Agda.Compiler.Backend

Interface for compiler backend writers.

Documentation

data Backend where

Constructors

Backend :: Backend' opts env menv mod def -> Backend

data Backend' opts env menv mod def

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

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

data Recompile menv mod

Constructors

Recompile menv

Skip mod

data IsMain

Constructors

IsMain

NotMain

Instances

Eq IsMain

Defined in Agda.Compiler.Common

Methods

(==) :: IsMain -> IsMain -> Bool

(/=) :: IsMain -> IsMain -> Bool

Show IsMain

Defined in Agda.Compiler.Common

Methods

showsPrec :: Int -> IsMain -> ShowS

show :: IsMain -> String

showList :: [IsMain] -> ShowS

Semigroup IsMain

Conjunctive semigroup (NotMain is absorbing).

Defined in Agda.Compiler.Common

Methods

(<>) :: IsMain -> IsMain -> IsMain

sconcat :: NonEmpty IsMain -> IsMain

stimes :: Integral b => b -> IsMain -> IsMain

Monoid IsMain

Defined in Agda.Compiler.Common

Methods

mempty :: IsMain

mappend :: IsMain -> IsMain -> IsMain

mconcat :: [IsMain] -> IsMain

type Flag opts = opts -> OptM opts

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)

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

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

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

builtinSetOmega :: String

builtinFromNat :: String

builtinFromNeg :: String

builtinFromString :: String

builtinQName :: String

builtinAgdaSort :: String

builtinAgdaSortSet :: String

builtinAgdaSortLit :: String

builtinAgdaSortUnsupported :: String

builtinHiding :: String

builtinHidden :: String

builtinInstance :: String

builtinVisible :: String

builtinRelevance :: String

builtinRelevant :: String

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

builtinAgdaTCMIsMacro :: String

builtinAgdaTCMWithNormalisation :: String

builtinAgdaTCMDebugPrint :: String

builtinAgdaTCMNoConstraints :: String

builtinAgdaTCMRunSpeculative :: String

builtinsNoDef :: [String]

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.

{--}

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

sizeBuiltins :: [String]

data Polarity

Polarity for equality and subtype checking.

Constructors

Covariant

monotone

Contravariant

antitone

Invariant

no information (mixed variance)

Nonvariant

constant

Instances

Eq Polarity

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: Polarity -> Polarity -> Bool

(/=) :: Polarity -> Polarity -> Bool

Data Polarity

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

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

toConstr :: Polarity -> Constr

dataTypeOf :: Polarity -> DataType

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

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

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

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

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

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

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

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

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

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

Show Polarity

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Polarity -> ShowS

show :: Polarity -> String

showList :: [Polarity] -> ShowS

Pretty Polarity

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Polarity -> Doc

prettyPrec :: Int -> Polarity -> Doc

prettyList :: [Polarity] -> Doc

KillRange Polarity

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Polarity

EmbPrj Polarity

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Polarity -> S Int32

icod_ :: Polarity -> S Int32

value :: Int32 -> R Polarity

PrettyTCM Polarity

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Polarity -> m Doc

Abstract [Polarity]

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> [Polarity] -> [Polarity]

Apply [Polarity]

Defined in Agda.TypeChecking.Substitute

Methods

apply :: [Polarity] -> Args -> [Polarity]

applyE :: [Polarity] -> Elims -> [Polarity]

newtype ProblemId

Constructors

ProblemId Nat

Instances

Enum ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: ProblemId -> ProblemId

pred :: ProblemId -> ProblemId

toEnum :: Int -> ProblemId

fromEnum :: ProblemId -> Int

enumFrom :: ProblemId -> [ProblemId]

enumFromThen :: ProblemId -> ProblemId -> [ProblemId]

enumFromTo :: ProblemId -> ProblemId -> [ProblemId]

enumFromThenTo :: ProblemId -> ProblemId -> ProblemId -> [ProblemId]

Eq ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: ProblemId -> ProblemId -> Bool

(/=) :: ProblemId -> ProblemId -> Bool

Integral ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

quot :: ProblemId -> ProblemId -> ProblemId

rem :: ProblemId -> ProblemId -> ProblemId

div :: ProblemId -> ProblemId -> ProblemId

mod :: ProblemId -> ProblemId -> ProblemId

quotRem :: ProblemId -> ProblemId -> (ProblemId, ProblemId)

divMod :: ProblemId -> ProblemId -> (ProblemId, ProblemId)

toInteger :: ProblemId -> Integer

Data ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProblemId -> c ProblemId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ProblemId

toConstr :: ProblemId -> Constr

dataTypeOf :: ProblemId -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ProblemId)

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

gmapT :: (forall b. Data b => b -> b) -> ProblemId -> ProblemId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProblemId -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProblemId -> r

gmapQ :: (forall d. Data d => d -> u) -> ProblemId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProblemId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProblemId -> m ProblemId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProblemId -> m ProblemId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProblemId -> m ProblemId

Num ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

(+) :: ProblemId -> ProblemId -> ProblemId

(-) :: ProblemId -> ProblemId -> ProblemId

(*) :: ProblemId -> ProblemId -> ProblemId

negate :: ProblemId -> ProblemId

abs :: ProblemId -> ProblemId

signum :: ProblemId -> ProblemId

fromInteger :: Integer -> ProblemId

Ord ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: ProblemId -> ProblemId -> Ordering

(<) :: ProblemId -> ProblemId -> Bool

(<=) :: ProblemId -> ProblemId -> Bool

(>) :: ProblemId -> ProblemId -> Bool

(>=) :: ProblemId -> ProblemId -> Bool

max :: ProblemId -> ProblemId -> ProblemId

min :: ProblemId -> ProblemId -> ProblemId

Real ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

toRational :: ProblemId -> Rational

Show ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> ProblemId -> ShowS

show :: ProblemId -> String

showList :: [ProblemId] -> ShowS

Pretty ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: ProblemId -> Doc

prettyPrec :: Int -> ProblemId -> Doc

prettyList :: [ProblemId] -> Doc

HasFresh ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' ProblemId TCState

nextFresh' :: ProblemId -> ProblemId

PrettyTCM ProblemId

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => ProblemId -> m Doc

ToJSON ProblemId

Defined in Agda.Interaction.JSONTop

Methods

toJSON :: ProblemId -> Value

toEncoding :: ProblemId -> Encoding

toJSONList :: [ProblemId] -> Value

toEncodingList :: [ProblemId] -> Encoding

EncodeTCM ProblemId

Defined in Agda.Interaction.JSONTop

Methods

encodeTCM :: ProblemId -> TCM Value

Monad m => MonadFresh ProblemId (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

fresh :: PureConversionT m ProblemId

data Comparison

Constructors

CmpEq

CmpLeq

Instances

Eq Comparison

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: Comparison -> Comparison -> Bool

(/=) :: Comparison -> Comparison -> Bool

Data Comparison

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

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

toConstr :: Comparison -> Constr

dataTypeOf :: Comparison -> DataType

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

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

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

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

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

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

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

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

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

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

Show Comparison

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Comparison -> ShowS

show :: Comparison -> String

showList :: [Comparison] -> ShowS

Pretty Comparison

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Comparison -> Doc

prettyPrec :: Int -> Comparison -> Doc

prettyList :: [Comparison] -> Doc

PrettyTCM Comparison

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Comparison -> m Doc

type BackendName = String

type ModuleToSource = Map TopLevelModuleName AbsolutePath

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

type TCM = TCMT IO

Type checking monad.

newtype TCMT m a

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

Constructors

TCM

Fields

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

Instances

MonadTrans TCMT

Defined in Agda.TypeChecking.Monad.Base

Methods

lift :: Monad m => m a -> TCMT m a

CatchImpossible TCM

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.

Defined in Agda.TypeChecking.Monad.Base

Methods

catchImpossible :: TCM a -> (Impossible -> TCM a) -> TCM a

catchImpossibleJust :: (Impossible -> Maybe b) -> TCM a -> (b -> TCM a) -> TCM a

handleImpossible :: (Impossible -> TCM a) -> TCM a -> TCM a

handleImpossibleJust :: (Impossible -> Maybe b) -> (b -> TCM a) -> TCM a -> TCM a

MonadFixityError ScopeM

Defined in Agda.Syntax.Scope.Monad

Methods

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

throwMultiplePolarityPragmas :: [Name] -> ScopeM a

warnUnknownNamesInFixityDecl :: [Name] -> ScopeM ()

warnUnknownNamesInPolarityPragmas :: [Name] -> ScopeM ()

warnUnknownFixityInMixfixDecl :: [Name] -> ScopeM ()

warnPolarityPragmasButNotPostulates :: [Name] -> ScopeM ()

MonadStConcreteNames TCM

Defined in Agda.TypeChecking.Monad.Base

Methods

runStConcreteNames :: StateT ConcreteNames TCM a -> TCM a

useConcreteNames :: TCM ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> TCM ()

MonadInteractionPoints TCM

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

freshInteractionId :: TCM InteractionId

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> TCM ()

MonadAddContext TCM

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> TCM a -> TCM a

addLetBinding' :: Name -> Term -> Dom Type -> TCM a -> TCM a

updateContext :: Substitution -> (Context -> Context) -> TCM a -> TCM a

withFreshName :: Range -> ArgName -> (Name -> TCM a) -> TCM a

MonadDebug TCM

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> TCM ()

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

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

getVerbosity :: TCM Verbosity

isDebugPrinting :: TCM Bool

nowDebugPrinting :: TCM a -> TCM a

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

MonadStatistics TCM

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> TCM ()

MonadWarning TCM

Defined in Agda.TypeChecking.Warnings

Methods

addWarning :: TCWarning -> TCM ()

MonadConstraint TCM

Defined in Agda.TypeChecking.Constraints

Methods

addConstraint :: Constraint -> TCM ()

addAwakeConstraint :: Constraint -> TCM ()

catchPatternErr :: TCM a -> TCM a -> TCM a

solveConstraint :: Constraint -> TCM ()

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

wakeConstraints :: (ProblemConstraint -> TCM Bool) -> TCM ()

stealConstraints :: ProblemId -> TCM ()

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

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

MonadMetaSolver TCM

Defined in Agda.TypeChecking.MetaVars

Methods

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

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

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

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

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

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

MonadError TCErr TCM

Defined in Agda.TypeChecking.Monad.Base

Methods

throwError :: TCErr -> TCM a

catchError :: TCM a -> (TCErr -> TCM a) -> TCM a

MonadError TCErr IM

Defined in Agda.TypeChecking.Monad.Base

Methods

throwError :: TCErr -> IM a

catchError :: IM a -> (TCErr -> IM a) -> IM a

MonadBench Phase TCM

We store benchmark statistics in an IORef. This enables benchmarking pure computation, see Agda.Benchmarking.

Defined in Agda.TypeChecking.Monad.Base

Methods

getBenchmark :: TCM (Benchmark Phase)

getsBenchmark :: (Benchmark Phase -> c) -> TCM c

putBenchmark :: Benchmark Phase -> TCM ()

modifyBenchmark :: (Benchmark Phase -> Benchmark Phase) -> TCM ()

finally :: TCM b -> TCM c -> TCM b

HasFresh i => MonadFresh i TCM

Defined in Agda.TypeChecking.Monad.Base

Methods

fresh :: TCM i

Conversion TOM Clause (Maybe ([Pat O], MExp O))

Defined in Agda.Auto.Convert

Methods

convert :: Clause -> TOM (Maybe ([Pat O], MExp O))

Conversion TOM Type (MExp O)

Defined in Agda.Auto.Convert

Methods

convert :: Type -> TOM (MExp O)

Conversion TOM Term (MExp O)

Defined in Agda.Auto.Convert

Methods

convert :: Term -> TOM (MExp O)

Conversion TOM Args (MM (ArgList O) (RefInfo O))

Defined in Agda.Auto.Convert

Methods

convert :: Args -> TOM (MM (ArgList O) (RefInfo O))

Conversion TOM [Clause] [([Pat O], MExp O)]

Defined in Agda.Auto.Convert

Methods

convert :: [Clause] -> TOM [([Pat O], MExp O)]

Conversion TOM (Arg Pattern) (Pat O)

Defined in Agda.Auto.Convert

Methods

convert :: Arg Pattern -> TOM (Pat O)

Conversion TOM a b => Conversion TOM (Arg a) (Hiding, b)

Defined in Agda.Auto.Convert

Methods

convert :: Arg a -> TOM (Hiding, b)

MonadIO m => Monad (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

(>>=) :: TCMT m a -> (a -> TCMT m b) -> TCMT m b

(>>) :: TCMT m a -> TCMT m b -> TCMT m b

return :: a -> TCMT m a

MonadIO m => Functor (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> TCMT m a -> TCMT m b

(<$) :: a -> TCMT m b -> TCMT m a

MonadIO m => MonadFail (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

fail :: String -> TCMT m a

MonadIO m => Applicative (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pure :: a -> TCMT m a

(<*>) :: TCMT m (a -> b) -> TCMT m a -> TCMT m b

liftA2 :: (a -> b -> c) -> TCMT m a -> TCMT m b -> TCMT m c

(*>) :: TCMT m a -> TCMT m b -> TCMT m b

(<*) :: TCMT m a -> TCMT m b -> TCMT m a

Semigroup (TCM Doc)

Defined in Agda.TypeChecking.Warnings

Methods

(<>) :: TCM Doc -> TCM Doc -> TCM Doc

sconcat :: NonEmpty (TCM Doc) -> TCM Doc

stimes :: Integral b => b -> TCM Doc -> TCM Doc

MonadIO m => MonadIO (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftIO :: IO a -> TCMT m a

Null (TCM Doc)

Defined in Agda.TypeChecking.Monad.Base

Methods

empty :: TCM Doc

null :: TCM Doc -> Bool

MonadIO m => MonadTCM (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> TCMT m a

MonadIO m => MonadTCState (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: TCMT m TCState

putTC :: TCState -> TCMT m ()

modifyTC :: (TCState -> TCState) -> TCMT m ()

MonadIO m => MonadTCEnv (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: TCMT m TCEnv

localTC :: (TCEnv -> TCEnv) -> TCMT m a -> TCMT m a

MonadIO m => MonadReduce (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> TCMT m a

MonadIO m => HasOptions (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: TCMT m PragmaOptions

commandLineOptions :: TCMT m CommandLineOptions

MonadIO m => ReadTCState (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: TCMT m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> TCMT m b -> TCMT m b

withTCState :: (TCState -> TCState) -> TCMT m a -> TCMT m a

MonadIO m => HasBuiltins (TCMT m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> TCMT m (Maybe (Builtin PrimFun))

TraceS [TCM Doc]

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m c -> m c

TraceS (TCM Doc)

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m c -> m c

ReportS [TCM Doc]

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m ()

ReportS (TCM Doc)

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m ()

HasConstInfo (TCMT IO)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> TCMT IO Definition

getConstInfo' :: QName -> TCMT IO (Either SigError Definition)

getRewriteRulesFor :: QName -> TCMT IO RewriteRules

(IsString a, MonadIO m) => IsString (TCMT m a)

Defined in Agda.TypeChecking.Monad.Base

Methods

fromString :: String -> TCMT m a

(MonadIO m, Semigroup a) => Semigroup (TCMT m a)

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.

Defined in Agda.TypeChecking.Monad.Base

Methods

(<>) :: TCMT m a -> TCMT m a -> TCMT m a

sconcat :: NonEmpty (TCMT m a) -> TCMT m a

stimes :: Integral b => b -> TCMT m a -> TCMT m a

(MonadIO m, Semigroup a, Monoid a) => Monoid (TCMT m a)

Strict (non-shortcut) monoid.

Defined in Agda.TypeChecking.Monad.Base

Methods

mempty :: TCMT m a

mappend :: TCMT m a -> TCMT m a -> TCMT m a

mconcat :: [TCMT m a] -> TCMT m a

data TCState

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

Show TCState

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> TCState -> ShowS

show :: TCState -> String

showList :: [TCState] -> ShowS

LensPersistentVerbosity TCState

Defined in Agda.Interaction.Options.Lenses

Methods

getPersistentVerbosity :: TCState -> PersistentVerbosity

setPersistentVerbosity :: PersistentVerbosity -> TCState -> TCState

mapPersistentVerbosity :: (PersistentVerbosity -> PersistentVerbosity) -> TCState -> TCState

LensIncludePaths TCState

Defined in Agda.Interaction.Options.Lenses

Methods

getIncludePaths :: TCState -> [FilePath]

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

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

getAbsoluteIncludePaths :: TCState -> [AbsolutePath]

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

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

LensSafeMode TCState

Defined in Agda.Interaction.Options.Lenses

Methods

getSafeMode :: TCState -> SafeMode

setSafeMode :: SafeMode -> TCState -> TCState

mapSafeMode :: (SafeMode -> SafeMode) -> TCState -> TCState

LensCommandLineOptions TCState

Defined in Agda.Interaction.Options.Lenses

Methods

getCommandLineOptions :: TCState -> CommandLineOptions

setCommandLineOptions :: CommandLineOptions -> TCState -> TCState

mapCommandLineOptions :: (CommandLineOptions -> CommandLineOptions) -> TCState -> TCState

LensVerbosity TCState

Defined in Agda.Interaction.Options.Lenses

Methods

getVerbosity :: TCState -> Verbosity

setVerbosity :: Verbosity -> TCState -> TCState

mapVerbosity :: (Verbosity -> Verbosity) -> TCState -> TCState

LensPragmaOptions TCState

Defined in Agda.Interaction.Options.Lenses

Methods

getPragmaOptions :: TCState -> PragmaOptions

setPragmaOptions :: PragmaOptions -> TCState -> TCState

mapPragmaOptions :: (PragmaOptions -> PragmaOptions) -> TCState -> TCState

lensPragmaOptions :: Lens' PragmaOptions TCState

data TCEnv

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]

  to detect import cycles

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

• 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
• envModuleNestingLevel :: !Int

  This number indicates how far away from the top-level module Agda has come when chasing modules. 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.

• 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
• envInjectivityDepth :: Int

  Injectivity can cause non-termination for unsolvable contraints (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.

• envCheckOptionConsistency :: Bool

  Do we check that options in imported files are consistent with each other?

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

Instances

Data TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TCEnv -> c TCEnv

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TCEnv

toConstr :: TCEnv -> Constr

dataTypeOf :: TCEnv -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TCEnv)

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

gmapT :: (forall b. Data b => b -> b) -> TCEnv -> TCEnv

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TCEnv -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TCEnv -> r

gmapQ :: (forall d. Data d => d -> u) -> TCEnv -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TCEnv -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TCEnv -> m TCEnv

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TCEnv -> m TCEnv

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TCEnv -> m TCEnv

LensIsAbstract TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

lensIsAbstract :: Lens' IsAbstract TCEnv

LensRelevance TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

getRelevance :: TCEnv -> Relevance

setRelevance :: Relevance -> TCEnv -> TCEnv

mapRelevance :: (Relevance -> Relevance) -> TCEnv -> TCEnv

LensQuantity TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

getQuantity :: TCEnv -> Quantity

setQuantity :: Quantity -> TCEnv -> TCEnv

mapQuantity :: (Quantity -> Quantity) -> TCEnv -> TCEnv

LensModality TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

getModality :: TCEnv -> Modality

setModality :: Modality -> TCEnv -> TCEnv

mapModality :: (Modality -> Modality) -> TCEnv -> TCEnv

LensTCEnv TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

lensTCEnv :: Lens' TCEnv TCEnv

data HighlightingLevel

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

Eq HighlightingLevel

Defined in Agda.TypeChecking.Monad.Base

Methods

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

(/=) :: HighlightingLevel -> HighlightingLevel -> Bool

Data HighlightingLevel

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

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

toConstr :: HighlightingLevel -> Constr

dataTypeOf :: HighlightingLevel -> DataType

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

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

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

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

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

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

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

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

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

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

Ord HighlightingLevel

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: HighlightingLevel -> HighlightingLevel -> Ordering

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

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

(>) :: HighlightingLevel -> HighlightingLevel -> Bool

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

max :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel

min :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel

Read HighlightingLevel

Defined in Agda.TypeChecking.Monad.Base

Methods

readsPrec :: Int -> ReadS HighlightingLevel

readList :: ReadS [HighlightingLevel]

readPrec :: ReadPrec HighlightingLevel

readListPrec :: ReadPrec [HighlightingLevel]

Show HighlightingLevel

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> HighlightingLevel -> ShowS

show :: HighlightingLevel -> String

showList :: [HighlightingLevel] -> ShowS

data HighlightingMethod

How should highlighting be sent to the user interface?

Constructors

Direct

Via stdout.

Indirect

Both via files and via stdout.

Instances

Eq HighlightingMethod

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: HighlightingMethod -> HighlightingMethod -> Bool

(/=) :: HighlightingMethod -> HighlightingMethod -> Bool

Data HighlightingMethod

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

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

toConstr :: HighlightingMethod -> Constr

dataTypeOf :: HighlightingMethod -> DataType

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

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

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

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

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

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

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

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

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

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

Read HighlightingMethod

Defined in Agda.TypeChecking.Monad.Base

Methods

readsPrec :: Int -> ReadS HighlightingMethod

readList :: ReadS [HighlightingMethod]

readPrec :: ReadPrec HighlightingMethod

readListPrec :: ReadPrec [HighlightingMethod]

Show HighlightingMethod

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> HighlightingMethod -> ShowS

show :: HighlightingMethod -> String

showList :: [HighlightingMethod] -> ShowS

data NamedMeta

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

Constructors

NamedMeta

Fields

• nmSuggestion :: MetaNameSuggestion
• nmid :: MetaId

Instances

Pretty NamedMeta

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: NamedMeta -> Doc

prettyPrec :: Int -> NamedMeta -> Doc

prettyList :: [NamedMeta] -> Doc

ToConcrete NamedMeta Expr

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

toConcrete :: NamedMeta -> AbsToCon Expr

bindToConcrete :: NamedMeta -> (Expr -> AbsToCon b) -> AbsToCon b

data TCWarning

Constructors

TCWarning

Fields

• 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

Eq TCWarning

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: TCWarning -> TCWarning -> Bool

(/=) :: TCWarning -> TCWarning -> Bool

Show TCWarning

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> TCWarning -> ShowS

show :: TCWarning -> String

showList :: [TCWarning] -> ShowS

HasRange TCWarning

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: TCWarning -> Range

EmbPrj TCWarning

Defined in Agda.TypeChecking.Serialise.Instances.Errors

Methods

icode :: TCWarning -> S Int32

icod_ :: TCWarning -> S Int32

value :: Int32 -> R TCWarning

PrettyTCM TCWarning

Defined in Agda.TypeChecking.Pretty.Warning

Methods

prettyTCM :: MonadPretty m => TCWarning -> m Doc

data TCErr

Type-checking errors.

Constructors

TypeError

Fields

• 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

The exception which is usually caught. Raised for pattern violations during unification (assignV) but also in other situations where we want to backtrack.

Instances

Show TCErr

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> TCErr -> ShowS

show :: TCErr -> String

showList :: [TCErr] -> ShowS

Exception TCErr

Defined in Agda.TypeChecking.Monad.Base

Methods

toException :: TCErr -> SomeException

fromException :: SomeException -> Maybe TCErr

displayException :: TCErr -> String

Error TCErr

Defined in Agda.TypeChecking.Monad.Base

Methods

noMsg :: TCErr

strMsg :: String -> TCErr

HasRange TCErr

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: TCErr -> Range

PrettyTCM TCErr

Defined in Agda.TypeChecking.Errors

Methods

prettyTCM :: MonadPretty m => TCErr -> m Doc

MonadError TCErr TCM

Defined in Agda.TypeChecking.Monad.Base

Methods

throwError :: TCErr -> TCM a

catchError :: TCM a -> (TCErr -> TCM a) -> TCM a

MonadError TCErr IM

Defined in Agda.TypeChecking.Monad.Base

Methods

throwError :: TCErr -> IM a

catchError :: IM a -> (TCErr -> IM a) -> IM a

MonadError TCErr TerM

Defined in Agda.Termination.Monad

Methods

throwError :: TCErr -> TerM a

catchError :: TerM a -> (TCErr -> TerM a) -> TerM a

Monad m => MonadError TCErr (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

throwError :: TCErr -> PureConversionT m a

catchError :: PureConversionT m a -> (TCErr -> PureConversionT m a) -> PureConversionT m a

data Warning

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

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

UselessPublic

If the user opens a module public before the module header. (See issue #2377.)

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. Generic warnings for one-off things

GenericWarning Doc

Harmless generic warning (not an error)

GenericNonFatalError Doc

Generic error which doesn't abort proceedings (not a warning) Safe flag errors

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 String

User-defined warning (e.g. to mention that a name is deprecated)

FixityInRenamingModule (NonEmpty Range)

Fixity of modules cannot be changed via renaming (since modules have no fixity).

ModuleDoesntExport QName [ImportedName]

Some imported names are not actually exported by the source module

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

PragmaCompileErased BackendName QName

COMPILE directive for an erased symbol

NotInScopeW [QName]

Out of scope error we can recover from

Instances

Data Warning

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Warning -> c Warning

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Warning

toConstr :: Warning -> Constr

dataTypeOf :: Warning -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Warning)

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

gmapT :: (forall b. Data b => b -> b) -> Warning -> Warning

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Warning -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Warning -> r

gmapQ :: (forall d. Data d => d -> u) -> Warning -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Warning -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Warning -> m Warning

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Warning -> m Warning

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Warning -> m Warning

Show Warning

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Warning -> ShowS

show :: Warning -> String

showList :: [Warning] -> ShowS

EmbPrj Warning

Defined in Agda.TypeChecking.Serialise.Instances.Errors

Methods

icode :: Warning -> S Int32

icod_ :: Warning -> S Int32

value :: Int32 -> R Warning

PrettyTCM Warning

Defined in Agda.TypeChecking.Pretty.Warning

Methods

prettyTCM :: MonadPretty m => Warning -> m Doc

type Verbosity = Trie VerboseKey VerboseLevel

type VerboseLevel = Int

type VerboseKey = String

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

Embedding a TCM computation.

Minimal complete definition

Nothing

Methods

liftTCM :: TCM a -> tcm a

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

Instances

MonadTCM TerM

Defined in Agda.Termination.Monad

Methods

liftTCM :: TCM a -> TerM a

MonadTCM tcm => MonadTCM (MaybeT tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> MaybeT tcm a

MonadTCM tcm => MonadTCM (ListT tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> ListT tcm a

MonadIO m => MonadTCM (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> TCMT m a

MonadTCM tcm => MonadTCM (ChangeT tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> ChangeT tcm a

MonadTCM m => MonadTCM (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

liftTCM :: TCM a -> NamesT m a

MonadTCM tcm => MonadTCM (ExceptT err tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> ExceptT err tcm a

MonadTCM tcm => MonadTCM (ReaderT r tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> ReaderT r tcm a

MonadTCM tcm => MonadTCM (IdentityT tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> IdentityT tcm a

MonadTCM tcm => MonadTCM (StateT s tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> StateT s tcm a

(Monoid w, MonadTCM tcm) => MonadTCM (WriterT w tcm)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftTCM :: TCM a -> WriterT w tcm a

type IM = TCMT (InputT IO)

Interaction monad.

class Monad m => MonadTCState m where

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

Minimal complete definition

getTC, (putTC | modifyTC)

Methods

getTC :: m TCState

putTC :: TCState -> m ()

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

Instances

MonadTCState TerM

Defined in Agda.Termination.Monad

Methods

getTC :: TerM TCState

putTC :: TCState -> TerM ()

modifyTC :: (TCState -> TCState) -> TerM ()

MonadTCState m => MonadTCState (MaybeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: MaybeT m TCState

putTC :: TCState -> MaybeT m ()

modifyTC :: (TCState -> TCState) -> MaybeT m ()

MonadTCState m => MonadTCState (ListT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: ListT m TCState

putTC :: TCState -> ListT m ()

modifyTC :: (TCState -> TCState) -> ListT m ()

MonadIO m => MonadTCState (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: TCMT m TCState

putTC :: TCState -> TCMT m ()

modifyTC :: (TCState -> TCState) -> TCMT m ()

MonadTCState m => MonadTCState (ChangeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: ChangeT m TCState

putTC :: TCState -> ChangeT m ()

modifyTC :: (TCState -> TCState) -> ChangeT m ()

MonadTCState m => MonadTCState (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

getTC :: NamesT m TCState

putTC :: TCState -> NamesT m ()

modifyTC :: (TCState -> TCState) -> NamesT m ()

MonadTCState m => MonadTCState (ExceptT err m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: ExceptT err m TCState

putTC :: TCState -> ExceptT err m ()

modifyTC :: (TCState -> TCState) -> ExceptT err m ()

MonadTCState m => MonadTCState (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: ReaderT r m TCState

putTC :: TCState -> ReaderT r m ()

modifyTC :: (TCState -> TCState) -> ReaderT r m ()

MonadTCState m => MonadTCState (IdentityT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: IdentityT m TCState

putTC :: TCState -> IdentityT m ()

modifyTC :: (TCState -> TCState) -> IdentityT m ()

MonadTCState m => MonadTCState (StateT s m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: StateT s m TCState

putTC :: TCState -> StateT s m ()

modifyTC :: (TCState -> TCState) -> StateT s m ()

(Monoid w, MonadTCState m) => MonadTCState (WriterT w m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTC :: WriterT w m TCState

putTC :: TCState -> WriterT w m ()

modifyTC :: (TCState -> TCState) -> WriterT w m ()

class Monad m => MonadTCEnv m where

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

Methods

askTC :: m TCEnv

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

Instances

MonadTCEnv ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: ReduceM TCEnv

localTC :: (TCEnv -> TCEnv) -> ReduceM a -> ReduceM a

MonadTCEnv AbsToCon

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

askTC :: AbsToCon TCEnv

localTC :: (TCEnv -> TCEnv) -> AbsToCon a -> AbsToCon a

MonadTCEnv TerM

Defined in Agda.Termination.Monad

Methods

askTC :: TerM TCEnv

localTC :: (TCEnv -> TCEnv) -> TerM a -> TerM a

MonadTCEnv m => MonadTCEnv (MaybeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: MaybeT m TCEnv

localTC :: (TCEnv -> TCEnv) -> MaybeT m a -> MaybeT m a

MonadTCEnv m => MonadTCEnv (ListT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: ListT m TCEnv

localTC :: (TCEnv -> TCEnv) -> ListT m a -> ListT m a

MonadIO m => MonadTCEnv (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: TCMT m TCEnv

localTC :: (TCEnv -> TCEnv) -> TCMT m a -> TCMT m a

MonadTCEnv m => MonadTCEnv (ChangeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: ChangeT m TCEnv

localTC :: (TCEnv -> TCEnv) -> ChangeT m a -> ChangeT m a

MonadTCEnv m => MonadTCEnv (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

askTC :: NamesT m TCEnv

localTC :: (TCEnv -> TCEnv) -> NamesT m a -> NamesT m a

MonadTCEnv m => MonadTCEnv (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

askTC :: PureConversionT m TCEnv

localTC :: (TCEnv -> TCEnv) -> PureConversionT m a -> PureConversionT m a

MonadTCEnv m => MonadTCEnv (ExceptT err m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: ExceptT err m TCEnv

localTC :: (TCEnv -> TCEnv) -> ExceptT err m a -> ExceptT err m a

MonadTCEnv m => MonadTCEnv (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: ReaderT r m TCEnv

localTC :: (TCEnv -> TCEnv) -> ReaderT r m a -> ReaderT r m a

MonadTCEnv m => MonadTCEnv (IdentityT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: IdentityT m TCEnv

localTC :: (TCEnv -> TCEnv) -> IdentityT m a -> IdentityT m a

MonadTCEnv m => MonadTCEnv (StateT s m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: StateT s m TCEnv

localTC :: (TCEnv -> TCEnv) -> StateT s m a -> StateT s m a

(Monoid w, MonadTCEnv m) => MonadTCEnv (WriterT w m)

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: WriterT w m TCEnv

localTC :: (TCEnv -> TCEnv) -> WriterT w m a -> WriterT w m a

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

Methods

liftReduce :: ReduceM a -> m a

Instances

MonadReduce ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> ReduceM a

MonadReduce TerM

Defined in Agda.Termination.Monad

Methods

liftReduce :: ReduceM a -> TerM a

MonadReduce m => MonadReduce (MaybeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> MaybeT m a

MonadReduce m => MonadReduce (ListT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> ListT m a

MonadIO m => MonadReduce (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> TCMT m a

MonadReduce m => MonadReduce (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

liftReduce :: ReduceM a -> NamesT m a

MonadReduce m => MonadReduce (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

liftReduce :: ReduceM a -> PureConversionT m a

MonadReduce m => MonadReduce (ExceptT err m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> ExceptT err m a

MonadReduce m => MonadReduce (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> ReaderT r m a

MonadReduce m => MonadReduce (StateT w m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> StateT w m a

(Monoid w, MonadReduce m) => MonadReduce (WriterT w m)

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> WriterT w m a

newtype ReduceM a

Constructors

ReduceM

Fields

• unReduceM :: ReduceEnv -> a

Instances

Monad ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

(>>=) :: ReduceM a -> (a -> ReduceM b) -> ReduceM b

(>>) :: ReduceM a -> ReduceM b -> ReduceM b

return :: a -> ReduceM a

Functor ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> ReduceM a -> ReduceM b

(<$) :: a -> ReduceM b -> ReduceM a

MonadFail ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

fail :: String -> ReduceM a

Applicative ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

pure :: a -> ReduceM a

(<*>) :: ReduceM (a -> b) -> ReduceM a -> ReduceM b

liftA2 :: (a -> b -> c) -> ReduceM a -> ReduceM b -> ReduceM c

(*>) :: ReduceM a -> ReduceM b -> ReduceM b

(<*) :: ReduceM a -> ReduceM b -> ReduceM a

MonadTCEnv ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

askTC :: ReduceM TCEnv

localTC :: (TCEnv -> TCEnv) -> ReduceM a -> ReduceM a

MonadReduce ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

liftReduce :: ReduceM a -> ReduceM a

HasOptions ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: ReduceM PragmaOptions

commandLineOptions :: ReduceM CommandLineOptions

ReadTCState ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: ReduceM TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> ReduceM b -> ReduceM b

withTCState :: (TCState -> TCState) -> ReduceM a -> ReduceM a

MonadAddContext ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

addCtx :: Name -> Dom Type -> ReduceM a -> ReduceM a

addLetBinding' :: Name -> Term -> Dom Type -> ReduceM a -> ReduceM a

updateContext :: Substitution -> (Context -> Context) -> ReduceM a -> ReduceM a

withFreshName :: Range -> ArgName -> (Name -> ReduceM a) -> ReduceM a

HasBuiltins ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

getBuiltinThing :: String -> ReduceM (Maybe (Builtin PrimFun))

MonadDebug ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> ReduceM ()

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

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

getVerbosity :: ReduceM Verbosity

isDebugPrinting :: ReduceM Bool

nowDebugPrinting :: ReduceM a -> ReduceM a

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

HasConstInfo ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

getConstInfo :: QName -> ReduceM Definition

getConstInfo' :: QName -> ReduceM (Either SigError Definition)

getRewriteRulesFor :: QName -> ReduceM RewriteRules

data ReduceEnv

Environment of the reduce monad.

Constructors

ReduceEnv

Fields

• redEnv :: TCEnv

  Read only access to environment.

• redSt :: TCState

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

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

Minimal complete definition

Nothing

Methods

pragmaOptions :: m PragmaOptions

Returns the pragma options which are currently in effect.

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

commandLineOptions :: m CommandLineOptions

Returns the command line options which are currently in effect.

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

Instances

HasOptions ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: ReduceM PragmaOptions

commandLineOptions :: ReduceM CommandLineOptions

HasOptions AbsToCon

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

pragmaOptions :: AbsToCon PragmaOptions

commandLineOptions :: AbsToCon CommandLineOptions

HasOptions TerM

Defined in Agda.Termination.Monad

Methods

pragmaOptions :: TerM PragmaOptions

commandLineOptions :: TerM CommandLineOptions

HasOptions m => HasOptions (MaybeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: MaybeT m PragmaOptions

commandLineOptions :: MaybeT m CommandLineOptions

HasOptions m => HasOptions (ListT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: ListT m PragmaOptions

commandLineOptions :: ListT m CommandLineOptions

MonadIO m => HasOptions (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: TCMT m PragmaOptions

commandLineOptions :: TCMT m CommandLineOptions

HasOptions m => HasOptions (ChangeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: ChangeT m PragmaOptions

commandLineOptions :: ChangeT m CommandLineOptions

HasOptions m => HasOptions (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

pragmaOptions :: NamesT m PragmaOptions

commandLineOptions :: NamesT m CommandLineOptions

HasOptions m => HasOptions (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

pragmaOptions :: PureConversionT m PragmaOptions

commandLineOptions :: PureConversionT m CommandLineOptions

HasOptions m => HasOptions (ExceptT e m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: ExceptT e m PragmaOptions

commandLineOptions :: ExceptT e m CommandLineOptions

HasOptions m => HasOptions (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: ReaderT r m PragmaOptions

commandLineOptions :: ReaderT r m CommandLineOptions

HasOptions m => HasOptions (IdentityT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: IdentityT m PragmaOptions

commandLineOptions :: IdentityT m CommandLineOptions

HasOptions m => HasOptions (StateT s m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: StateT s m PragmaOptions

commandLineOptions :: StateT s m CommandLineOptions

(HasOptions m, Monoid w) => HasOptions (WriterT w m)

Defined in Agda.TypeChecking.Monad.Base

Methods

pragmaOptions :: WriterT w m PragmaOptions

commandLineOptions :: WriterT w m CommandLineOptions

data LHSOrPatSyn

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

Constructors

IsLHS

IsPatSyn

Instances

Eq LHSOrPatSyn

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: LHSOrPatSyn -> LHSOrPatSyn -> Bool

(/=) :: LHSOrPatSyn -> LHSOrPatSyn -> Bool

Show LHSOrPatSyn

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> LHSOrPatSyn -> ShowS

show :: LHSOrPatSyn -> String

showList :: [LHSOrPatSyn] -> ShowS

data TypeError

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

IlltypedPattern Pattern Type

IllformedProjectionPattern Pattern

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

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

BuiltinMustBeConstructor String Expr

NoSuchBuiltinName String

DuplicateBuiltinBinding String Term Term

NoBindingForBuiltin String

NoSuchPrimitiveFunction String

DuplicatePrimitiveBinding String QName QName

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 not 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 (NonEmpty QName)

AmbiguousModule QName (NonEmpty ModuleName)

ClashingDefinition QName QName

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 (NonEmpty (QName, PatternSynDefn))

UnusedVariableInPatternSynonym

NoParseForApplication [Expr]

AmbiguousParseForApplication [Expr] [Expr]

NoParseForLHS LHSOrPatSyn Pattern

AmbiguousParseForLHS LHSOrPatSyn Pattern [Pattern]

OperatorInformation [NotationSection] TypeError

InstanceNoCandidate Type [(Term, TCErr)]

UnquoteFailed UnquoteError

DeBruijnIndexOutOfScope Nat Telescope [Name]

NeedOptionCopatterns

NeedOptionRewriting

NeedOptionProp

NonFatalErrors [TCWarning]

InstanceSearchDepthExhausted Term Type Int

TriedToCopyConstrainedPrim QName

Instances

Show TypeError

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> TypeError -> ShowS

show :: TypeError -> String

showList :: [TypeError] -> ShowS

PrettyTCM TypeError

Defined in Agda.TypeChecking.Errors

Methods

prettyTCM :: MonadPretty m => TypeError -> m Doc

data UnquoteError

Constructors

BadVisibility String (Arg Term)

ConInsteadOfDef QName String String

DefInsteadOfCon QName String String

NonCanonical String Term

BlockedOnMeta TCState MetaId

UnquotePanic String

Instances

Show UnquoteError

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> UnquoteError -> ShowS

show :: UnquoteError -> String

showList :: [UnquoteError] -> ShowS

data UnificationFailure

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

Show UnificationFailure

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> UnificationFailure -> ShowS

show :: UnificationFailure -> String

showList :: [UnificationFailure] -> ShowS

PrettyTCM UnificationFailure

Defined in Agda.TypeChecking.Errors

Methods

prettyTCM :: MonadPretty m => UnificationFailure -> m Doc

data NegativeUnification

Constructors

UnifyConflict Telescope Term Term

UnifyCycle Telescope Int Term

Instances

Show NegativeUnification

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> NegativeUnification -> ShowS

show :: NegativeUnification -> String

showList :: [NegativeUnification] -> ShowS

PrettyTCM NegativeUnification

Defined in Agda.TypeChecking.Errors

Methods

prettyTCM :: MonadPretty m => NegativeUnification -> m Doc

data SplitError

Error when splitting a pattern variable into possible constructor patterns.

Constructors

NotADatatype (Closure Type)

Neither data type nor record.

IrrelevantDatatype (Closure Type)

Data type, but in irrelevant position.

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

• 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

Show SplitError

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> SplitError -> ShowS

show :: SplitError -> String

showList :: [SplitError] -> ShowS

PrettyTCM SplitError

Defined in Agda.TypeChecking.Errors

Methods

prettyTCM :: MonadPretty m => SplitError -> m Doc

data TerminationError

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

Data TerminationError

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TerminationError -> c TerminationError

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TerminationError

toConstr :: TerminationError -> Constr

dataTypeOf :: TerminationError -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TerminationError)

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

gmapT :: (forall b. Data b => b -> b) -> TerminationError -> TerminationError

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TerminationError -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TerminationError -> r

gmapQ :: (forall d. Data d => d -> u) -> TerminationError -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TerminationError -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TerminationError -> m TerminationError

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TerminationError -> m TerminationError

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TerminationError -> m TerminationError

Show TerminationError

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> TerminationError -> ShowS

show :: TerminationError -> String

showList :: [TerminationError] -> ShowS

data CallInfo

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

Data CallInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CallInfo -> c CallInfo

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CallInfo

toConstr :: CallInfo -> Constr

dataTypeOf :: CallInfo -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CallInfo)

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

gmapT :: (forall b. Data b => b -> b) -> CallInfo -> CallInfo

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CallInfo -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CallInfo -> r

gmapQ :: (forall d. Data d => d -> u) -> CallInfo -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> CallInfo -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CallInfo -> m CallInfo

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CallInfo -> m CallInfo

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CallInfo -> m CallInfo

Show CallInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> CallInfo -> ShowS

show :: CallInfo -> String

showList :: [CallInfo] -> ShowS

Pretty CallInfo

We only show the name of the callee.

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: CallInfo -> Doc

prettyPrec :: Int -> CallInfo -> Doc

prettyList :: [CallInfo] -> Doc

AllNames CallInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

allNames :: CallInfo -> Seq QName

PrettyTCM CallInfo

Defined in Agda.TypeChecking.Pretty.Call

Methods

prettyTCM :: MonadPretty m => CallInfo -> m Doc

data Candidate

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

• candidateTerm :: Term
• candidateType :: Type
• candidateOverlappable :: Bool

Instances

Eq Candidate

Defined in Agda.TypeChecking.Substitute

Methods

(==) :: Candidate -> Candidate -> Bool

(/=) :: Candidate -> Candidate -> Bool

Data Candidate

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

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

toConstr :: Candidate -> Constr

dataTypeOf :: Candidate -> DataType

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

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

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

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

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

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

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

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

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

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

Show Candidate

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Candidate -> ShowS

show :: Candidate -> String

showList :: [Candidate] -> ShowS

Free Candidate

Defined in Agda.TypeChecking.Monad.Base

Methods

freeVars' :: IsVarSet a c => Candidate -> FreeM a c

InstantiateFull Candidate

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Candidate -> ReduceM Candidate

Normalise Candidate

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: Candidate -> ReduceM Candidate

Simplify Candidate

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: Candidate -> ReduceM Candidate

Reduce Candidate

Defined in Agda.TypeChecking.Reduce

Methods

reduce' :: Candidate -> ReduceM Candidate

reduceB' :: Candidate -> ReduceM (Blocked Candidate)

Instantiate Candidate

Defined in Agda.TypeChecking.Reduce

Methods

instantiate' :: Candidate -> ReduceM Candidate

Subst Term Candidate

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' Term -> Candidate -> Candidate

data ExpandHidden

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

Eq ExpandHidden

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: ExpandHidden -> ExpandHidden -> Bool

(/=) :: ExpandHidden -> ExpandHidden -> Bool

Data ExpandHidden

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

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

toConstr :: ExpandHidden -> Constr

dataTypeOf :: ExpandHidden -> DataType

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

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

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

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

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

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

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

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

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

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

data AbstractMode

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

Eq AbstractMode

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: AbstractMode -> AbstractMode -> Bool

(/=) :: AbstractMode -> AbstractMode -> Bool

Data AbstractMode

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

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

toConstr :: AbstractMode -> Constr

dataTypeOf :: AbstractMode -> DataType

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

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

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

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

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

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

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

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

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

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

Show AbstractMode

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> AbstractMode -> ShowS

show :: AbstractMode -> String

showList :: [AbstractMode] -> ShowS

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

type ContextEntry = Dom (Name, Type)

type Context = [ContextEntry]

The Context is a stack of ContextEntrys.

data UnquoteFlags

Constructors

UnquoteFlags

Fields

• _unquoteNormalise :: Bool

Instances

Data UnquoteFlags

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

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

toConstr :: UnquoteFlags -> Constr

dataTypeOf :: UnquoteFlags -> DataType

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

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

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

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

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

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

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

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

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

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

class LensTCEnv a where

Methods

lensTCEnv :: Lens' TCEnv a

Instances

LensTCEnv TCEnv

Defined in Agda.TypeChecking.Monad.Base

Methods

lensTCEnv :: Lens' TCEnv TCEnv

LensTCEnv (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

lensTCEnv :: Lens' TCEnv (Closure a)

data Builtin pf

Constructors

Builtin Term

Prim pf

Instances

Functor Builtin

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> Builtin a -> Builtin b

(<$) :: a -> Builtin b -> Builtin a

Foldable Builtin

Defined in Agda.TypeChecking.Monad.Base

Methods

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

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

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

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

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

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

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

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

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

toList :: Builtin a -> [a]

null :: Builtin a -> Bool

length :: Builtin a -> Int

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

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

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

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

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

Traversable Builtin

Defined in Agda.TypeChecking.Monad.Base

Methods

traverse :: Applicative f => (a -> f b) -> Builtin a -> f (Builtin b)

sequenceA :: Applicative f => Builtin (f a) -> f (Builtin a)

mapM :: Monad m => (a -> m b) -> Builtin a -> m (Builtin b)

sequence :: Monad m => Builtin (m a) -> m (Builtin a)

Show pf => Show (Builtin pf)

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Builtin pf -> ShowS

show :: Builtin pf -> String

showList :: [Builtin pf] -> ShowS

EmbPrj a => EmbPrj (Builtin a)

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Builtin a -> S Int32

icod_ :: Builtin a -> S Int32

value :: Int32 -> R (Builtin a)

InstantiateFull a => InstantiateFull (Builtin a)

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Builtin a -> ReduceM (Builtin a)

type BuiltinThings pf = Map String (Builtin pf)

data BuiltinInfo

Constructors

BuiltinInfo

Fields

• builtinName :: String
• builtinDesc :: BuiltinDescriptor

data BuiltinDescriptor

Constructors

BuiltinData (TCM Type) [String]

BuiltinDataCons (TCM Type)

BuiltinPrim String (Term -> TCM ())

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)

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)

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

data Call

Constructors

CheckClause Type SpineClause

CheckLHS SpineLHS

CheckPattern Pattern Telescope Type

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]

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

Data Call

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

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

toConstr :: Call -> Constr

dataTypeOf :: Call -> DataType

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

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

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

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

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

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

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

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

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

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

Pretty Call

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Call -> Doc

prettyPrec :: Int -> Call -> Doc

prettyList :: [Call] -> Doc

HasRange Call

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: Call -> Range

PrettyTCM Call

Defined in Agda.TypeChecking.Pretty.Call

Methods

prettyTCM :: MonadPretty m => Call -> m Doc

type Statistics = Map String Integer

newtype MutualId

Constructors

MutId Int32

Instances

Enum MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: MutualId -> MutualId

pred :: MutualId -> MutualId

toEnum :: Int -> MutualId

fromEnum :: MutualId -> Int

enumFrom :: MutualId -> [MutualId]

enumFromThen :: MutualId -> MutualId -> [MutualId]

enumFromTo :: MutualId -> MutualId -> [MutualId]

enumFromThenTo :: MutualId -> MutualId -> MutualId -> [MutualId]

Eq MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: MutualId -> MutualId -> Bool

(/=) :: MutualId -> MutualId -> Bool

Data MutualId

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

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

toConstr :: MutualId -> Constr

dataTypeOf :: MutualId -> DataType

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

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

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

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

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

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

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

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

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

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

Num MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

(+) :: MutualId -> MutualId -> MutualId

(-) :: MutualId -> MutualId -> MutualId

(*) :: MutualId -> MutualId -> MutualId

negate :: MutualId -> MutualId

abs :: MutualId -> MutualId

signum :: MutualId -> MutualId

fromInteger :: Integer -> MutualId

Ord MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: MutualId -> MutualId -> Ordering

(<) :: MutualId -> MutualId -> Bool

(<=) :: MutualId -> MutualId -> Bool

(>) :: MutualId -> MutualId -> Bool

(>=) :: MutualId -> MutualId -> Bool

max :: MutualId -> MutualId -> MutualId

min :: MutualId -> MutualId -> MutualId

Show MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> MutualId -> ShowS

show :: MutualId -> String

showList :: [MutualId] -> ShowS

KillRange MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT MutualId

HasFresh MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' MutualId TCState

nextFresh' :: MutualId -> MutualId

EmbPrj MutualId

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: MutualId -> S Int32

icod_ :: MutualId -> S Int32

value :: Int32 -> R MutualId

data TermHead

Constructors

SortHead

PiHead

ConsHead QName

VarHead Nat

UnknownHead

Instances

Eq TermHead

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: TermHead -> TermHead -> Bool

(/=) :: TermHead -> TermHead -> Bool

Data TermHead

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

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

toConstr :: TermHead -> Constr

dataTypeOf :: TermHead -> DataType

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

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

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

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

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

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

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

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

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

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

Ord TermHead

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: TermHead -> TermHead -> Ordering

(<) :: TermHead -> TermHead -> Bool

(<=) :: TermHead -> TermHead -> Bool

(>) :: TermHead -> TermHead -> Bool

(>=) :: TermHead -> TermHead -> Bool

max :: TermHead -> TermHead -> TermHead

min :: TermHead -> TermHead -> TermHead

Show TermHead

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> TermHead -> ShowS

show :: TermHead -> String

showList :: [TermHead] -> ShowS

Pretty TermHead

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: TermHead -> Doc

prettyPrec :: Int -> TermHead -> Doc

prettyList :: [TermHead] -> Doc

KillRange TermHead

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT TermHead

EmbPrj TermHead

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: TermHead -> S Int32

icod_ :: TermHead -> S Int32

value :: Int32 -> R TermHead

data FunctionInverse' c

Constructors

NotInjective

Inverse (InversionMap c)

Instances

Functor FunctionInverse'

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> FunctionInverse' a -> FunctionInverse' b

(<$) :: a -> FunctionInverse' b -> FunctionInverse' a

Abstract FunctionInverse

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> FunctionInverse -> FunctionInverse

Apply FunctionInverse

Defined in Agda.TypeChecking.Substitute

Methods

apply :: FunctionInverse -> Args -> FunctionInverse

applyE :: FunctionInverse -> Elims -> FunctionInverse

DropArgs FunctionInverse

Defined in Agda.TypeChecking.DropArgs

Methods

dropArgs :: Int -> FunctionInverse -> FunctionInverse

InstantiateFull FunctionInverse

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: FunctionInverse -> ReduceM FunctionInverse

Data c => Data (FunctionInverse' c)

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)

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

toConstr :: FunctionInverse' c -> Constr

dataTypeOf :: FunctionInverse' c -> DataType

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

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

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

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

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

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

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

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

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

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

Show c => Show (FunctionInverse' c)

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> FunctionInverse' c -> ShowS

show :: FunctionInverse' c -> String

showList :: [FunctionInverse' c] -> ShowS

KillRange c => KillRange (FunctionInverse' c)

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT (FunctionInverse' c)

EmbPrj a => EmbPrj (FunctionInverse' a)

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: FunctionInverse' a -> S Int32

icod_ :: FunctionInverse' a -> S Int32

value :: Int32 -> R (FunctionInverse' a)

type InversionMap c = Map TermHead [c]

type FunctionInverse = FunctionInverse' Clause

data PrimFun

Constructors

PrimFun

Fields

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

Instances

Abstract PrimFun

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> PrimFun -> PrimFun

Apply PrimFun

Defined in Agda.TypeChecking.Substitute

Methods

apply :: PrimFun -> Args -> PrimFun

applyE :: PrimFun -> Elims -> PrimFun

data PrimitiveImpl

Primitives

Constructors

PrimImpl Type PrimFun

type AllowedReductions = SmallSet AllowedReduction

data AllowedReduction

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

Bounded AllowedReduction

Defined in Agda.TypeChecking.Monad.Base

Methods

minBound :: AllowedReduction

maxBound :: AllowedReduction

Enum AllowedReduction

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: AllowedReduction -> AllowedReduction

pred :: AllowedReduction -> AllowedReduction

toEnum :: Int -> AllowedReduction

fromEnum :: AllowedReduction -> Int

enumFrom :: AllowedReduction -> [AllowedReduction]

enumFromThen :: AllowedReduction -> AllowedReduction -> [AllowedReduction]

enumFromTo :: AllowedReduction -> AllowedReduction -> [AllowedReduction]

enumFromThenTo :: AllowedReduction -> AllowedReduction -> AllowedReduction -> [AllowedReduction]

Eq AllowedReduction

Defined in Agda.TypeChecking.Monad.Base

Methods

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

(/=) :: AllowedReduction -> AllowedReduction -> Bool

Data AllowedReduction

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

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

toConstr :: AllowedReduction -> Constr

dataTypeOf :: AllowedReduction -> DataType

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

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

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

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

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

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

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

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

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

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

Ord AllowedReduction

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: AllowedReduction -> AllowedReduction -> Ordering

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

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

(>) :: AllowedReduction -> AllowedReduction -> Bool

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

max :: AllowedReduction -> AllowedReduction -> AllowedReduction

min :: AllowedReduction -> AllowedReduction -> AllowedReduction

Show AllowedReduction

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> AllowedReduction -> ShowS

show :: AllowedReduction -> String

showList :: [AllowedReduction] -> ShowS

Ix AllowedReduction

Defined in Agda.TypeChecking.Monad.Base

Methods

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

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

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

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

rangeSize :: (AllowedReduction, AllowedReduction) -> Int

unsafeRangeSize :: (AllowedReduction, AllowedReduction) -> Int

type MaybeReducedElims = [MaybeReduced Elim]

type MaybeReducedArgs = [MaybeReduced (Arg Term)]

data MaybeReduced a

Constructors

MaybeRed

Fields

• isReduced :: IsReduced
• ignoreReduced :: a

Instances

Functor MaybeReduced

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> MaybeReduced a -> MaybeReduced b

(<$) :: a -> MaybeReduced b -> MaybeReduced a

IsProjElim e => IsProjElim (MaybeReduced e)

Defined in Agda.TypeChecking.Monad.Base

Methods

isProjElim :: MaybeReduced e -> Maybe (ProjOrigin, QName)

PrettyTCM a => PrettyTCM (MaybeReduced a)

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => MaybeReduced a -> m Doc

data IsReduced

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

Constructors

NotReduced

Reduced (Blocked ())

data Reduced no yes

Constructors

NoReduction no

YesReduction Simplification yes

Instances

Functor (Reduced no)

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> Reduced no a -> Reduced no b

(<$) :: a -> Reduced no b -> Reduced no a

data Simplification

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

Eq Simplification

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: Simplification -> Simplification -> Bool

(/=) :: Simplification -> Simplification -> Bool

Data Simplification

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

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

toConstr :: Simplification -> Constr

dataTypeOf :: Simplification -> DataType

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

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

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

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

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

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

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

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

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

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

Show Simplification

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Simplification -> ShowS

show :: Simplification -> String

showList :: [Simplification] -> ShowS

Semigroup Simplification

Defined in Agda.TypeChecking.Monad.Base

Methods

(<>) :: Simplification -> Simplification -> Simplification

sconcat :: NonEmpty Simplification -> Simplification

stimes :: Integral b => b -> Simplification -> Simplification

Monoid Simplification

Defined in Agda.TypeChecking.Monad.Base

Methods

mempty :: Simplification

mappend :: Simplification -> Simplification -> Simplification

mconcat :: [Simplification] -> Simplification

Null Simplification

Defined in Agda.TypeChecking.Monad.Base

Methods

empty :: Simplification

null :: Simplification -> Bool

newtype Fields

Constructors

Fields [(Name, Type)]

Instances

Null Fields

Defined in Agda.TypeChecking.Monad.Base

Methods

empty :: Fields

null :: Fields -> Bool

data Defn

Constructors

Axiom

Postulate

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, datas and records. 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, datas and records. 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, datas and records. 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.

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

Instances

Data Defn

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

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

toConstr :: Defn -> Constr

dataTypeOf :: Defn -> DataType

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

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

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

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

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

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

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

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

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

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

Show Defn

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Defn -> ShowS

show :: Defn -> String

showList :: [Defn] -> ShowS

Pretty Defn

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Defn -> Doc

prettyPrec :: Int -> Defn -> Doc

prettyList :: [Defn] -> Doc

KillRange Defn

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Defn

Abstract Defn

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> Defn -> Defn

Apply Defn

Defined in Agda.TypeChecking.Substitute

Methods

apply :: Defn -> Args -> Defn

applyE :: Defn -> Elims -> Defn

EmbPrj Defn

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Defn -> S Int32

icod_ :: Defn -> S Int32

value :: Int32 -> R Defn

NamesIn Defn

Defined in Agda.Syntax.Internal.Names

Methods

namesIn :: Defn -> Set QName

InstantiateFull Defn

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Defn -> ReduceM Defn

Occurs Defn

Defined in Agda.TypeChecking.MetaVars.Occurs

Methods

occurs :: Defn -> OccursM Defn

metaOccurs :: MetaId -> Defn -> TCM ()

data CompKit

Constructors

CompKit

Fields

• nameOfHComp :: Maybe QName
• nameOfTransp :: Maybe QName

Instances

Eq CompKit

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: CompKit -> CompKit -> Bool

(/=) :: CompKit -> CompKit -> Bool

Data CompKit

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

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

toConstr :: CompKit -> Constr

dataTypeOf :: CompKit -> DataType

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

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

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

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

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

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

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

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

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

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

Ord CompKit

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: CompKit -> CompKit -> Ordering

(<) :: CompKit -> CompKit -> Bool

(<=) :: CompKit -> CompKit -> Bool

(>) :: CompKit -> CompKit -> Bool

(>=) :: CompKit -> CompKit -> Bool

max :: CompKit -> CompKit -> CompKit

min :: CompKit -> CompKit -> CompKit

Show CompKit

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> CompKit -> ShowS

show :: CompKit -> String

showList :: [CompKit] -> ShowS

KillRange CompKit

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT CompKit

EmbPrj CompKit

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: CompKit -> S Int32

icod_ :: CompKit -> S Int32

value :: Int32 -> R CompKit

NamesIn CompKit

Defined in Agda.Syntax.Internal.Names

Methods

namesIn :: CompKit -> Set QName

data FunctionFlag

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

Enum FunctionFlag

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: FunctionFlag -> FunctionFlag

pred :: FunctionFlag -> FunctionFlag

toEnum :: Int -> FunctionFlag

fromEnum :: FunctionFlag -> Int

enumFrom :: FunctionFlag -> [FunctionFlag]

enumFromThen :: FunctionFlag -> FunctionFlag -> [FunctionFlag]

enumFromTo :: FunctionFlag -> FunctionFlag -> [FunctionFlag]

enumFromThenTo :: FunctionFlag -> FunctionFlag -> FunctionFlag -> [FunctionFlag]

Eq FunctionFlag

Defined in Agda.TypeChecking.Monad.Base

Methods

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

(/=) :: FunctionFlag -> FunctionFlag -> Bool

Data FunctionFlag

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

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

toConstr :: FunctionFlag -> Constr

dataTypeOf :: FunctionFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Ord FunctionFlag

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: FunctionFlag -> FunctionFlag -> Ordering

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

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

(>) :: FunctionFlag -> FunctionFlag -> Bool

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

max :: FunctionFlag -> FunctionFlag -> FunctionFlag

min :: FunctionFlag -> FunctionFlag -> FunctionFlag

Show FunctionFlag

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> FunctionFlag -> ShowS

show :: FunctionFlag -> String

showList :: [FunctionFlag] -> ShowS

KillRange FunctionFlag

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT FunctionFlag

EmbPrj FunctionFlag

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: FunctionFlag -> S Int32

icod_ :: FunctionFlag -> S Int32

value :: Int32 -> R FunctionFlag

data EtaEquality

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

Eq EtaEquality

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: EtaEquality -> EtaEquality -> Bool

(/=) :: EtaEquality -> EtaEquality -> Bool

Data EtaEquality

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

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

toConstr :: EtaEquality -> Constr

dataTypeOf :: EtaEquality -> DataType

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

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

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

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

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

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

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

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

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

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

Show EtaEquality

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> EtaEquality -> ShowS

show :: EtaEquality -> String

showList :: [EtaEquality] -> ShowS

KillRange EtaEquality

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT EtaEquality

EmbPrj EtaEquality

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: EtaEquality -> S Int32

icod_ :: EtaEquality -> S Int32

value :: Int32 -> R EtaEquality

newtype ProjLams

Abstractions to build projection function (dropping parameters).

Constructors

ProjLams

Fields

• getProjLams :: [Arg ArgName]

Instances

Data ProjLams

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

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

toConstr :: ProjLams -> Constr

dataTypeOf :: ProjLams -> DataType

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

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

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

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

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

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

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

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

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

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

Show ProjLams

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> ProjLams -> ShowS

show :: ProjLams -> String

showList :: [ProjLams] -> ShowS

Null ProjLams

Defined in Agda.TypeChecking.Monad.Base

Methods

empty :: ProjLams

null :: ProjLams -> Bool

KillRange ProjLams

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT ProjLams

Abstract ProjLams

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> ProjLams -> ProjLams

Apply ProjLams

Defined in Agda.TypeChecking.Substitute

Methods

apply :: ProjLams -> Args -> ProjLams

applyE :: ProjLams -> Elims -> ProjLams

EmbPrj ProjLams

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: ProjLams -> S Int32

icod_ :: ProjLams -> S Int32

value :: Int32 -> R ProjLams

data Projection

Additional information for projection Functions.

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

Data Projection

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

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

toConstr :: Projection -> Constr

dataTypeOf :: Projection -> DataType

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

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

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

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

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

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

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

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

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

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

Show Projection

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Projection -> ShowS

show :: Projection -> String

showList :: [Projection] -> ShowS

KillRange Projection

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Projection

Abstract Projection

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> Projection -> Projection

Apply Projection

Defined in Agda.TypeChecking.Substitute

Methods

apply :: Projection -> Args -> Projection

applyE :: Projection -> Elims -> Projection

EmbPrj Projection

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Projection -> S Int32

icod_ :: Projection -> S Int32

value :: Int32 -> R Projection

data ExtLamInfo

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.

• extLamSys :: !(Maybe System)

Instances

Data ExtLamInfo

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

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

toConstr :: ExtLamInfo -> Constr

dataTypeOf :: ExtLamInfo -> DataType

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

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

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

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

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

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

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

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

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

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

Show ExtLamInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> ExtLamInfo -> ShowS

show :: ExtLamInfo -> String

showList :: [ExtLamInfo] -> ShowS

KillRange ExtLamInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT ExtLamInfo

Apply ExtLamInfo

Defined in Agda.TypeChecking.Substitute

Methods

apply :: ExtLamInfo -> Args -> ExtLamInfo

applyE :: ExtLamInfo -> Elims -> ExtLamInfo

EmbPrj ExtLamInfo

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: ExtLamInfo -> S Int32

icod_ :: ExtLamInfo -> S Int32

value :: Int32 -> R ExtLamInfo

InstantiateFull ExtLamInfo

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: ExtLamInfo -> ReduceM ExtLamInfo

data System

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

Data System

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

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

toConstr :: System -> Constr

dataTypeOf :: System -> DataType

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

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

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

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

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

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

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

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

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

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

Show System

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> System -> ShowS

show :: System -> String

showList :: [System] -> ShowS

KillRange System

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT System

Abstract System

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> System -> System

Apply System

Defined in Agda.TypeChecking.Substitute

Methods

apply :: System -> Args -> System

applyE :: System -> Elims -> System

EmbPrj System

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: System -> S Int32

icod_ :: System -> S Int32

value :: Int32 -> R System

InstantiateFull System

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: System -> ReduceM System

Reify (QNamed System) [Clause]

Defined in Agda.Syntax.Translation.InternalToAbstract

Methods

reify :: MonadReify m => QNamed System -> m [Clause]

reifyWhen :: MonadReify m => Bool -> QNamed System -> m [Clause]

type Face = [(Term, Bool)]

type CompiledRepresentation = Map BackendName [CompilerPragma]

data CompilerPragma

The backends are responsible for parsing their own pragmas.

Constructors

CompilerPragma Range String

Instances

Eq CompilerPragma

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: CompilerPragma -> CompilerPragma -> Bool

(/=) :: CompilerPragma -> CompilerPragma -> Bool

Data CompilerPragma

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

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

toConstr :: CompilerPragma -> Constr

dataTypeOf :: CompilerPragma -> DataType

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

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

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

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

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

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

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

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

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

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

Show CompilerPragma

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> CompilerPragma -> ShowS

show :: CompilerPragma -> String

showList :: [CompilerPragma] -> ShowS

KillRange CompiledRepresentation

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT CompiledRepresentation

HasRange CompilerPragma

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: CompilerPragma -> Range

EmbPrj CompilerPragma

Defined in Agda.TypeChecking.Serialise.Instances.Compilers

Methods

icode :: CompilerPragma -> S Int32

icod_ :: CompilerPragma -> S Int32

value :: Int32 -> R CompilerPragma

data IsForced

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

Constructors

Forced

NotForced

Instances

Eq IsForced

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: IsForced -> IsForced -> Bool

(/=) :: IsForced -> IsForced -> Bool

Data IsForced

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

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

toConstr :: IsForced -> Constr

dataTypeOf :: IsForced -> DataType

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

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

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

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

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

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

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

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

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

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

Show IsForced

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> IsForced -> ShowS

show :: IsForced -> String

showList :: [IsForced] -> ShowS

KillRange IsForced

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT IsForced

EmbPrj IsForced

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: IsForced -> S Int32

icod_ :: IsForced -> S Int32

value :: Int32 -> R IsForced

PrettyTCM IsForced

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => IsForced -> m Doc

ChooseFlex IsForced

Defined in Agda.TypeChecking.Rules.LHS.Problem

Methods

chooseFlex :: IsForced -> IsForced -> FlexChoice

data NumGeneralizableArgs

Constructors

NoGeneralizableArgs

SomeGeneralizableArgs Int

When lambda-lifting new args are generalizable if SomeGeneralizableArgs, also when the number is zero.

Instances

Data NumGeneralizableArgs

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

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

toConstr :: NumGeneralizableArgs -> Constr

dataTypeOf :: NumGeneralizableArgs -> DataType

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

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

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

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

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

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

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

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

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

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

Show NumGeneralizableArgs

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> NumGeneralizableArgs -> ShowS

show :: NumGeneralizableArgs -> String

showList :: [NumGeneralizableArgs] -> ShowS

KillRange NumGeneralizableArgs

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT NumGeneralizableArgs

Abstract NumGeneralizableArgs

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> NumGeneralizableArgs -> NumGeneralizableArgs

Apply NumGeneralizableArgs

Defined in Agda.TypeChecking.Substitute

Methods

apply :: NumGeneralizableArgs -> Args -> NumGeneralizableArgs

applyE :: NumGeneralizableArgs -> Elims -> NumGeneralizableArgs

EmbPrj NumGeneralizableArgs

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: NumGeneralizableArgs -> S Int32

icod_ :: NumGeneralizableArgs -> S Int32

value :: Int32 -> R NumGeneralizableArgs

data Definition

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.

• theDef :: Defn

Instances

Data Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Definition -> c Definition

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Definition

toConstr :: Definition -> Constr

dataTypeOf :: Definition -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Definition)

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

gmapT :: (forall b. Data b => b -> b) -> Definition -> Definition

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Definition -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Definition -> r

gmapQ :: (forall d. Data d => d -> u) -> Definition -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Definition -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Definition -> m Definition

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Definition -> m Definition

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Definition -> m Definition

Show Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Definition -> ShowS

show :: Definition -> String

showList :: [Definition] -> ShowS

Pretty Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Definition -> Doc

prettyPrec :: Int -> Definition -> Doc

prettyList :: [Definition] -> Doc

KillRange Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Definition

KillRange Definitions

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Definitions

LensArgInfo Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

getArgInfo :: Definition -> ArgInfo

setArgInfo :: ArgInfo -> Definition -> Definition

mapArgInfo :: (ArgInfo -> ArgInfo) -> Definition -> Definition

LensRelevance Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

getRelevance :: Definition -> Relevance

setRelevance :: Relevance -> Definition -> Definition

mapRelevance :: (Relevance -> Relevance) -> Definition -> Definition

LensQuantity Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

getQuantity :: Definition -> Quantity

setQuantity :: Quantity -> Definition -> Definition

mapQuantity :: (Quantity -> Quantity) -> Definition -> Definition

LensModality Definition

Defined in Agda.TypeChecking.Monad.Base

Methods

getModality :: Definition -> Modality

setModality :: Modality -> Definition -> Definition

mapModality :: (Modality -> Modality) -> Definition -> Definition

Abstract Definition

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> Definition -> Definition

Apply Definition

Defined in Agda.TypeChecking.Substitute

Methods

apply :: Definition -> Args -> Definition

applyE :: Definition -> Elims -> Definition

EmbPrj Definition

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Definition -> S Int32

icod_ :: Definition -> S Int32

value :: Int32 -> R Definition

NamesIn Definition

Defined in Agda.Syntax.Internal.Names

Methods

namesIn :: Definition -> Set QName

InstantiateFull Definition

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Definition -> ReduceM Definition

data RewriteRule

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.

Instances

Data RewriteRule

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

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

toConstr :: RewriteRule -> Constr

dataTypeOf :: RewriteRule -> DataType

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

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

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

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

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

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

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

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

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

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

Show RewriteRule

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> RewriteRule -> ShowS

show :: RewriteRule -> String

showList :: [RewriteRule] -> ShowS

KillRange RewriteRule

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT RewriteRule

KillRange RewriteRuleMap

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT RewriteRuleMap

Abstract RewriteRule

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

Defined in Agda.TypeChecking.Substitute

Methods

abstract :: Telescope -> RewriteRule -> RewriteRule

Apply RewriteRule

Defined in Agda.TypeChecking.Substitute

Methods

apply :: RewriteRule -> Args -> RewriteRule

applyE :: RewriteRule -> Elims -> RewriteRule

EmbPrj RewriteRule

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: RewriteRule -> S Int32

icod_ :: RewriteRule -> S Int32

value :: Int32 -> R RewriteRule

PrettyTCM RewriteRule

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => RewriteRule -> m Doc

InstantiateFull RewriteRule

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: RewriteRule -> ReduceM RewriteRule

GetMatchables RewriteRule

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

getMatchables :: RewriteRule -> [QName]

Subst NLPat RewriteRule

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> RewriteRule -> RewriteRule

type RewriteRules = [RewriteRule]

data NLPSort

Constructors

PType NLPat

PProp NLPat

PInf

PSizeUniv

Instances

Data NLPSort

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NLPSort

toConstr :: NLPSort -> Constr

dataTypeOf :: NLPSort -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NLPSort)

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

gmapT :: (forall b. Data b => b -> b) -> NLPSort -> NLPSort

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPSort -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPSort -> r

gmapQ :: (forall d. Data d => d -> u) -> NLPSort -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NLPSort -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NLPSort -> m NLPSort

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPSort -> m NLPSort

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPSort -> m NLPSort

Show NLPSort

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> NLPSort -> ShowS

show :: NLPSort -> String

showList :: [NLPSort] -> ShowS

KillRange NLPSort

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT NLPSort

Free NLPSort

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

freeVars' :: IsVarSet a c => NLPSort -> FreeM a c

EmbPrj NLPSort

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: NLPSort -> S Int32

icod_ :: NLPSort -> S Int32

value :: Int32 -> R NLPSort

PrettyTCM NLPSort

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => NLPSort -> m Doc

InstantiateFull NLPSort

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: NLPSort -> ReduceM NLPSort

GetMatchables NLPSort

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

getMatchables :: NLPSort -> [QName]

NLPatVars NLPSort

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatVarsUnder :: Int -> NLPSort -> IntSet

nlPatVars :: NLPSort -> IntSet

Subst NLPat NLPSort

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> NLPSort -> NLPSort

NLPatToTerm NLPSort Sort

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatToTerm :: (MonadReduce m, HasBuiltins m, HasConstInfo m, MonadDebug m) => NLPSort -> m Sort

PatternFrom () Sort NLPSort

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

patternFrom :: Relevance -> Int -> () -> Sort -> TCM NLPSort

Match () NLPSort Sort

Defined in Agda.TypeChecking.Rewriting.NonLinMatch

Methods

match :: Relevance -> Telescope -> Telescope -> () -> NLPSort -> Sort -> NLM ()

data NLPType

Constructors

NLPType

Fields

• nlpTypeSort :: NLPSort
• nlpTypeUnEl :: NLPat

Instances

Data NLPType

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NLPType

toConstr :: NLPType -> Constr

dataTypeOf :: NLPType -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NLPType)

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

gmapT :: (forall b. Data b => b -> b) -> NLPType -> NLPType

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPType -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPType -> r

gmapQ :: (forall d. Data d => d -> u) -> NLPType -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NLPType -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NLPType -> m NLPType

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPType -> m NLPType

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPType -> m NLPType

Show NLPType

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> NLPType -> ShowS

show :: NLPType -> String

showList :: [NLPType] -> ShowS

KillRange NLPType

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT NLPType

Free NLPType

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

freeVars' :: IsVarSet a c => NLPType -> FreeM a c

EmbPrj NLPType

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: NLPType -> S Int32

icod_ :: NLPType -> S Int32

value :: Int32 -> R NLPType

PrettyTCM NLPType

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => NLPType -> m Doc

InstantiateFull NLPType

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: NLPType -> ReduceM NLPType

GetMatchables NLPType

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

getMatchables :: NLPType -> [QName]

NLPatVars NLPType

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatVarsUnder :: Int -> NLPType -> IntSet

nlPatVars :: NLPType -> IntSet

Subst NLPat NLPType

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> NLPType -> NLPType

NLPatToTerm NLPType Type

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatToTerm :: (MonadReduce m, HasBuiltins m, HasConstInfo m, MonadDebug m) => NLPType -> m Type

PatternFrom () Type NLPType

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

patternFrom :: Relevance -> Int -> () -> Type -> TCM NLPType

Match () NLPType Type

Defined in Agda.TypeChecking.Rewriting.NonLinMatch

Methods

match :: Relevance -> Telescope -> Telescope -> () -> NLPType -> Type -> NLM ()

type PElims = [Elim' NLPat]

data NLPat

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

Data NLPat

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NLPat

toConstr :: NLPat -> Constr

dataTypeOf :: NLPat -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NLPat)

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

gmapT :: (forall b. Data b => b -> b) -> NLPat -> NLPat

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r

gmapQ :: (forall d. Data d => d -> u) -> NLPat -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NLPat -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NLPat -> m NLPat

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPat -> m NLPat

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPat -> m NLPat

Show NLPat

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> NLPat -> ShowS

show :: NLPat -> String

showList :: [NLPat] -> ShowS

KillRange NLPat

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT NLPat

DeBruijn NLPat

Defined in Agda.TypeChecking.Substitute

Methods

deBruijnVar :: Int -> NLPat

debruijnNamedVar :: String -> Int -> NLPat

deBruijnView :: NLPat -> Maybe Int

Free NLPat

Only computes free variables that are not bound (see nlPatVars), i.e., those in a PTerm.

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

freeVars' :: IsVarSet a c => NLPat -> FreeM a c

EmbPrj NLPat

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: NLPat -> S Int32

icod_ :: NLPat -> S Int32

value :: Int32 -> R NLPat

PrettyTCM NLPat

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => NLPat -> m Doc

InstantiateFull NLPat

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: NLPat -> ReduceM NLPat

GetMatchables NLPat

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

getMatchables :: NLPat -> [QName]

NLPatVars NLPat

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatVarsUnder :: Int -> NLPat -> IntSet

nlPatVars :: NLPat -> IntSet

Subst NLPat RewriteRule

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> RewriteRule -> RewriteRule

Subst NLPat NLPSort

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> NLPSort -> NLPSort

Subst NLPat NLPType

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> NLPType -> NLPType

Subst NLPat NLPat

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' NLPat -> NLPat -> NLPat

NLPatToTerm NLPat Level

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatToTerm :: (MonadReduce m, HasBuiltins m, HasConstInfo m, MonadDebug m) => NLPat -> m Level

NLPatToTerm NLPat Term

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

nlPatToTerm :: (MonadReduce m, HasBuiltins m, HasConstInfo m, MonadDebug m) => NLPat -> m Term

PatternFrom () Level NLPat

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

patternFrom :: Relevance -> Int -> () -> Level -> TCM NLPat

PatternFrom Type Term NLPat

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

patternFrom :: Relevance -> Int -> Type -> Term -> TCM NLPat

Match () NLPat Level

Defined in Agda.TypeChecking.Rewriting.NonLinMatch

Methods

match :: Relevance -> Telescope -> Telescope -> () -> NLPat -> Level -> NLM ()

Match Type NLPat Term

Defined in Agda.TypeChecking.Rewriting.NonLinMatch

Methods

match :: Relevance -> Telescope -> Telescope -> Type -> NLPat -> Term -> NLM ()

PrettyTCM (Type' NLPat)

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Type' NLPat -> m Doc

PrettyTCM (Elim' NLPat)

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Elim' NLPat -> m Doc

ToNLPat (NamedArg DeBruijnPattern) (Elim' NLPat)

Defined in Agda.TypeChecking.Rewriting.Clause

Methods

toNLPat :: NamedArg DeBruijnPattern -> Elim' NLPat

ToNLPat (Arg DeBruijnPattern) (Elim' NLPat)

Defined in Agda.TypeChecking.Rewriting.Clause

Methods

toNLPat :: Arg DeBruijnPattern -> Elim' NLPat

PatternFrom (Type, Term) Elims [Elim' NLPat]

Defined in Agda.TypeChecking.Rewriting.NonLinPattern

Methods

patternFrom :: Relevance -> Int -> (Type, Term) -> Elims -> TCM [Elim' NLPat]

Match (Type, Term) [Elim' NLPat] Elims

Defined in Agda.TypeChecking.Rewriting.NonLinMatch

Methods

match :: Relevance -> Telescope -> Telescope -> (Type, Term) -> [Elim' NLPat] -> Elims -> NLM ()

data DisplayTerm

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

Data DisplayTerm

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DisplayTerm

toConstr :: DisplayTerm -> Constr

dataTypeOf :: DisplayTerm -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DisplayTerm)

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

gmapT :: (forall b. Data b => b -> b) -> DisplayTerm -> DisplayTerm

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r

gmapQ :: (forall d. Data d => d -> u) -> DisplayTerm -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DisplayTerm -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm

Show DisplayTerm

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> DisplayTerm -> ShowS

show :: DisplayTerm -> String

showList :: [DisplayTerm] -> ShowS

Pretty DisplayTerm

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: DisplayTerm -> Doc

prettyPrec :: Int -> DisplayTerm -> Doc

prettyList :: [DisplayTerm] -> Doc

KillRange DisplayTerm

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT DisplayTerm

Free DisplayTerm

Defined in Agda.TypeChecking.Monad.Base

Methods

freeVars' :: IsVarSet a c => DisplayTerm -> FreeM a c

Apply DisplayTerm

Defined in Agda.TypeChecking.Substitute

Methods

apply :: DisplayTerm -> Args -> DisplayTerm

applyE :: DisplayTerm -> Elims -> DisplayTerm

EmbPrj DisplayTerm

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: DisplayTerm -> S Int32

icod_ :: DisplayTerm -> S Int32

value :: Int32 -> R DisplayTerm

PrettyTCM DisplayTerm

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => DisplayTerm -> m Doc

NamesIn DisplayTerm

Defined in Agda.Syntax.Internal.Names

Methods

namesIn :: DisplayTerm -> Set QName

InstantiateFull DisplayTerm

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: DisplayTerm -> ReduceM DisplayTerm

SubstWithOrigin DisplayTerm

Defined in Agda.TypeChecking.DisplayForm

Methods

substWithOrigin :: Substitution -> [WithOrigin Term] -> DisplayTerm -> DisplayTerm

Subst Term DisplayTerm

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' Term -> DisplayTerm -> DisplayTerm

Reify DisplayTerm Expr

Defined in Agda.Syntax.Translation.InternalToAbstract

Methods

reify :: MonadReify m => DisplayTerm -> m Expr

reifyWhen :: MonadReify m => Bool -> DisplayTerm -> m Expr

PrettyTCM (Elim' DisplayTerm)

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Elim' DisplayTerm -> m Doc

SubstWithOrigin (Arg DisplayTerm)

Defined in Agda.TypeChecking.DisplayForm

Methods

substWithOrigin :: Substitution -> [WithOrigin Term] -> Arg DisplayTerm -> Arg DisplayTerm

type LocalDisplayForm = Open DisplayForm

data DisplayForm

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 var 0 is interpreted as a hole. Each occurrence of var 0 is a new hole (pattern var). For each *occurrence* of var0 the rhs dt has a free variable. These are instantiated when matching a display form against a term q vs succeeds.

Constructors

Display

Fields

• dfFreeVars :: Nat

  Number n of free variables in dfRHS.

• dfPats :: Elims

  Left hand side patterns, where var 0 stands for a pattern variable. There should be n occurrences of var0 in dfPats. The ArgInfo is ignored in these patterns.

• dfRHS :: DisplayTerm

  Right hand side, with n free variables.

Instances

Data DisplayForm

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DisplayForm

toConstr :: DisplayForm -> Constr

dataTypeOf :: DisplayForm -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DisplayForm)

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

gmapT :: (forall b. Data b => b -> b) -> DisplayForm -> DisplayForm

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r

gmapQ :: (forall d. Data d => d -> u) -> DisplayForm -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DisplayForm -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm

Show DisplayForm

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> DisplayForm -> ShowS

show :: DisplayForm -> String

showList :: [DisplayForm] -> ShowS

KillRange DisplayForm

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT DisplayForm

Free DisplayForm

Defined in Agda.TypeChecking.Monad.Base

Methods

freeVars' :: IsVarSet a c => DisplayForm -> FreeM a c

EmbPrj DisplayForm

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: DisplayForm -> S Int32

icod_ :: DisplayForm -> S Int32

value :: Int32 -> R DisplayForm

NamesIn DisplayForm

Defined in Agda.Syntax.Internal.Names

Methods

namesIn :: DisplayForm -> Set QName

InstantiateFull DisplayForm

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: DisplayForm -> ReduceM DisplayForm

Normalise DisplayForm

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: DisplayForm -> ReduceM DisplayForm

Simplify DisplayForm

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: DisplayForm -> ReduceM DisplayForm

Subst Term DisplayForm

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' Term -> DisplayForm -> DisplayForm

newtype Section

Constructors

Section

Fields

• _secTelescope :: Telescope

Instances

Eq Section

Defined in Agda.TypeChecking.Substitute

Methods

(==) :: Section -> Section -> Bool

(/=) :: Section -> Section -> Bool

Data Section

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Section

toConstr :: Section -> Constr

dataTypeOf :: Section -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Section)

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

gmapT :: (forall b. Data b => b -> b) -> Section -> Section

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Section -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Section -> r

gmapQ :: (forall d. Data d => d -> u) -> Section -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Section -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Section -> m Section

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Section -> m Section

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Section -> m Section

Show Section

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Section -> ShowS

show :: Section -> String

showList :: [Section] -> ShowS

Pretty Section

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Section -> Doc

prettyPrec :: Int -> Section -> Doc

prettyList :: [Section] -> Doc

KillRange Section

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Section

KillRange Sections

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Sections

EmbPrj Section

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Section -> S Int32

icod_ :: Section -> S Int32

value :: Int32 -> R Section

InstantiateFull Section

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Section -> ReduceM Section

type DisplayForms = HashMap QName [LocalDisplayForm]

type RewriteRuleMap = HashMap QName RewriteRules

type Definitions = HashMap QName Definition

type Sections = Map ModuleName Section

data Signature

Constructors

Sig

Fields

• _sigSections :: Sections
• _sigDefinitions :: Definitions
• _sigRewriteRules :: RewriteRuleMap

  The rewrite rules defined in this file.

Instances

Data Signature

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Signature -> c Signature

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Signature

toConstr :: Signature -> Constr

dataTypeOf :: Signature -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Signature)

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

gmapT :: (forall b. Data b => b -> b) -> Signature -> Signature

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Signature -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Signature -> r

gmapQ :: (forall d. Data d => d -> u) -> Signature -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Signature -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Signature -> m Signature

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Signature -> m Signature

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Signature -> m Signature

Show Signature

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Signature -> ShowS

show :: Signature -> String

showList :: [Signature] -> ShowS

KillRange Signature

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT Signature

EmbPrj Signature

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Signature -> S Int32

icod_ :: Signature -> S Int32

value :: Int32 -> R Signature

InstantiateFull Signature

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Signature -> ReduceM Signature

data IPClause

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

Eq IPClause

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: IPClause -> IPClause -> Bool

(/=) :: IPClause -> IPClause -> Bool

Data IPClause

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPClause -> c IPClause

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IPClause

toConstr :: IPClause -> Constr

dataTypeOf :: IPClause -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IPClause)

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

gmapT :: (forall b. Data b => b -> b) -> IPClause -> IPClause

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPClause -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPClause -> r

gmapQ :: (forall d. Data d => d -> u) -> IPClause -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPClause -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPClause -> m IPClause

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPClause -> m IPClause

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPClause -> m IPClause

type IPBoundary = IPBoundary' Term

data IPBoundary' t

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

Functor IPBoundary'

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> IPBoundary' a -> IPBoundary' b

(<$) :: a -> IPBoundary' b -> IPBoundary' a

Foldable IPBoundary'

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => IPBoundary' m -> m

foldMap :: Monoid m => (a -> m) -> IPBoundary' a -> m

foldMap' :: Monoid m => (a -> m) -> IPBoundary' a -> m

foldr :: (a -> b -> b) -> b -> IPBoundary' a -> b

foldr' :: (a -> b -> b) -> b -> IPBoundary' a -> b

foldl :: (b -> a -> b) -> b -> IPBoundary' a -> b

foldl' :: (b -> a -> b) -> b -> IPBoundary' a -> b

foldr1 :: (a -> a -> a) -> IPBoundary' a -> a

foldl1 :: (a -> a -> a) -> IPBoundary' a -> a

toList :: IPBoundary' a -> [a]

null :: IPBoundary' a -> Bool

length :: IPBoundary' a -> Int

elem :: Eq a => a -> IPBoundary' a -> Bool

maximum :: Ord a => IPBoundary' a -> a

minimum :: Ord a => IPBoundary' a -> a

sum :: Num a => IPBoundary' a -> a

product :: Num a => IPBoundary' a -> a

Traversable IPBoundary'

Defined in Agda.TypeChecking.Monad.Base

Methods

traverse :: Applicative f => (a -> f b) -> IPBoundary' a -> f (IPBoundary' b)

sequenceA :: Applicative f => IPBoundary' (f a) -> f (IPBoundary' a)

mapM :: Monad m => (a -> m b) -> IPBoundary' a -> m (IPBoundary' b)

sequence :: Monad m => IPBoundary' (m a) -> m (IPBoundary' a)

Data t => Data (IPBoundary' t)

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)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t)

toConstr :: IPBoundary' t -> Constr

dataTypeOf :: IPBoundary' t -> DataType

dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (IPBoundary' t))

dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (IPBoundary' t))

gmapT :: (forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r

gmapQ :: (forall d. Data d => d -> u) -> IPBoundary' t -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPBoundary' t -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPBoundary' t -> m (IPBoundary' t)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBoundary' t -> m (IPBoundary' t)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBoundary' t -> m (IPBoundary' t)

Show t => Show (IPBoundary' t)

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> IPBoundary' t -> ShowS

show :: IPBoundary' t -> String

showList :: [IPBoundary' t] -> ShowS

Pretty c => Pretty (IPBoundary' c)

Defined in Agda.Interaction.BasicOps

Methods

pretty :: IPBoundary' c -> Doc

prettyPrec :: Int -> IPBoundary' c -> Doc

prettyList :: [IPBoundary' c] -> Doc

Normalise t => Normalise (IPBoundary' t)

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: IPBoundary' t -> ReduceM (IPBoundary' t)

Simplify t => Simplify (IPBoundary' t)

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: IPBoundary' t -> ReduceM (IPBoundary' t)

Reduce t => Reduce (IPBoundary' t)

Defined in Agda.TypeChecking.Reduce

Methods

reduce' :: IPBoundary' t -> ReduceM (IPBoundary' t)

reduceB' :: IPBoundary' t -> ReduceM (Blocked (IPBoundary' t))

ToConcrete a c => ToConcrete (IPBoundary' a) (IPBoundary' c)

Defined in Agda.Interaction.BasicOps

Methods

toConcrete :: IPBoundary' a -> AbsToCon (IPBoundary' c)

bindToConcrete :: IPBoundary' a -> (IPBoundary' c -> AbsToCon b) -> AbsToCon b

Reify a e => Reify (IPBoundary' a) (IPBoundary' e)

Defined in Agda.Interaction.BasicOps

Methods

reify :: MonadReify m => IPBoundary' a -> m (IPBoundary' e)

reifyWhen :: MonadReify m => Bool -> IPBoundary' a -> m (IPBoundary' e)

data Overapplied

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

Eq Overapplied

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: Overapplied -> Overapplied -> Bool

(/=) :: Overapplied -> Overapplied -> Bool

Data Overapplied

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overapplied

toConstr :: Overapplied -> Constr

dataTypeOf :: Overapplied -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overapplied)

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

gmapT :: (forall b. Data b => b -> b) -> Overapplied -> Overapplied

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overapplied -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overapplied -> r

gmapQ :: (forall d. Data d => d -> u) -> Overapplied -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overapplied -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied

Show Overapplied

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Overapplied -> ShowS

show :: Overapplied -> String

showList :: [Overapplied] -> ShowS

type InteractionPoints = Map InteractionId InteractionPoint

Data structure managing the interaction points.

We never remove interaction points from this map, only set their ipSolved to True. (Issue #2368)

data InteractionPoint

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

Eq InteractionPoint

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: InteractionPoint -> InteractionPoint -> Bool

(/=) :: InteractionPoint -> InteractionPoint -> Bool

type MetaStore = IntMap MetaVariable

type MetaNameSuggestion = String

Name suggestion for meta variable. Empty string means no suggestion.

data MetaInfo

MetaInfo is cloned from one meta to the next during pruning.

Constructors

MetaInfo

Fields

• miClosRange :: Closure Range
• 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

SetRange MetaInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

setRange :: Range -> MetaInfo -> MetaInfo

HasRange MetaInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: MetaInfo -> Range

LensIsAbstract MetaInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

lensIsAbstract :: Lens' IsAbstract MetaInfo

LensClosure Range MetaInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

lensClosure :: Lens' (Closure Range) MetaInfo

data RunMetaOccursCheck

Constructors

RunMetaOccursCheck

DontRunMetaOccursCheck

Instances

Eq RunMetaOccursCheck

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool

(/=) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool

Ord RunMetaOccursCheck

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: RunMetaOccursCheck -> RunMetaOccursCheck -> Ordering

(<) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool

(<=) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool

(>) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool

(>=) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool

max :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck

min :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck

Show RunMetaOccursCheck

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> RunMetaOccursCheck -> ShowS

show :: RunMetaOccursCheck -> String

showList :: [RunMetaOccursCheck] -> ShowS

newtype MetaPriority

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

Eq MetaPriority

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: MetaPriority -> MetaPriority -> Bool

(/=) :: MetaPriority -> MetaPriority -> Bool

Ord MetaPriority

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: MetaPriority -> MetaPriority -> Ordering

(<) :: MetaPriority -> MetaPriority -> Bool

(<=) :: MetaPriority -> MetaPriority -> Bool

(>) :: MetaPriority -> MetaPriority -> Bool

(>=) :: MetaPriority -> MetaPriority -> Bool

max :: MetaPriority -> MetaPriority -> MetaPriority

min :: MetaPriority -> MetaPriority -> MetaPriority

Show MetaPriority

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> MetaPriority -> ShowS

show :: MetaPriority -> String

showList :: [MetaPriority] -> ShowS

data TypeCheckingProblem

Constructors

CheckExpr Comparison Expr Type

CheckArgs ExpandHidden Range [NamedArg Expr] Type Type ([Maybe Range] -> Elims -> Type -> CheckedTarget -> TCM Term)

CheckProjAppToKnownPrincipalArg Comparison Expr ProjOrigin (NonEmpty QName) Args Type Int Term Type

CheckLambda Comparison (Arg ([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

PrettyTCM TypeCheckingProblem

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => TypeCheckingProblem -> m Doc

data CheckedTarget

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

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) (TCM Bool)

Instances

Show MetaInstantiation

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> MetaInstantiation -> ShowS

show :: MetaInstantiation -> String

showList :: [MetaInstantiation] -> ShowS

data Frozen

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

Eq Frozen

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: Frozen -> Frozen -> Bool

(/=) :: Frozen -> Frozen -> Bool

Show Frozen

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Frozen -> ShowS

show :: Frozen -> String

showList :: [Frozen] -> ShowS

data Listener

Constructors

EtaExpand MetaId

CheckConstraint Nat ProblemConstraint

Instances

Eq Listener

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: Listener -> Listener -> Bool

(/=) :: Listener -> Listener -> Bool

Ord Listener

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: Listener -> Listener -> Ordering

(<) :: Listener -> Listener -> Bool

(<=) :: Listener -> Listener -> Bool

(>) :: Listener -> Listener -> Bool

(>=) :: Listener -> Listener -> Bool

max :: Listener -> Listener -> Listener

min :: Listener -> Listener -> Listener

data MetaVariable

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 this meta will be equated to m when the latter is unblocked. See blockedTermOnProblem.

Instances

SetRange MetaVariable

Defined in Agda.TypeChecking.Monad.Base

Methods

setRange :: Range -> MetaVariable -> MetaVariable

HasRange MetaVariable

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: MetaVariable -> Range

LensClosure Range MetaVariable

Defined in Agda.TypeChecking.Monad.Base

Methods

lensClosure :: Lens' (Closure Range) MetaVariable

data GeneralizedValue

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

Data GeneralizedValue

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GeneralizedValue

toConstr :: GeneralizedValue -> Constr

dataTypeOf :: GeneralizedValue -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GeneralizedValue)

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

gmapT :: (forall b. Data b => b -> b) -> GeneralizedValue -> GeneralizedValue

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r

gmapQ :: (forall d. Data d => d -> u) -> GeneralizedValue -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GeneralizedValue -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GeneralizedValue -> m GeneralizedValue

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GeneralizedValue -> m GeneralizedValue

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GeneralizedValue -> m GeneralizedValue

Show GeneralizedValue

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> GeneralizedValue -> ShowS

show :: GeneralizedValue -> String

showList :: [GeneralizedValue] -> ShowS

data DoGeneralize

Constructors

YesGeneralize

NoGeneralize

Instances

Eq DoGeneralize

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: DoGeneralize -> DoGeneralize -> Bool

(/=) :: DoGeneralize -> DoGeneralize -> Bool

Data DoGeneralize

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DoGeneralize

toConstr :: DoGeneralize -> Constr

dataTypeOf :: DoGeneralize -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DoGeneralize)

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

gmapT :: (forall b. Data b => b -> b) -> DoGeneralize -> DoGeneralize

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r

gmapQ :: (forall d. Data d => d -> u) -> DoGeneralize -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DoGeneralize -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize

Ord DoGeneralize

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: DoGeneralize -> DoGeneralize -> Ordering

(<) :: DoGeneralize -> DoGeneralize -> Bool

(<=) :: DoGeneralize -> DoGeneralize -> Bool

(>) :: DoGeneralize -> DoGeneralize -> Bool

(>=) :: DoGeneralize -> DoGeneralize -> Bool

max :: DoGeneralize -> DoGeneralize -> DoGeneralize

min :: DoGeneralize -> DoGeneralize -> DoGeneralize

Show DoGeneralize

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> DoGeneralize -> ShowS

show :: DoGeneralize -> String

showList :: [DoGeneralize] -> ShowS

KillRange DoGeneralize

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT DoGeneralize

EmbPrj DoGeneralize

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: DoGeneralize -> S Int32

icod_ :: DoGeneralize -> S Int32

value :: Int32 -> R DoGeneralize

data Judgement a

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

Show a => Show (Judgement a)

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Judgement a -> ShowS

show :: Judgement a -> String

showList :: [Judgement a] -> ShowS

PrettyTCM a => PrettyTCM (Judgement a)

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Judgement a -> m Doc

data Open a

A thing tagged with the context it came from.

Constructors

OpenThing

Fields

• openThingCheckpoint :: CheckpointId
• openThing :: a

Instances

Functor Open

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> Open a -> Open b

(<$) :: a -> Open b -> Open a

Foldable Open

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => Open m -> m

foldMap :: Monoid m => (a -> m) -> Open a -> m

foldMap' :: Monoid m => (a -> m) -> Open a -> m

foldr :: (a -> b -> b) -> b -> Open a -> b

foldr' :: (a -> b -> b) -> b -> Open a -> b

foldl :: (b -> a -> b) -> b -> Open a -> b

foldl' :: (b -> a -> b) -> b -> Open a -> b

foldr1 :: (a -> a -> a) -> Open a -> a

foldl1 :: (a -> a -> a) -> Open a -> a

toList :: Open a -> [a]

null :: Open a -> Bool

length :: Open a -> Int

elem :: Eq a => a -> Open a -> Bool

maximum :: Ord a => Open a -> a

minimum :: Ord a => Open a -> a

sum :: Num a => Open a -> a

product :: Num a => Open a -> a

Traversable Open

Defined in Agda.TypeChecking.Monad.Base

Methods

traverse :: Applicative f => (a -> f b) -> Open a -> f (Open b)

sequenceA :: Applicative f => Open (f a) -> f (Open a)

mapM :: Monad m => (a -> m b) -> Open a -> m (Open b)

sequence :: Monad m => Open (m a) -> m (Open a)

Decoration Open

Defined in Agda.TypeChecking.Monad.Base

Methods

traverseF :: Functor m => (a -> m b) -> Open a -> m (Open b)

distributeF :: Functor m => Open (m a) -> m (Open a)

Data a => Data (Open a)

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Open a -> c (Open a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Open a)

toConstr :: Open a -> Constr

dataTypeOf :: Open a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Open a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Open a))

gmapT :: (forall b. Data b => b -> b) -> Open a -> Open a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Open a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Open a -> r

gmapQ :: (forall d. Data d => d -> u) -> Open a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Open a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Open a -> m (Open a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Open a -> m (Open a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Open a -> m (Open a)

Show a => Show (Open a)

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Open a -> ShowS

show :: Open a -> String

showList :: [Open a] -> ShowS

KillRange a => KillRange (Open a)

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT (Open a)

EmbPrj a => EmbPrj (Open a)

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: Open a -> S Int32

icod_ :: Open a -> S Int32

value :: Int32 -> R (Open a)

NamesIn a => NamesIn (Open a)

Defined in Agda.Syntax.Internal.Names

Methods

namesIn :: Open a -> Set QName

InstantiateFull t => InstantiateFull (Open t)

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Open t -> ReduceM (Open t)

data CompareAs

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

Eq CompareAs

Defined in Agda.TypeChecking.Substitute

Methods

(==) :: CompareAs -> CompareAs -> Bool

(/=) :: CompareAs -> CompareAs -> Bool

Data CompareAs

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompareAs

toConstr :: CompareAs -> Constr

dataTypeOf :: CompareAs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CompareAs)

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

gmapT :: (forall b. Data b => b -> b) -> CompareAs -> CompareAs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompareAs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompareAs -> r

gmapQ :: (forall d. Data d => d -> u) -> CompareAs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompareAs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs

Show CompareAs

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> CompareAs -> ShowS

show :: CompareAs -> String

showList :: [CompareAs] -> ShowS

Free CompareAs

Defined in Agda.TypeChecking.Monad.Base

Methods

freeVars' :: IsVarSet a c => CompareAs -> FreeM a c

TermLike CompareAs

Defined in Agda.TypeChecking.Monad.Base

Methods

traverseTermM :: Monad m => (Term -> m Term) -> CompareAs -> m CompareAs

foldTerm :: Monoid m => (Term -> m) -> CompareAs -> m

PrettyTCM CompareAs

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => CompareAs -> m Doc

IsSizeType CompareAs

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => CompareAs -> m (Maybe BoundedSize)

MentionsMeta CompareAs

Defined in Agda.TypeChecking.MetaVars.Mention

Methods

mentionsMetas :: HashSet MetaId -> CompareAs -> Bool

InstantiateFull CompareAs

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: CompareAs -> ReduceM CompareAs

Normalise CompareAs

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: CompareAs -> ReduceM CompareAs

Simplify CompareAs

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: CompareAs -> ReduceM CompareAs

Reduce CompareAs

Defined in Agda.TypeChecking.Reduce

Methods

reduce' :: CompareAs -> ReduceM CompareAs

reduceB' :: CompareAs -> ReduceM (Blocked CompareAs)

IsMeta CompareAs

Defined in Agda.TypeChecking.Reduce

Methods

isMeta :: HasBuiltins m => CompareAs -> m (Maybe MetaId)

Instantiate CompareAs

Defined in Agda.TypeChecking.Reduce

Methods

instantiate' :: CompareAs -> ReduceM CompareAs

Subst Term CompareAs

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' Term -> CompareAs -> CompareAs

data CompareDirection

An extension of Comparison to >=.

Constructors

DirEq

DirLeq

DirGeq

Instances

Eq CompareDirection

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: CompareDirection -> CompareDirection -> Bool

(/=) :: CompareDirection -> CompareDirection -> Bool

Show CompareDirection

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> CompareDirection -> ShowS

show :: CompareDirection -> String

showList :: [CompareDirection] -> ShowS

Pretty CompareDirection

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: CompareDirection -> Doc

prettyPrec :: Int -> CompareDirection -> Doc

prettyList :: [CompareDirection] -> Doc

data Constraint

Constructors

ValueCmp Comparison CompareAs Term Term

ValueCmpOnFace Comparison Term Type Term Term

ElimCmp [Polarity] [IsForced] Type Term [Elim] [Elim]

TelCmp Type Type Comparison Telescope Telescope

the two types are for the error message only

SortCmp Comparison Sort Sort

LevelCmp Comparison Level Level

HasBiggerSort Sort

HasPTSRule (Dom Type) (Abs Sort)

CheckMetaInst MetaId

UnBlock MetaId

Guarded Constraint ProblemId

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 MetaId) (Maybe [Candidate])

the first argument is the instance argument, the second one is the meta on which the constraint may be blocked on and the third one is the list of candidates (or Nothing if we haven’t determined the list of candidates yet)

CheckFunDef Delayed DefInfo QName [Clause]

UnquoteTactic (Maybe MetaId) Term Term Type

First argument is computation and the others are hole and goal type

Instances

Data Constraint

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Constraint -> c Constraint

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Constraint

toConstr :: Constraint -> Constr

dataTypeOf :: Constraint -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Constraint)

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

gmapT :: (forall b. Data b => b -> b) -> Constraint -> Constraint

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Constraint -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Constraint -> r

gmapQ :: (forall d. Data d => d -> u) -> Constraint -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Constraint -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint

Show Constraint

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Constraint -> ShowS

show :: Constraint -> String

showList :: [Constraint] -> ShowS

HasRange Constraint

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: Constraint -> Range

Free Constraint

Defined in Agda.TypeChecking.Monad.Base

Methods

freeVars' :: IsVarSet a c => Constraint -> FreeM a c

TermLike Constraint

Defined in Agda.TypeChecking.Monad.Base

Methods

traverseTermM :: Monad m => (Term -> m Term) -> Constraint -> m Constraint

foldTerm :: Monoid m => (Term -> m) -> Constraint -> m

PrettyTCM Constraint

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Constraint -> m Doc

MentionsMeta Constraint

Defined in Agda.TypeChecking.MetaVars.Mention

Methods

mentionsMetas :: HashSet MetaId -> Constraint -> Bool

InstantiateFull Constraint

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Constraint -> ReduceM Constraint

Normalise Constraint

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: Constraint -> ReduceM Constraint

Simplify Constraint

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: Constraint -> ReduceM Constraint

Reduce Constraint

Defined in Agda.TypeChecking.Reduce

Methods

reduce' :: Constraint -> ReduceM Constraint

reduceB' :: Constraint -> ReduceM (Blocked Constraint)

Instantiate Constraint

Defined in Agda.TypeChecking.Reduce

Methods

instantiate' :: Constraint -> ReduceM Constraint

Subst Term Constraint

Defined in Agda.TypeChecking.Substitute

Methods

applySubst :: Substitution' Term -> Constraint -> Constraint

Reify Constraint (OutputConstraint Expr Expr)

Defined in Agda.Interaction.BasicOps

Methods

reify :: MonadReify m => Constraint -> m (OutputConstraint Expr Expr)

reifyWhen :: MonadReify m => Bool -> Constraint -> m (OutputConstraint Expr Expr)

data ProblemConstraint

Constructors

PConstr

Fields

• constraintProblems :: Set ProblemId
• theConstraint :: Closure Constraint

Instances

Data ProblemConstraint

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProblemConstraint -> c ProblemConstraint

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ProblemConstraint

toConstr :: ProblemConstraint -> Constr

dataTypeOf :: ProblemConstraint -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ProblemConstraint)

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

gmapT :: (forall b. Data b => b -> b) -> ProblemConstraint -> ProblemConstraint

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProblemConstraint -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProblemConstraint -> r

gmapQ :: (forall d. Data d => d -> u) -> ProblemConstraint -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProblemConstraint -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProblemConstraint -> m ProblemConstraint

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProblemConstraint -> m ProblemConstraint

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProblemConstraint -> m ProblemConstraint

Show ProblemConstraint

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> ProblemConstraint -> ShowS

show :: ProblemConstraint -> String

showList :: [ProblemConstraint] -> ShowS

HasRange ProblemConstraint

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: ProblemConstraint -> Range

PrettyTCM ProblemConstraint

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => ProblemConstraint -> m Doc

MentionsMeta ProblemConstraint

Defined in Agda.TypeChecking.MetaVars.Mention

Methods

mentionsMetas :: HashSet MetaId -> ProblemConstraint -> Bool

InstantiateFull ProblemConstraint

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: ProblemConstraint -> ReduceM ProblemConstraint

Normalise ProblemConstraint

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: ProblemConstraint -> ReduceM ProblemConstraint

Simplify ProblemConstraint

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: ProblemConstraint -> ReduceM ProblemConstraint

Reify ProblemConstraint (Closure (OutputForm Expr Expr))

Defined in Agda.Interaction.BasicOps

Methods

reify :: MonadReify m => ProblemConstraint -> m (Closure (OutputForm Expr Expr))

reifyWhen :: MonadReify m => Bool -> ProblemConstraint -> m (Closure (OutputForm Expr Expr))

type Constraints = [ProblemConstraint]

class LensClosure a b | b -> a where

Methods

lensClosure :: Lens' (Closure a) b

Instances

LensClosure Range MetaInfo

Defined in Agda.TypeChecking.Monad.Base

Methods

lensClosure :: Lens' (Closure Range) MetaInfo

LensClosure Range MetaVariable

Defined in Agda.TypeChecking.Monad.Base

Methods

lensClosure :: Lens' (Closure Range) MetaVariable

LensClosure a (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

lensClosure :: Lens' (Closure a) (Closure a)

data Closure a

Constructors

Closure

Fields

• clSignature :: Signature
• clEnv :: TCEnv
• clScope :: ScopeInfo
• clModuleCheckpoints :: Map ModuleName CheckpointId
• clValue :: a

Instances

Functor Closure

Defined in Agda.TypeChecking.Monad.Base

Methods

fmap :: (a -> b) -> Closure a -> Closure b

(<$) :: a -> Closure b -> Closure a

Foldable Closure

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => Closure m -> m

foldMap :: Monoid m => (a -> m) -> Closure a -> m

foldMap' :: Monoid m => (a -> m) -> Closure a -> m

foldr :: (a -> b -> b) -> b -> Closure a -> b

foldr' :: (a -> b -> b) -> b -> Closure a -> b

foldl :: (b -> a -> b) -> b -> Closure a -> b

foldl' :: (b -> a -> b) -> b -> Closure a -> b

foldr1 :: (a -> a -> a) -> Closure a -> a

foldl1 :: (a -> a -> a) -> Closure a -> a

toList :: Closure a -> [a]

null :: Closure a -> Bool

length :: Closure a -> Int

elem :: Eq a => a -> Closure a -> Bool

maximum :: Ord a => Closure a -> a

minimum :: Ord a => Closure a -> a

sum :: Num a => Closure a -> a

product :: Num a => Closure a -> a

LensClosure a (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

lensClosure :: Lens' (Closure a) (Closure a)

Reify ProblemConstraint (Closure (OutputForm Expr Expr))

Defined in Agda.Interaction.BasicOps

Methods

reify :: MonadReify m => ProblemConstraint -> m (Closure (OutputForm Expr Expr))

reifyWhen :: MonadReify m => Bool -> ProblemConstraint -> m (Closure (OutputForm Expr Expr))

Data a => Data (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Closure a -> c (Closure a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Closure a)

toConstr :: Closure a -> Constr

dataTypeOf :: Closure a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Closure a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Closure a))

gmapT :: (forall b. Data b => b -> b) -> Closure a -> Closure a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Closure a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Closure a -> r

gmapQ :: (forall d. Data d => d -> u) -> Closure a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Closure a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Closure a -> m (Closure a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Closure a -> m (Closure a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Closure a -> m (Closure a)

Show a => Show (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Closure a -> ShowS

show :: Closure a -> String

showList :: [Closure a] -> ShowS

KillRange a => KillRange (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

killRange :: KillRangeT (Closure a)

HasRange a => HasRange (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

getRange :: Closure a -> Range

LensIsAbstract (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

lensIsAbstract :: Lens' IsAbstract (Closure a)

LensTCEnv (Closure a)

Defined in Agda.TypeChecking.Monad.Base

Methods

lensTCEnv :: Lens' TCEnv (Closure a)

PrettyTCM a => PrettyTCM (Closure a)

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => Closure a -> m Doc

MentionsMeta a => MentionsMeta (Closure a)

Defined in Agda.TypeChecking.MetaVars.Mention

Methods

mentionsMetas :: HashSet MetaId -> Closure a -> Bool

InstantiateFull a => InstantiateFull (Closure a)

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Closure a -> ReduceM (Closure a)

Normalise a => Normalise (Closure a)

Defined in Agda.TypeChecking.Reduce

Methods

normalise' :: Closure a -> ReduceM (Closure a)

Simplify a => Simplify (Closure a)

Defined in Agda.TypeChecking.Reduce

Methods

simplify' :: Closure a -> ReduceM (Closure a)

Reduce a => Reduce (Closure a)

Defined in Agda.TypeChecking.Reduce

Methods

reduce' :: Closure a -> ReduceM (Closure a)

reduceB' :: Closure a -> ReduceM (Blocked (Closure a))

Instantiate a => Instantiate (Closure a)

Defined in Agda.TypeChecking.Reduce

Methods

instantiate' :: Closure a -> ReduceM (Closure a)

data Interface

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 String

  User warnings for imported identifiers

• iImportWarning :: Maybe String

  Whether this module should raise a warning when imported

• iBuiltin :: BuiltinThings (String, QName)
• iForeignCode :: Map BackendName [ForeignCode]
• iHighlighting :: HighlightingInfo
• iPragmaOptions :: [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

Show Interface

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> Interface -> ShowS

show :: Interface -> String

showList :: [Interface] -> ShowS

Pretty Interface

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: Interface -> Doc

prettyPrec :: Int -> Interface -> Doc

prettyList :: [Interface] -> Doc

EmbPrj Interface

Defined in Agda.TypeChecking.Serialise.Instances

Methods

icode :: Interface -> S Int32

icod_ :: Interface -> S Int32

value :: Int32 -> R Interface

InstantiateFull Interface

Defined in Agda.TypeChecking.Reduce

Methods

instantiateFull' :: Interface -> ReduceM Interface

data ForeignCode

Constructors

ForeignCode Range String

Instances

Show ForeignCode

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> ForeignCode -> ShowS

show :: ForeignCode -> String

showList :: [ForeignCode] -> ShowS

EmbPrj ForeignCode

Defined in Agda.TypeChecking.Serialise.Instances.Compilers

Methods

icode :: ForeignCode -> S Int32

icod_ :: ForeignCode -> S Int32

value :: Int32 -> R ForeignCode

type DecodedModules = Map TopLevelModuleName Interface

type VisitedModules = Map TopLevelModuleName ModuleInfo

data ModuleInfo

Constructors

ModuleInfo

Fields

• miInterface :: Interface
• miWarnings :: Bool

  True if warnings were encountered when the module was type checked.

• miPrimitive :: Bool

  True if the module is a primitive module, which should always be importable.

class Monad m => MonadStConcreteNames m where

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

useConcreteNames :: m ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> m ()

Instances

MonadStConcreteNames TCM

Defined in Agda.TypeChecking.Monad.Base

Methods

runStConcreteNames :: StateT ConcreteNames TCM a -> TCM a

useConcreteNames :: TCM ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> TCM ()

MonadStConcreteNames AbsToCon

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

runStConcreteNames :: StateT ConcreteNames AbsToCon a -> AbsToCon a

useConcreteNames :: AbsToCon ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> AbsToCon ()

ReadTCState m => MonadStConcreteNames (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

runStConcreteNames :: StateT ConcreteNames (PureConversionT m) a -> PureConversionT m a

useConcreteNames :: PureConversionT m ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> PureConversionT m ()

MonadStConcreteNames m => MonadStConcreteNames (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

runStConcreteNames :: StateT ConcreteNames (ReaderT r m) a -> ReaderT r m a

useConcreteNames :: ReaderT r m ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> ReaderT r m ()

MonadStConcreteNames m => MonadStConcreteNames (StateT s m)

Defined in Agda.TypeChecking.Monad.Base

Methods

runStConcreteNames :: StateT ConcreteNames (StateT s m) a -> StateT s m a

useConcreteNames :: StateT s m ConcreteNames

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> StateT s m ()

type SourceToModule = Map AbsolutePath TopLevelModuleName

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

class FreshName a where

Create a fresh name from a.

Methods

freshName_ :: MonadFresh NameId m => a -> m Name

Instances

FreshName ()

Defined in Agda.TypeChecking.Monad.Base

Methods

freshName_ :: MonadFresh NameId m => () -> m Name

FreshName String

Defined in Agda.TypeChecking.Monad.Base

Methods

freshName_ :: MonadFresh NameId m => String -> m Name

FreshName Range

Defined in Agda.TypeChecking.Monad.Base

Methods

freshName_ :: MonadFresh NameId m => Range -> m Name

FreshName (Range, String)

Defined in Agda.TypeChecking.Monad.Base

Methods

freshName_ :: MonadFresh NameId m => (Range, String) -> m Name

newtype CheckpointId

Constructors

CheckpointId Int

Instances

Enum CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: CheckpointId -> CheckpointId

pred :: CheckpointId -> CheckpointId

toEnum :: Int -> CheckpointId

fromEnum :: CheckpointId -> Int

enumFrom :: CheckpointId -> [CheckpointId]

enumFromThen :: CheckpointId -> CheckpointId -> [CheckpointId]

enumFromTo :: CheckpointId -> CheckpointId -> [CheckpointId]

enumFromThenTo :: CheckpointId -> CheckpointId -> CheckpointId -> [CheckpointId]

Eq CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: CheckpointId -> CheckpointId -> Bool

(/=) :: CheckpointId -> CheckpointId -> Bool

Integral CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

quot :: CheckpointId -> CheckpointId -> CheckpointId

rem :: CheckpointId -> CheckpointId -> CheckpointId

div :: CheckpointId -> CheckpointId -> CheckpointId

mod :: CheckpointId -> CheckpointId -> CheckpointId

quotRem :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)

divMod :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)

toInteger :: CheckpointId -> Integer

Data CheckpointId

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CheckpointId

toConstr :: CheckpointId -> Constr

dataTypeOf :: CheckpointId -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CheckpointId)

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

gmapT :: (forall b. Data b => b -> b) -> CheckpointId -> CheckpointId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r

gmapQ :: (forall d. Data d => d -> u) -> CheckpointId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> CheckpointId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId

Num CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

(+) :: CheckpointId -> CheckpointId -> CheckpointId

(-) :: CheckpointId -> CheckpointId -> CheckpointId

(*) :: CheckpointId -> CheckpointId -> CheckpointId

negate :: CheckpointId -> CheckpointId

abs :: CheckpointId -> CheckpointId

signum :: CheckpointId -> CheckpointId

fromInteger :: Integer -> CheckpointId

Ord CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: CheckpointId -> CheckpointId -> Ordering

(<) :: CheckpointId -> CheckpointId -> Bool

(<=) :: CheckpointId -> CheckpointId -> Bool

(>) :: CheckpointId -> CheckpointId -> Bool

(>=) :: CheckpointId -> CheckpointId -> Bool

max :: CheckpointId -> CheckpointId -> CheckpointId

min :: CheckpointId -> CheckpointId -> CheckpointId

Real CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

toRational :: CheckpointId -> Rational

Show CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> CheckpointId -> ShowS

show :: CheckpointId -> String

showList :: [CheckpointId] -> ShowS

Pretty CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

pretty :: CheckpointId -> Doc

prettyPrec :: Int -> CheckpointId -> Doc

prettyList :: [CheckpointId] -> Doc

HasFresh CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' CheckpointId TCState

nextFresh' :: CheckpointId -> CheckpointId

EmbPrj CheckpointId

Defined in Agda.TypeChecking.Serialise.Instances.Internal

Methods

icode :: CheckpointId -> S Int32

icod_ :: CheckpointId -> S Int32

value :: Int32 -> R CheckpointId

PrettyTCM CheckpointId

Defined in Agda.TypeChecking.Pretty

Methods

prettyTCM :: MonadPretty m => CheckpointId -> m Doc

class Monad m => MonadFresh i m where

Methods

fresh :: m i

Instances

HasFresh i => MonadFresh i TCM

Defined in Agda.TypeChecking.Monad.Base

Methods

fresh :: TCM i

Monad m => MonadFresh Int (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

fresh :: PureConversionT m Int

Monad m => MonadFresh NameId (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

fresh :: PureConversionT m NameId

Monad m => MonadFresh ProblemId (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

fresh :: PureConversionT m ProblemId

MonadFresh i m => MonadFresh i (StateT s m)

Defined in Agda.TypeChecking.Monad.Base

Methods

fresh :: StateT s m i

MonadFresh i m => MonadFresh i (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

fresh :: ReaderT r m i

class Enum i => HasFresh i where

Minimal complete definition

freshLens

Methods

freshLens :: Lens' i TCState

nextFresh' :: i -> i

Instances

HasFresh Int

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' Int TCState

nextFresh' :: Int -> Int

HasFresh InteractionId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' InteractionId TCState

nextFresh' :: InteractionId -> InteractionId

HasFresh MetaId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' MetaId TCState

nextFresh' :: MetaId -> MetaId

HasFresh NameId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' NameId TCState

nextFresh' :: NameId -> NameId

HasFresh ProblemId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' ProblemId TCState

nextFresh' :: ProblemId -> ProblemId

HasFresh MutualId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' MutualId TCState

nextFresh' :: MutualId -> MutualId

HasFresh CheckpointId

Defined in Agda.TypeChecking.Monad.Base

Methods

freshLens :: Lens' CheckpointId TCState

nextFresh' :: CheckpointId -> CheckpointId

data TypeCheckAction

A complete log for a module will look like this:

• Pragmas
• EnterSection, entering the main module.
• DeclEnterSectionLeaveSection, for declarations and nested modules
• LeaveSection, leaving the main module.

Constructors

EnterSection !ModuleInfo !ModuleName !Telescope

LeaveSection !ModuleName

Decl !Declaration

Never a Section or ScopeDecl

Pragmas !PragmaOptions

type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)]

Like CachedTypeCheckLog, but storing the log for an ongoing type checking of a module. Stored in reverse order (last performed action first).

type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)]

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

Constructors

LoadedFileCache

Fields

• lfcCached :: !CachedTypeCheckLog
• lfcCurrent :: !CurrentTypeCheckLog

data PersistentTCState

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

LensPersistentVerbosity PersistentTCState

Defined in Agda.Interaction.Options.Lenses

Methods

getPersistentVerbosity :: PersistentTCState -> PersistentVerbosity

setPersistentVerbosity :: PersistentVerbosity -> PersistentTCState -> PersistentTCState

mapPersistentVerbosity :: (PersistentVerbosity -> PersistentVerbosity) -> PersistentTCState -> PersistentTCState

LensIncludePaths PersistentTCState

Defined in Agda.Interaction.Options.Lenses

Methods

getIncludePaths :: PersistentTCState -> [FilePath]

setIncludePaths :: [FilePath] -> PersistentTCState -> PersistentTCState

mapIncludePaths :: ([FilePath] -> [FilePath]) -> PersistentTCState -> PersistentTCState

getAbsoluteIncludePaths :: PersistentTCState -> [AbsolutePath]

setAbsoluteIncludePaths :: [AbsolutePath] -> PersistentTCState -> PersistentTCState

mapAbsoluteIncludePaths :: ([AbsolutePath] -> [AbsolutePath]) -> PersistentTCState -> PersistentTCState

LensSafeMode PersistentTCState

Defined in Agda.Interaction.Options.Lenses

Methods

getSafeMode :: PersistentTCState -> SafeMode

setSafeMode :: SafeMode -> PersistentTCState -> PersistentTCState

mapSafeMode :: (SafeMode -> SafeMode) -> PersistentTCState -> PersistentTCState

LensCommandLineOptions PersistentTCState

Defined in Agda.Interaction.Options.Lenses

Methods

getCommandLineOptions :: PersistentTCState -> CommandLineOptions

setCommandLineOptions :: CommandLineOptions -> PersistentTCState -> PersistentTCState

mapCommandLineOptions :: (CommandLineOptions -> CommandLineOptions) -> PersistentTCState -> PersistentTCState

data MutualBlock

A mutual block of names in the signature.

Constructors

MutualBlock

Fields

• mutualInfo :: MutualInfo

  The original info of the mutual block.

• mutualNames :: Set QName

Instances

Eq MutualBlock

Defined in Agda.TypeChecking.Monad.Base

Methods

(==) :: MutualBlock -> MutualBlock -> Bool

(/=) :: MutualBlock -> MutualBlock -> Bool

Show MutualBlock

Defined in Agda.TypeChecking.Monad.Base

Methods

showsPrec :: Int -> MutualBlock -> ShowS

show :: MutualBlock -> String

showList :: [MutualBlock] -> ShowS

Null MutualBlock

Defined in Agda.TypeChecking.Monad.Base

Methods

empty :: MutualBlock

null :: MutualBlock -> Bool

data PostScopeState

Constructors

PostScopeState

Fields

• stPostSyntaxInfo :: !CompressedFile

  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

type ConcreteNames = Map Name [Name]

type DisambiguatedNames = IntMap QName

data PreScopeState

Constructors

PreScopeState

Fields

• stPreTokens :: !CompressedFile

  Highlighting info for tokens (but not those tokens for which highlighting exists in stSyntaxInfo).

• 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 String)

  Imported UserWarnings, not to be stored in the Interface

• stPreLocalUserWarnings :: !(Map QName String)

  Locally defined UserWarnings, to be stored in the Interface

• stPreWarningOnImport :: !(Maybe String)

  Whether the current module should raise a warning when opened

• stPreImportedPartialDefs :: !(Set QName)

  Imported partial definitions, not to be stored in the Interface

class Monad m => ReadTCState m where

Minimal complete definition

getTCState, locallyTCState

Methods

getTCState :: m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> m b -> m b

withTCState :: (TCState -> TCState) -> m a -> m a

Instances

ReadTCState ReduceM

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: ReduceM TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> ReduceM b -> ReduceM b

withTCState :: (TCState -> TCState) -> ReduceM a -> ReduceM a

ReadTCState AbsToCon

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

getTCState :: AbsToCon TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> AbsToCon b -> AbsToCon b

withTCState :: (TCState -> TCState) -> AbsToCon a -> AbsToCon a

ReadTCState TerM

Defined in Agda.Termination.Monad

Methods

getTCState :: TerM TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> TerM b -> TerM b

withTCState :: (TCState -> TCState) -> TerM a -> TerM a

ReadTCState m => ReadTCState (MaybeT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: MaybeT m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> MaybeT m b -> MaybeT m b

withTCState :: (TCState -> TCState) -> MaybeT m a -> MaybeT m a

ReadTCState m => ReadTCState (ListT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: ListT m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> ListT m b -> ListT m b

withTCState :: (TCState -> TCState) -> ListT m a -> ListT m a

MonadIO m => ReadTCState (TCMT m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: TCMT m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> TCMT m b -> TCMT m b

withTCState :: (TCState -> TCState) -> TCMT m a -> TCMT m a

ReadTCState m => ReadTCState (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

getTCState :: NamesT m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> NamesT m b -> NamesT m b

withTCState :: (TCState -> TCState) -> NamesT m a -> NamesT m a

ReadTCState m => ReadTCState (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

getTCState :: PureConversionT m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> PureConversionT m b -> PureConversionT m b

withTCState :: (TCState -> TCState) -> PureConversionT m a -> PureConversionT m a

ReadTCState m => ReadTCState (ExceptT err m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: ExceptT err m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> ExceptT err m b -> ExceptT err m b

withTCState :: (TCState -> TCState) -> ExceptT err m a -> ExceptT err m a

ReadTCState m => ReadTCState (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: ReaderT r m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> ReaderT r m b -> ReaderT r m b

withTCState :: (TCState -> TCState) -> ReaderT r m a -> ReaderT r m a

ReadTCState m => ReadTCState (StateT s m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: StateT s m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> StateT s m b -> StateT s m b

withTCState :: (TCState -> TCState) -> StateT s m a -> StateT s m a

(Monoid w, ReadTCState m) => ReadTCState (WriterT w m)

Defined in Agda.TypeChecking.Monad.Base

Methods

getTCState :: WriterT w m TCState

locallyTCState :: Lens' a TCState -> (a -> a) -> WriterT w m b -> WriterT w m b

withTCState :: (TCState -> TCState) -> WriterT w m a -> WriterT w m a

initPersistentState :: PersistentTCState

Empty persistent state.

initPreScopeState :: PreScopeState

Empty state of type checker.

initPostScopeState :: PostScopeState

initState :: TCState

stTokens :: Lens' CompressedFile 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 String) TCState

stLocalUserWarnings :: Lens' (Map QName String) TCState

getUserWarnings :: ReadTCState m => m (Map QName String)

stWarningOnImport :: Lens' (Maybe String) 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

stFreshNameId :: Lens' NameId TCState

stSyntaxInfo :: Lens' CompressedFile 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

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)

Lookup an AbsolutePath in sourceToModule.

O(n).

iFullHash :: Interface -> Hash

Combines the source hash and the (full) hashes of the imported modules.

buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a)

fromCmp :: Comparison -> CompareDirection

Embed Comparison into CompareDirection.

flipCmp :: CompareDirection -> CompareDirection

Flip the direction of comparison.

dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c

Turn a Comparison function into a CompareDirection function.

Property: dirToCmp f (fromCmp cmp) = f cmp

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]

By default, we have no display form.

theDefLens :: Lens' Defn Definition

defaultDefn :: ArgInfo -> QName -> Type -> Defn -> Definition

Create a definition with sensible defaults.

jsBackendName :: BackendName

ghcBackendName :: BackendName

noCompiledRep :: CompiledRepresentation

modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo

projDropPars :: Projection -> ProjOrigin -> Term

Building the projection function (which drops the parameters).

projArgInfo :: Projection -> ArgInfo

The info of the principal (record) argument.

setEtaEquality :: EtaEquality -> HasEta -> EtaEquality

Make sure we do not overwrite a user specification.

emptyCompKit :: CompKit

recRecursive :: Defn -> Bool

Is the record type recursive?

recEtaEquality :: Defn -> HasEta

emptyFunction :: Defn

A template for creating Function definitions, with sensible defaults.

funFlag :: FunctionFlag -> Lens' Bool Defn

funStatic :: Lens' Bool Defn

funInline :: Lens' Bool Defn

funMacro :: Lens' Bool Defn

isMacro :: Defn -> Bool

isEmptyFunction :: Defn -> Bool

Checking whether we are dealing with a function yet to be defined.

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

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

notReduced :: a -> MaybeReduced a

reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)

allReductions :: AllowedReductions

Not quite all reductions (skip non-terminating reductions)

reallyAllReductions :: AllowedReductions

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

Are the clauses of this definition delayed?

defNonterminating :: Definition -> Bool

Has the definition failed the termination checker?

defTerminationUnconfirmed :: Definition -> Bool

Has the definition not termination checked or did the check fail?

defAbstract :: Definition -> IsAbstract

defForced :: Definition -> [IsForced]

ifTopLevelAndHighlightingLevelIsOr :: MonadTCM tcm => HighlightingLevel -> Bool -> tcm () -> tcm ()

ifTopLevelAndHighlightingLevelIs l b m runs m when we're type-checking the top-level module and either the highlighting level is at least l or b is True.

ifTopLevelAndHighlightingLevelIs :: MonadTCM tcm => HighlightingLevel -> tcm () -> tcm ()

ifTopLevelAndHighlightingLevelIs l m runs m when we're type-checking the top-level module and the highlighting level is at least l.

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

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

eModuleNestingLevel :: Lens' Int TCEnv

eExpandLast :: Lens' ExpandHidden TCEnv

eAppDef :: Lens' (Maybe QName) TCEnv

eSimplification :: Lens' Simplification TCEnv

eAllowedReductions :: Lens' AllowedReductions TCEnv

eInjectivityDepth :: Lens' Int TCEnv

eCompareBlocked :: Lens' Bool TCEnv

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

aDefToMode :: IsAbstract -> AbstractMode

aModeToDef :: AbstractMode -> Maybe IsAbstract

isDontExpandLast :: ExpandHidden -> Bool

warningName :: Warning -> WarningName

tcWarningOrigin :: TCWarning -> SrcFile

sizedTypesOption :: HasOptions m => m Bool

guardednessOption :: HasOptions m => m Bool

withoutKOption :: HasOptions m => m Bool

getIncludeDirs :: HasOptions m => m [AbsolutePath]

Gets the include directories.

Precondition: optAbsoluteIncludePaths must be nonempty (i.e. setCommandLineOptions must have run).

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

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

Modify the lens-indicated part of the TCEnv in a subcomputation.

getsTC :: ReadTCState m => (TCState -> a) -> m a

modifyTC' :: MonadTCState m => (TCState -> TCState) -> m ()

A variant of modifyTC in which the computation is strict in the new state.

useTC :: ReadTCState m => Lens' a TCState -> m a

setTCLens :: MonadTCState m => Lens' a TCState -> a -> m () infix 4

Overwrite the part of the TCState focused on by the lens.

modifyTCLens :: MonadTCState m => Lens' a TCState -> (a -> a) -> m ()

Modify the part of the TCState focused on by the lens.

modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m ()

Modify a part of the state monadically.

stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r, a)) -> m r

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

Modify a part of the state monadically, and return some result.

mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a

pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a

returnTCMT :: MonadIO m => a -> TCMT m a

bindTCMT :: MonadIO m => TCMT m a -> (a -> TCMT m b) -> TCMT m b

thenTCMT :: MonadIO m => TCMT m a -> TCMT m b -> TCMT m b

fmapTCMT :: MonadIO m => (a -> b) -> TCMT m a -> TCMT m b

apTCMT :: MonadIO m => TCMT m (a -> b) -> TCMT m a -> TCMT m b

runIM :: IM a -> TCM a

catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a

Preserve the state of the failing computation.

finally_ :: TCM a -> TCM b -> TCM a

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.

patternViolation :: MonadError TCErr m => m a

internalError :: MonadTCM tcm => String -> tcm a

genericError :: (MonadTCEnv m, ReadTCState m, MonadError TCErr m) => String -> m a

genericDocError :: (MonadTCEnv m, ReadTCState m, MonadError TCErr m) => Doc -> m a

typeError :: (MonadTCEnv m, ReadTCState m, MonadError TCErr m) => TypeError -> m a

typeError_ :: (MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr

runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState)

Running the type checking monad (most general form).

runTCMTop :: TCM a -> IO (Either TCErr a)

Running the type checking monad on toplevel (with initial state).

runTCMTop' :: MonadIO m => TCMT m a -> m a

runSafeTCM :: TCM a -> TCState -> IO (a, TCState)

runSafeTCM runs a safe TCM action (a TCM action which cannot fail) in the initial environment.

forkTCM :: TCM a -> TCM ()

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

Base name for patterns in telescopes

extendedLambdaName :: String

Base name for extended lambda patterns

isExtendedLambdaName :: QName -> Bool

Check whether we have an definition from an extended lambda.

absurdLambdaName :: String

Name of absurdLambda definitions.

isAbsurdLambdaName :: QName -> Bool

Check whether we have an definition from an absurd lambda.

generalizedFieldName :: String

Base name for generalized variable projections

getGeneralizedFieldName :: QName -> Maybe String

Check whether we have a generalized variable field

class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m where

Methods

freshInteractionId :: m InteractionId

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> m ()

Instances

MonadInteractionPoints TCM

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

freshInteractionId :: TCM InteractionId

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> TCM ()

(MonadTCEnv m, ReadTCState m) => MonadInteractionPoints (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

freshInteractionId :: PureConversionT m InteractionId

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> PureConversionT m ()

MonadInteractionPoints m => MonadInteractionPoints (ReaderT r m)

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

freshInteractionId :: ReaderT r m InteractionId

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> ReaderT r m ()

MonadInteractionPoints m => MonadInteractionPoints (StateT r m)

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

freshInteractionId :: StateT r m InteractionId

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> StateT r 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 :: TCM VisitedModules

isVisited :: TopLevelModuleName -> TCM Bool

getVisitedModule :: TopLevelModuleName -> TCM (Maybe ModuleInfo)

mapVisitedModule :: TopLevelModuleName -> (ModuleInfo -> ModuleInfo) -> TCM ()

getDecodedModules :: TCM DecodedModules

setDecodedModules :: DecodedModules -> TCM ()

getDecodedModule :: TopLevelModuleName -> TCM (Maybe Interface)

storeDecodedModule :: Interface -> TCM ()

dropDecodedModule :: TopLevelModuleName -> TCM ()

withImportPath :: [TopLevelModuleName] -> TCM a -> TCM a

checkForImportCycle :: TCM ()

Assumes that the first module in the import path is the module we are worried about.

currentModule :: MonadTCEnv m => m ModuleName

Get the name of the current module, if any.

withCurrentModule :: MonadTCEnv m => ModuleName -> m a -> m a

Set the name of the current module.

getCurrentPath :: MonadTCEnv m => m AbsolutePath

Get the path of the currently checked file

getAnonymousVariables :: MonadTCEnv m => ModuleName -> m Nat

Get the number of variables bound by anonymous modules.

withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a

Add variables bound by an anonymous module.

withEnv :: MonadTCEnv m => TCEnv -> m a -> m a

Set the current environment to the given

getEnv :: TCM TCEnv

Get the current environment

withIncreasedModuleNestingLevel :: TCM a -> TCM a

Increases the module nesting level by one in the given computation.

withHighlightingLevel :: HighlightingLevel -> TCM a -> TCM a

Set highlighting level

withoutOptionsChecking :: TCM a -> TCM a

doExpandLast :: TCM a -> TCM a

Restore setting for ExpandLast to default.

dontExpandLast :: TCM a -> TCM a

reallyDontExpandLast :: TCM a -> TCM a

performedSimplification :: MonadTCEnv m => m a -> m a

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

getSimplification :: MonadTCEnv m => m Simplification

updateAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCEnv -> TCEnv

Lens for AllowedReductions.

modifyAllowedReductions :: MonadTCEnv m => (AllowedReductions -> AllowedReductions) -> m a -> m a

putAllowedReductions :: MonadTCEnv m => AllowedReductions -> m a -> m a

onlyReduceProjections :: MonadTCEnv m => m a -> m a

Reduce Def f vs only if f is a projection.

allowAllReductions :: MonadTCEnv m => m a -> m a

Allow all reductions except for non-terminating functions (default).

allowNonTerminatingReductions :: MonadTCEnv m => m a -> m a

Allow all reductions including non-terminating functions.

onlyReduceTypes :: MonadTCEnv m => m a -> m a

Allow all reductions when reducing types

typeLevelReductions :: MonadTCEnv m => m a -> m a

Update allowed reductions when working on types

insideDotPattern :: TCM a -> TCM a

isInsideDotPattern :: TCM Bool

callByName :: TCM a -> TCM a

Don't use call-by-need evaluation for the given computation.

class MonadTCEnv m => MonadAddContext m where

Methods

addCtx :: Name -> Dom Type -> m a -> m a

addCtx x arg cont add a variable to the context.

Chooses an unused Name.

Warning: Does not update module parameter substitution!

addLetBinding' :: Name -> Term -> Dom Type -> m a -> m a

Add a let bound variable to the context

updateContext :: Substitution -> (Context -> Context) -> m a -> m a

Update the context. Requires a substitution that transports things living in the old context to the new.

withFreshName :: Range -> ArgName -> (Name -> m a) -> m a

Instances

MonadAddContext TCM

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> TCM a -> TCM a

addLetBinding' :: Name -> Term -> Dom Type -> TCM a -> TCM a

updateContext :: Substitution -> (Context -> Context) -> TCM a -> TCM a

withFreshName :: Range -> ArgName -> (Name -> TCM a) -> TCM a

MonadAddContext ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

addCtx :: Name -> Dom Type -> ReduceM a -> ReduceM a

addLetBinding' :: Name -> Term -> Dom Type -> ReduceM a -> ReduceM a

updateContext :: Substitution -> (Context -> Context) -> ReduceM a -> ReduceM a

withFreshName :: Range -> ArgName -> (Name -> ReduceM a) -> ReduceM a

MonadAddContext TerM

Defined in Agda.Termination.Monad

Methods

addCtx :: Name -> Dom Type -> TerM a -> TerM a

addLetBinding' :: Name -> Term -> Dom Type -> TerM a -> TerM a

updateContext :: Substitution -> (Context -> Context) -> TerM a -> TerM a

withFreshName :: Range -> ArgName -> (Name -> TerM a) -> TerM a

MonadAddContext m => MonadAddContext (MaybeT m)

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> MaybeT m a -> MaybeT m a

addLetBinding' :: Name -> Term -> Dom Type -> MaybeT m a -> MaybeT m a

updateContext :: Substitution -> (Context -> Context) -> MaybeT m a -> MaybeT m a

withFreshName :: Range -> ArgName -> (Name -> MaybeT m a) -> MaybeT m a

MonadAddContext m => MonadAddContext (ListT m)

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> ListT m a -> ListT m a

addLetBinding' :: Name -> Term -> Dom Type -> ListT m a -> ListT m a

updateContext :: Substitution -> (Context -> Context) -> ListT m a -> ListT m a

withFreshName :: Range -> ArgName -> (Name -> ListT m a) -> ListT m a

MonadAddContext m => MonadAddContext (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

addCtx :: Name -> Dom Type -> NamesT m a -> NamesT m a

addLetBinding' :: Name -> Term -> Dom Type -> NamesT m a -> NamesT m a

updateContext :: Substitution -> (Context -> Context) -> NamesT m a -> NamesT m a

withFreshName :: Range -> ArgName -> (Name -> NamesT m a) -> NamesT m a

MonadAddContext m => MonadAddContext (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

addCtx :: Name -> Dom Type -> PureConversionT m a -> PureConversionT m a

addLetBinding' :: Name -> Term -> Dom Type -> PureConversionT m a -> PureConversionT m a

updateContext :: Substitution -> (Context -> Context) -> PureConversionT m a -> PureConversionT m a

withFreshName :: Range -> ArgName -> (Name -> PureConversionT m a) -> PureConversionT m a

MonadAddContext m => MonadAddContext (ExceptT e m)

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> ExceptT e m a -> ExceptT e m a

addLetBinding' :: Name -> Term -> Dom Type -> ExceptT e m a -> ExceptT e m a

updateContext :: Substitution -> (Context -> Context) -> ExceptT e m a -> ExceptT e m a

withFreshName :: Range -> ArgName -> (Name -> ExceptT e m a) -> ExceptT e m a

MonadAddContext m => MonadAddContext (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> ReaderT r m a -> ReaderT r m a

addLetBinding' :: Name -> Term -> Dom Type -> ReaderT r m a -> ReaderT r m a

updateContext :: Substitution -> (Context -> Context) -> ReaderT r m a -> ReaderT r m a

withFreshName :: Range -> ArgName -> (Name -> ReaderT r m a) -> ReaderT r m a

MonadAddContext m => MonadAddContext (StateT r m)

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> StateT r m a -> StateT r m a

addLetBinding' :: Name -> Term -> Dom Type -> StateT r m a -> StateT r m a

updateContext :: Substitution -> (Context -> Context) -> StateT r m a -> StateT r m a

withFreshName :: Range -> ArgName -> (Name -> StateT r m a) -> StateT r m a

(Monoid w, MonadAddContext m) => MonadAddContext (WriterT w m)

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> WriterT w m a -> WriterT w m a

addLetBinding' :: Name -> Term -> Dom Type -> WriterT w m a -> WriterT w m a

updateContext :: Substitution -> (Context -> Context) -> WriterT w m a -> WriterT w m a

withFreshName :: Range -> ArgName -> (Name -> WriterT w m a) -> WriterT w m a

checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution

Get the substitution from the context at a given checkpoint to the current context.

class (Functor m, Applicative m, MonadFail m) => HasBuiltins m where

Methods

getBuiltinThing :: String -> m (Maybe (Builtin PrimFun))

Instances

HasBuiltins ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

getBuiltinThing :: String -> ReduceM (Maybe (Builtin PrimFun))

HasBuiltins TerM

Defined in Agda.Termination.Monad

Methods

getBuiltinThing :: String -> TerM (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (MaybeT m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> MaybeT m (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (ListT m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> ListT m (Maybe (Builtin PrimFun))

MonadIO m => HasBuiltins (TCMT m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> TCMT m (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

getBuiltinThing :: String -> NamesT m (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

getBuiltinThing :: String -> PureConversionT m (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (ExceptT e m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> ExceptT e m (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (ReaderT e m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> ReaderT e m (Maybe (Builtin PrimFun))

HasBuiltins m => HasBuiltins (StateT s m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> StateT s m (Maybe (Builtin PrimFun))

(HasBuiltins m, Monoid w) => HasBuiltins (WriterT w m)

Defined in Agda.TypeChecking.Monad.Builtin

Methods

getBuiltinThing :: String -> WriterT w m (Maybe (Builtin PrimFun))

class TraceS a where

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

Instances

TraceS String

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m c -> m c

TraceS Doc

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> Doc -> m c -> m c

TraceS [String]

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [String] -> m c -> m c

TraceS [Doc]

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [Doc] -> m c -> m c

TraceS [TCM Doc]

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m c -> m c

TraceS (TCM Doc)

Defined in Agda.TypeChecking.Monad.Debug

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m c -> m c

class ReportS a where

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

Instances

ReportS String

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m ()

ReportS Doc

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> Doc -> m ()

ReportS [String]

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [String] -> m ()

ReportS [Doc]

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [Doc] -> m ()

ReportS [TCM Doc]

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m ()

ReportS (TCM Doc)

Defined in Agda.TypeChecking.Monad.Debug

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m ()

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

Minimal complete definition

formatDebugMessage, verboseBracket

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> m ()

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

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

getVerbosity :: m Verbosity

default getVerbosity :: HasOptions m => m Verbosity

isDebugPrinting :: m Bool

default isDebugPrinting :: MonadTCEnv m => m Bool

nowDebugPrinting :: m a -> m a

default nowDebugPrinting :: MonadTCEnv m => m a -> m a

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

Print brackets around debug messages issued by a computation.

Instances

MonadDebug TCM

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> TCM ()

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

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

getVerbosity :: TCM Verbosity

isDebugPrinting :: TCM Bool

nowDebugPrinting :: TCM a -> TCM a

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

MonadDebug ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> ReduceM ()

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

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

getVerbosity :: ReduceM Verbosity

isDebugPrinting :: ReduceM Bool

nowDebugPrinting :: ReduceM a -> ReduceM a

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

MonadDebug AbsToCon

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> AbsToCon ()

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

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

getVerbosity :: AbsToCon Verbosity

isDebugPrinting :: AbsToCon Bool

nowDebugPrinting :: AbsToCon a -> AbsToCon a

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

MonadDebug TerM

Defined in Agda.Termination.Monad

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> TerM ()

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

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

getVerbosity :: TerM Verbosity

isDebugPrinting :: TerM Bool

nowDebugPrinting :: TerM a -> TerM a

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

MonadDebug m => MonadDebug (MaybeT m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> MaybeT m ()

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

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

getVerbosity :: MaybeT m Verbosity

isDebugPrinting :: MaybeT m Bool

nowDebugPrinting :: MaybeT m a -> MaybeT m a

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

MonadDebug m => MonadDebug (ListT m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> ListT m ()

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

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

getVerbosity :: ListT m Verbosity

isDebugPrinting :: ListT m Bool

nowDebugPrinting :: ListT m a -> ListT m a

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

MonadDebug m => MonadDebug (ChangeT m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> ChangeT m ()

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

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

getVerbosity :: ChangeT m Verbosity

isDebugPrinting :: ChangeT m Bool

nowDebugPrinting :: ChangeT m a -> ChangeT m a

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

MonadDebug m => MonadDebug (NamesT m)

Defined in Agda.TypeChecking.Names

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> NamesT m ()

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

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

getVerbosity :: NamesT m Verbosity

isDebugPrinting :: NamesT m Bool

nowDebugPrinting :: NamesT m a -> NamesT m a

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

MonadDebug m => MonadDebug (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> PureConversionT m ()

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

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

getVerbosity :: PureConversionT m Verbosity

isDebugPrinting :: PureConversionT m Bool

nowDebugPrinting :: PureConversionT m a -> PureConversionT m a

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

MonadDebug m => MonadDebug (ExceptT e m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> ExceptT e m ()

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

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

getVerbosity :: ExceptT e m Verbosity

isDebugPrinting :: ExceptT e m Bool

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

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

MonadDebug m => MonadDebug (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> ReaderT r m ()

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

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

getVerbosity :: ReaderT r m Verbosity

isDebugPrinting :: ReaderT r m Bool

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

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

MonadDebug m => MonadDebug (IdentityT m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> IdentityT m ()

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

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

getVerbosity :: IdentityT m Verbosity

isDebugPrinting :: IdentityT m Bool

nowDebugPrinting :: IdentityT m a -> IdentityT m a

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

MonadDebug m => MonadDebug (StateT s m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> StateT s m ()

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

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

getVerbosity :: StateT s m Verbosity

isDebugPrinting :: StateT s m Bool

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

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

(MonadDebug m, Monoid w) => MonadDebug (WriterT w m)

Defined in Agda.TypeChecking.Monad.Debug

Methods

displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> WriterT w m ()

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

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

getVerbosity :: WriterT w m Verbosity

isDebugPrinting :: WriterT w m Bool

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

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

catchAndPrintImpossible :: (CatchImpossible m, Monad m) => VerboseKey -> VerboseLevel -> m String -> m String

During printing, catch internal errors of kind Impossible and print them.

reportSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m ()

Conditionally println debug string.

__IMPOSSIBLE_VERBOSE__ :: (HasCallStack, MonadDebug m) => String -> m a

reportSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m ()

Conditionally render debug Doc and print it.

reportResult :: MonadDebug m => VerboseKey -> VerboseLevel -> (a -> TCM Doc) -> m a -> m a

Debug print the result of a computation.

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

Conditionally render debug Doc, print it, and then continue.

openVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m ()

closeVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> m ()

parseVerboseKey :: VerboseKey -> [String]

hasVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool

Check whether a certain verbosity level is activated.

Precondition: The level must be non-negative.

hasExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool

Check whether a certain verbosity level is activated (exact match).

whenExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m ()

Run a computation if a certain verbosity level is activated (exact match).

__CRASH_WHEN__ :: (HasCallStack, MonadTCM m, MonadDebug m) => VerboseKey -> VerboseLevel -> m ()

verboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m ()

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

Apply a function if a certain verbosity level is activated.

Precondition: The level must be non-negative.

verbosity :: VerboseKey -> Lens' VerboseLevel TCState

Verbosity lens.

class ReadTCState m => MonadStatistics m where

Minimal complete definition

Nothing

Methods

modifyCounter :: String -> (Integer -> Integer) -> m ()

default modifyCounter :: (MonadStatistics n, MonadTrans t, t n ~ m) => String -> (Integer -> Integer) -> m ()

Instances

MonadStatistics TCM

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> TCM ()

MonadStatistics TerM

Defined in Agda.Termination.Monad

Methods

modifyCounter :: String -> (Integer -> Integer) -> TerM ()

MonadStatistics m => MonadStatistics (MaybeT m)

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> MaybeT m ()

ReadTCState m => MonadStatistics (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

modifyCounter :: String -> (Integer -> Integer) -> PureConversionT m ()

MonadStatistics m => MonadStatistics (ExceptT e m)

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> ExceptT e m ()

MonadStatistics m => MonadStatistics (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> ReaderT r m ()

MonadStatistics m => MonadStatistics (StateT s m)

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> StateT s m ()

(MonadStatistics m, Monoid w) => MonadStatistics (WriterT w m)

Defined in Agda.TypeChecking.Monad.Statistics

Methods

modifyCounter :: String -> (Integer -> Integer) -> WriterT w m ()

getStatistics :: ReadTCState m => m Statistics

Get the statistics.

modifyStatistics :: (Statistics -> Statistics) -> TCM ()

Modify the statistics via given function.

tick :: MonadStatistics m => String -> m ()

Increase specified counter by 1.

tickN :: MonadStatistics m => String -> Integer -> m ()

Increase specified counter by n.

tickMax :: MonadStatistics m => String -> Integer -> m ()

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

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

Minimal complete definition

Nothing

Methods

getConstInfo :: QName -> m Definition

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)

Version that reports exceptions:

default getConstInfo' :: (HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m (Either SigError Definition)

getRewriteRulesFor :: QName -> m RewriteRules

Lookup the rewrite rules with the given head symbol.

default getRewriteRulesFor :: (HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m RewriteRules

Instances

HasConstInfo ReduceM

Defined in Agda.TypeChecking.Reduce.Monad

Methods

getConstInfo :: QName -> ReduceM Definition

getConstInfo' :: QName -> ReduceM (Either SigError Definition)

getRewriteRulesFor :: QName -> ReduceM RewriteRules

HasConstInfo TerM

Defined in Agda.Termination.Monad

Methods

getConstInfo :: QName -> TerM Definition

getConstInfo' :: QName -> TerM (Either SigError Definition)

getRewriteRulesFor :: QName -> TerM RewriteRules

HasConstInfo m => HasConstInfo (MaybeT m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> MaybeT m Definition

getConstInfo' :: QName -> MaybeT m (Either SigError Definition)

getRewriteRulesFor :: QName -> MaybeT m RewriteRules

HasConstInfo m => HasConstInfo (ListT m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> ListT m Definition

getConstInfo' :: QName -> ListT m (Either SigError Definition)

getRewriteRulesFor :: QName -> ListT m RewriteRules

HasConstInfo (TCMT IO)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> TCMT IO Definition

getConstInfo' :: QName -> TCMT IO (Either SigError Definition)

getRewriteRulesFor :: QName -> TCMT IO RewriteRules

HasConstInfo m => HasConstInfo (ChangeT m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> ChangeT m Definition

getConstInfo' :: QName -> ChangeT m (Either SigError Definition)

getRewriteRulesFor :: QName -> ChangeT m RewriteRules

HasConstInfo m => HasConstInfo (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

getConstInfo :: QName -> PureConversionT m Definition

getConstInfo' :: QName -> PureConversionT m (Either SigError Definition)

getRewriteRulesFor :: QName -> PureConversionT m RewriteRules

HasConstInfo m => HasConstInfo (ExceptT err m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> ExceptT err m Definition

getConstInfo' :: QName -> ExceptT err m (Either SigError Definition)

getRewriteRulesFor :: QName -> ExceptT err m RewriteRules

HasConstInfo m => HasConstInfo (ReaderT r m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> ReaderT r m Definition

getConstInfo' :: QName -> ReaderT r m (Either SigError Definition)

getRewriteRulesFor :: QName -> ReaderT r m RewriteRules

HasConstInfo m => HasConstInfo (IdentityT m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> IdentityT m Definition

getConstInfo' :: QName -> IdentityT m (Either SigError Definition)

getRewriteRulesFor :: QName -> IdentityT m RewriteRules

HasConstInfo m => HasConstInfo (StateT s m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> StateT s m Definition

getConstInfo' :: QName -> StateT s m (Either SigError Definition)

getRewriteRulesFor :: QName -> StateT s m RewriteRules

(Monoid w, HasConstInfo m) => HasConstInfo (WriterT w m)

Defined in Agda.TypeChecking.Monad.Signature

Methods

getConstInfo :: QName -> WriterT w m Definition

getConstInfo' :: QName -> WriterT w m (Either SigError Definition)

getRewriteRulesFor :: QName -> WriterT w m RewriteRules

data SigError

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

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

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.

cachingStarts :: (MonadTCState m, ReadTCState m) => m ()

To be called before any write or restore calls.

areWeCaching :: ReadTCState m => m Bool

writeToCurrentLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => TypeCheckAction -> m ()

Writes a TypeCheckAction to the current log, using the current PostScopeState

restorePostScopeState :: (MonadDebug m, MonadTCState m) => PostScopeState -> m ()

localCache :: (MonadTCState m, ReadTCState m) => m a -> m a

Runs the action and restores the current cache at the end of it.

withoutCache :: (MonadTCState m, ReadTCState m) => m a -> m a

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

Reads the next entry in the cached type check log, if present.

cleanCachedLog :: (MonadDebug m, MonadTCState m) => m ()

Empties the "to read" CachedState. To be used when it gets invalid.

activateLoadedFileCache :: (HasOptions m, MonadDebug m, MonadTCState m) => m ()

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

Caches the current type check log. Discardes the old cache. Does nothing if caching is inactive.

data SpeculateResult

Constructors

SpeculateAbort

SpeculateCommit

resetState :: TCM ()

Resets the non-persistent part of the type checking state.

resetAllState :: TCM ()

Resets all of the type checking state.

Keep only Benchmark and backend information.

localTCState :: TCM a -> TCM a

Restore TCState after performing subcomputation.

In contrast to localState, the Benchmark info from the subcomputation is saved.

localTCStateSaving :: TCM a -> TCM (a, TCState)

Same as localTCState but also returns the state in which we were just before reverting it.

localTCStateSavingWarnings :: TCM a -> TCM a

Same as localTCState but keep all warnings.

speculateTCState :: TCM (a, SpeculateResult) -> TCM a

Allow rolling back the state changes of a TCM computation.

speculateTCState_ :: TCM SpeculateResult -> TCM ()

freshTCM :: TCM a -> TCM (Either TCErr a)

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

updatePersistentState :: (PersistentTCState -> PersistentTCState) -> TCState -> TCState

modifyPersistentState :: (PersistentTCState -> PersistentTCState) -> TCM ()

lensAccumStatisticsP :: Lens' Statistics PersistentTCState

Lens for stAccumStatistics.

lensAccumStatistics :: Lens' Statistics TCState

getScope :: ReadTCState m => m ScopeInfo

Get the current scope.

setScope :: ScopeInfo -> TCM ()

Set the current scope.

modifyScope_ :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m ()

Modify the current scope without updating the inverse maps.

modifyScope :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m ()

Modify the current scope.

useScope :: ReadTCState m => Lens' a ScopeInfo -> m a

Get a part of the current scope.

locallyScope :: ReadTCState m => Lens' a ScopeInfo -> (a -> a) -> m b -> m b

Run a computation in a modified scope.

withScope :: ReadTCState m => ScopeInfo -> m a -> m (a, ScopeInfo)

Run a computation in a local scope.

withScope_ :: ReadTCState m => ScopeInfo -> m a -> m a

Same as withScope, but discard the scope from the computation.

localScope :: TCM a -> TCM a

Discard any changes to the scope by a computation.

notInScopeError :: QName -> TCM a

Scope error.

notInScopeWarning :: QName -> TCM ()

printScope :: String -> Int -> String -> TCM ()

Debug print the scope.

modifySignature :: (Signature -> Signature) -> TCM ()

modifyImportedSignature :: (Signature -> Signature) -> TCM ()

getSignature :: ReadTCState m => m Signature

modifyGlobalDefinition :: QName -> (Definition -> Definition) -> TCM ()

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 :: Signature -> TCM ()

withSignature :: Signature -> TCM a -> TCM a

Run some computation in a different signature, restore original signature.

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

Set the top-level module. This affects the global module id of freshly generated names.

withTopLevelModule :: QName -> TCM a -> TCM a

Use a different top-level module for a computation. Used when generating names for imported modules.

addForeignCode :: BackendName -> String -> TCM ()

getInteractionOutputCallback :: TCM InteractionOutputCallback

appInteractionOutputCallback :: Response -> TCM ()

setInteractionOutputCallback :: InteractionOutputCallback -> TCM ()

getPatternSyns :: ReadTCState m => m PatternSynDefns

setPatternSyns :: PatternSynDefns -> TCM ()

modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM ()

Lens for stPatternSyns.

getPatternSynImports :: ReadTCState m => m PatternSynDefns

getAllPatternSyns :: ReadTCState m => m PatternSynDefns

Get both local and imported pattern synonyms

lookupPatternSyn :: AmbiguousQName -> TCM PatternSynDefn

lookupSinglePatternSyn :: QName -> TCM PatternSynDefn

theBenchmark :: TCState -> Benchmark

Lens getter for Benchmark from TCState.

updateBenchmark :: (Benchmark -> Benchmark) -> TCState -> TCState

Lens map for Benchmark.

modifyBenchmark :: (Benchmark -> Benchmark) -> TCM ()

Lens modify for Benchmark.

addImportedInstances :: Signature -> TCM ()

Look through the signature and reconstruct the instance table.

updateInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCState -> TCState

Lens for stInstanceDefs.

modifyInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCM ()

getAllInstanceDefs :: TCM TempInstanceTable

getAnonInstanceDefs :: TCM (Set QName)

clearAnonInstanceDefs :: TCM ()

Remove all instances whose type is still unresolved.

addUnknownInstance :: QName -> TCM ()

Add an instance whose type is still unresolved.

addNamedInstance

Arguments

:: QName

Name of the instance.

-> QName

Name of the class.

-> TCM ()

Add instance to some `class'.

interestingCall :: Call -> Bool

traceCallM :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => tcm Call -> tcm a -> tcm a

traceCallCPS :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => Call -> ((a -> tcm b) -> tcm b) -> (a -> tcm b) -> tcm b

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.

traceCall :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => Call -> tcm a -> tcm a

Record a function call in the trace.

traceClosureCall :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => Closure Call -> tcm a -> tcm a

getCurrentRange :: MonadTCEnv m => m Range

setCurrentRange :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm, HasRange x) => x -> tcm a -> tcm a

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

Arguments

:: (MonadTCM tcm, ReadTCState tcm)

=> Range

rPre

-> Range

r

-> tcm a

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

printHighlightingInfo :: (MonadTCM tcm, ReadTCState tcm) => RemoveTokenBasedHighlighting -> HighlightingInfo -> tcm ()

Lispify and print the given highlighting information.

noMutualBlock :: TCM a -> TCM a

inMutualBlock :: (MutualId -> TCM a) -> TCM a

Pass the current mutual block id or create a new mutual block if we are not already inside on.

setMutualBlockInfo :: MutualId -> MutualInfo -> TCM ()

Set the mutual block info for a block, possibly overwriting the existing one.

insertMutualBlockInfo :: MutualId -> MutualInfo -> TCM ()

Set the mutual block info for a block if non-existing.

setMutualBlock :: MutualId -> QName -> TCM ()

Set the mutual block for a definition.

currentOrFreshMutualBlock :: TCM MutualId

Get the current mutual block, if any, otherwise a fresh mutual block is returned.

lookupMutualBlock :: MutualId -> TCM MutualBlock

mutualBlockOf :: QName -> TCM MutualId

Reverse lookup of a mutual block id for a names.

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, HasOptions m, MonadDebug m) => MonadConstraint m where

Monad service class containing methods for adding and solving constraints

Methods

addConstraint :: Constraint -> m ()

Unconditionally add the constraint.

addAwakeConstraint :: Constraint -> m ()

Add constraint as awake constraint.

catchPatternErr :: m a -> m a -> m a

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

solveConstraint :: Constraint -> m ()

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> m ()

Solve awake constraints matching the predicate. If the second argument is True solve constraints even if already isSolvingConstraints.

wakeConstraints :: (ProblemConstraint -> m Bool) -> m ()

stealConstraints :: ProblemId -> m ()

modifyAwakeConstraints :: (Constraints -> Constraints) -> m ()

modifySleepingConstraints :: (Constraints -> Constraints) -> m ()

Instances

MonadConstraint TCM

Defined in Agda.TypeChecking.Constraints

Methods

addConstraint :: Constraint -> TCM ()

addAwakeConstraint :: Constraint -> TCM ()

catchPatternErr :: TCM a -> TCM a -> TCM a

solveConstraint :: Constraint -> TCM ()

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

wakeConstraints :: (ProblemConstraint -> TCM Bool) -> TCM ()

stealConstraints :: ProblemId -> TCM ()

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

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

(MonadTCEnv m, ReadTCState m, HasOptions m, MonadDebug m) => MonadConstraint (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

addConstraint :: Constraint -> PureConversionT m ()

addAwakeConstraint :: Constraint -> PureConversionT m ()

catchPatternErr :: PureConversionT m a -> PureConversionT m a -> PureConversionT m a

solveConstraint :: Constraint -> PureConversionT m ()

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> PureConversionT m ()

wakeConstraints :: (ProblemConstraint -> PureConversionT m Bool) -> PureConversionT m ()

stealConstraints :: ProblemId -> PureConversionT m ()

modifyAwakeConstraints :: (Constraints -> Constraints) -> PureConversionT m ()

modifySleepingConstraints :: (Constraints -> Constraints) -> PureConversionT m ()

data ConstraintStatus

Constructors

AwakeConstraint

SleepingConstraint

Instances

Eq ConstraintStatus

Defined in Agda.TypeChecking.Monad.Constraints

Methods

(==) :: ConstraintStatus -> ConstraintStatus -> Bool

(/=) :: ConstraintStatus -> ConstraintStatus -> Bool

Show ConstraintStatus

Defined in Agda.TypeChecking.Monad.Constraints

Methods

showsPrec :: Int -> ConstraintStatus -> ShowS

show :: ConstraintStatus -> String

showList :: [ConstraintStatus] -> ShowS

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

Get the awake constraints

dropConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m ()

takeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m Constraints

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

putAllConstraintsToSleep :: MonadConstraint m => m ()

holdConstraints :: (ConstraintStatus -> ProblemConstraint -> Bool) -> TCM a -> TCM a

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)

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 -> Constraint -> m ProblemConstraint

buildProblemConstraint_ :: (MonadTCEnv m, ReadTCState m) => Constraint -> m ProblemConstraint

buildConstraint :: Constraint -> TCM ProblemConstraint

addConstraint' :: Constraint -> TCM ()

Add new a constraint

addAwakeConstraint' :: Constraint -> TCM ()

addConstraintTo :: Lens' Constraints TCState -> Constraint -> TCM ()

nowSolvingConstraints :: MonadTCEnv m => m a -> m a

Start solving constraints

isSolvingConstraints :: MonadTCEnv m => m Bool

catchConstraint :: MonadConstraint m => Constraint -> m () -> m ()

Add constraint if the action raises a pattern violation

mapAwakeConstraints :: (Constraints -> Constraints) -> TCState -> TCState

mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState

setPragmaOptions :: PragmaOptions -> TCM ()

Sets the pragma options.

setCommandLineOptions :: CommandLineOptions -> TCM ()

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'

Arguments

:: AbsolutePath

The base directory of relative paths.

-> CommandLineOptions

-> TCM ()

libToTCM :: LibM a -> TCM a

setLibraryPaths

Arguments

:: AbsolutePath

The base directory of relative paths.

-> CommandLineOptions

-> TCM CommandLineOptions

setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions

addDefaultLibraries

Arguments

:: AbsolutePath

The base directory of relative paths.

-> CommandLineOptions

-> TCM CommandLineOptions

setOptionsFromPragma :: OptionsPragma -> TCM ()

enableDisplayForms :: MonadTCEnv m => m a -> m a

Disable display forms.

disableDisplayForms :: MonadTCEnv m => m a -> m a

Disable display forms.

displayFormsEnabled :: MonadTCEnv m => m Bool

Check if display forms are enabled.

setIncludeDirs

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

An empty list is interpreted as ["."].

setInputFile :: FilePath -> TCM ()

getInputFile :: TCM AbsolutePath

Should only be run if hasInputFile.

getInputFile' :: TCM (Maybe AbsolutePath)

Return the optInputFile as AbsolutePath, if any.

hasInputFile :: HasOptions m => m Bool

isPropEnabled :: HasOptions m => m Bool

hasUniversePolymorphism :: HasOptions m => m Bool

showImplicitArguments :: HasOptions m => m Bool

showIrrelevantArguments :: HasOptions m => m Bool

withShowAllArguments :: ReadTCState m => m a -> m a

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

withPragmaOptions :: ReadTCState m => (PragmaOptions -> PragmaOptions) -> m a -> m a

Change PragmaOptions for a computation and restore afterwards.

ignoreInterfaces :: HasOptions m => m Bool

ignoreAllInterfaces :: HasOptions m => m Bool

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

makeOpen :: MonadTCEnv m => a -> m (Open a)

Create an open term in the current context.

getOpen :: (Subst Term a, MonadTCEnv m) => Open a -> m a

Extract the value from an open term. The checkpoint at which it was created must be in scope.

tryGetOpen :: (Subst Term a, MonadTCEnv m) => Open a -> m (Maybe a)

Extract the value from an open term. Returns Nothing if the checkpoint at which it was created is not in scope.

isClosed :: Open a -> Bool

An Open is closed if it has checkpoint 0.

newtype KeepNames a

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

AddContext (KeepNames Telescope)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => KeepNames Telescope -> m a -> m a

contextSize :: KeepNames Telescope -> Nat

AddContext (KeepNames String, Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => (KeepNames String, Dom Type) -> m a -> m a

contextSize :: (KeepNames String, Dom Type) -> Nat

class AddContext b where

Various specializations of addCtx.

Methods

addContext :: MonadAddContext m => b -> m a -> m a

contextSize :: b -> Nat

Instances

AddContext String

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => String -> m a -> m a

contextSize :: String -> Nat

AddContext Name

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => Name -> m a -> m a

contextSize :: Name -> Nat

AddContext Telescope

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => Telescope -> m a -> m a

contextSize :: Telescope -> Nat

AddContext a => AddContext [a]

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => [a] -> m a0 -> m a0

contextSize :: [a] -> Nat

AddContext (Dom (String, Type))

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => Dom (String, Type) -> m a -> m a

contextSize :: Dom (String, Type) -> Nat

AddContext (Dom (Name, Type))

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => Dom (Name, Type) -> m a -> m a

contextSize :: Dom (Name, Type) -> Nat

AddContext (Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => Dom Type -> m a -> m a

contextSize :: Dom Type -> Nat

AddContext (KeepNames Telescope)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => KeepNames Telescope -> m a -> m a

contextSize :: KeepNames Telescope -> Nat

AddContext ([NamedArg Name], Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => ([NamedArg Name], Type) -> m a -> m a

contextSize :: ([NamedArg Name], Type) -> Nat

AddContext ([Arg Name], Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => ([Arg Name], Type) -> m a -> m a

contextSize :: ([Arg Name], Type) -> Nat

AddContext ([WithHiding Name], Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => ([WithHiding Name], Dom Type) -> m a -> m a

contextSize :: ([WithHiding Name], Dom Type) -> Nat

AddContext ([Name], Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => ([Name], Dom Type) -> m a -> m a

contextSize :: ([Name], Dom Type) -> Nat

AddContext (String, Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => (String, Dom Type) -> m a -> m a

contextSize :: (String, Dom Type) -> Nat

AddContext (Name, Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => (Name, Dom Type) -> m a -> m a

contextSize :: (Name, Dom Type) -> Nat

AddContext (KeepNames String, Dom Type)

Defined in Agda.TypeChecking.Monad.Context

Methods

addContext :: MonadAddContext m => (KeepNames String, Dom Type) -> m a -> m a

contextSize :: (KeepNames String, Dom Type) -> Nat

unsafeModifyContext :: MonadTCEnv tcm => (Context -> Context) -> tcm a -> tcm a

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

Modify the Dom part of context entries.

inTopContext :: (MonadTCEnv tcm, ReadTCState tcm) => tcm a -> tcm a

Change to top (=empty) context. Resets the checkpoints.

unsafeInTopContext :: (MonadTCEnv m, ReadTCState m) => m a -> m a

Change to top (=empty) context, but don't update the checkpoints. Totally not safe!

unsafeEscapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a

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 => Empty -> Int -> m a -> m a

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

Add a new checkpoint. Do not use directly!

checkpointSubstitution' :: MonadTCEnv tcm => CheckpointId -> tcm (Maybe Substitution)

Get the substitution from the context at a given checkpoint to the current context.

getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m (Maybe Substitution)

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

Default implementation of addCtx in terms of updateContext

withFreshName_ :: MonadAddContext m => ArgName -> (Name -> m a) -> m a

withShadowingNameTCM :: Name -> TCM b -> TCM b

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

underAbstraction :: (Subst t a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b

Go under an abstraction. Do not extend context in case of NoAbs.

underAbstraction' :: (Subst t a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b

underAbstractionAbs :: (Subst t a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b

Go under an abstraction, treating NoAbs as Abs.

underAbstractionAbs' :: (Subst t a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b

underAbstraction_ :: (Subst t a, MonadAddContext m) => Abs a -> (a -> m b) -> m b

Go under an abstract without worrying about the type to add to the context.

mapAbstraction :: (Subst t a, Subst t' b, Free b, MonadAddContext m) => Dom Type -> (a -> m b) -> Abs a -> m (Abs b)

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

defaultAddLetBinding' :: MonadTCEnv m => Name -> Term -> Dom Type -> m a -> m a

Add a let bound variable

addLetBinding :: MonadAddContext m => ArgInfo -> Name -> Term -> Type -> m a -> m a

Add a let bound variable

getContext :: MonadTCEnv m => m [Dom (Name, Type)]

Get the current context.

getContextSize :: (Applicative m, MonadTCEnv m) => m Nat

Get the size of the current context.

getContextArgs :: (Applicative m, MonadTCEnv m) => m Args

Generate [var (n - 1), ..., var 0] for all declarations in the context.

getContextTerms :: (Applicative m, MonadTCEnv m) => m [Term]

Generate [var (n - 1), ..., var 0] for all declarations in the context.

getContextTelescope :: (Applicative m, MonadTCEnv m) => m Telescope

Get the current context as a Telescope.

getContextNames :: (Applicative m, MonadTCEnv m) => m [Name]

Get the names of all declarations in the context.

lookupBV' :: MonadTCEnv m => Nat -> m (Maybe (Dom (Name, Type)))

get type of bound variable (i.e. deBruijn index)

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)

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 CoinductionKit

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

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

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, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => Term -> m Term

Rewrite a literal to constructor form if possible.

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

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

primSetOmega :: (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

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

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

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

primAgdaTCMDebugPrint :: (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

coinductionKit' :: TCM CoinductionKit

Tries to build a CoinductionKit.

coinductionKit :: TCM (Maybe CoinductionKit)

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

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)

idViewAsPath :: HasBuiltins m => Type -> m PathView

Non dependent Path

boldPathView :: Type -> PathView

pathUnview :: PathView -> Type

Revert the PathView.

Postcondition: type is reduced.

primEqualityName :: TCM QName

Get the name of the equality type.

equalityView :: Type -> TCM EqualityView

Check whether the type is actually an equality (lhs ≡ rhs) and extract lhs, rhs, and their type.

Precondition: type is reduced.

equalityUnview :: EqualityView -> Type

Revert the EqualityView.

Postcondition: type is reduced.

constrainedPrims :: [String]

Primitives with typechecking constrants.

getNameOfConstrained :: HasBuiltins m => String -> m (Maybe QName)

type SizeMaxView' = [DeepSizeView]

type SizeMaxView = NonEmpty DeepSizeView

data SizeViewComparable a

Constructors

NotComparable

YesAbove DeepSizeView a

YesBelow DeepSizeView a

Instances

Functor SizeViewComparable

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

fmap :: (a -> b) -> SizeViewComparable a -> SizeViewComparable b

(<$) :: a -> SizeViewComparable b -> SizeViewComparable a

data DeepSizeView

A deep view on sizes.

Constructors

DSizeInf

DSizeVar Nat Offset

DSizeMeta MetaId Elims Offset

DOtherSize Term

Instances

Show DeepSizeView

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

showsPrec :: Int -> DeepSizeView -> ShowS

show :: DeepSizeView -> String

showList :: [DeepSizeView] -> ShowS

Pretty DeepSizeView

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

pretty :: DeepSizeView -> Doc

prettyPrec :: Int -> DeepSizeView -> Doc

prettyList :: [DeepSizeView] -> Doc

type Offset = Nat

data SizeView

A useful view on sizes.

Constructors

SizeInf

SizeSuc Term

OtherSize Term

class IsSizeType a where

Check if a type is the primSize type. The argument should be reduced.

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => a -> m (Maybe BoundedSize)

Instances

IsSizeType Term

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => Term -> m (Maybe BoundedSize)

IsSizeType CompareAs

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => CompareAs -> m (Maybe BoundedSize)

IsSizeType a => IsSizeType (Type' a)

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => Type' a -> m (Maybe BoundedSize)

IsSizeType a => IsSizeType (Dom a)

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => Dom a -> m (Maybe BoundedSize)

IsSizeType a => IsSizeType (b, a)

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => (b, a) -> m (Maybe BoundedSize)

data BoundedSize

Result of querying whether size variable i is bounded by another size.

Constructors

BoundedLt Term

yes i : Size< t

BoundedNo

Instances

Eq BoundedSize

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

(==) :: BoundedSize -> BoundedSize -> Bool

(/=) :: BoundedSize -> BoundedSize -> Bool

Show BoundedSize

Defined in Agda.TypeChecking.Monad.SizedTypes

Methods

showsPrec :: Int -> BoundedSize -> ShowS

show :: BoundedSize -> String

showList :: [BoundedSize] -> ShowS

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

Test whether OPTIONS --sized-types and whether the size built-ins are defined.

haveSizeLt :: TCM Bool

Test whether the SIZELT builtin is defined.

builtinSizeHook :: String -> QName -> Type -> TCM ()

Add polarity info to a SIZE builtin.

sizeSort :: Sort

The sort of built-in types SIZE and SIZELT.

sizeUniv :: Type

The type of built-in types SIZE and SIZELT.

sizeType_ :: QName -> Type

The built-in type SIZE with user-given name.

sizeType :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => m Type

The built-in type SIZE.

sizeSucName :: (HasBuiltins m, HasOptions m) => m (Maybe QName)

The name of SIZESUC.

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

Transform list of terms into a term build from binary maximum.

sizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => Term -> m SizeView

Expects argument to be reduced.

sizeViewComparable :: DeepSizeView -> DeepSizeView -> SizeViewComparable ()

sizeViewComparable v w checks whether v >= w (then Left) or v <= w (then Right). If uncomparable, it returns NotComparable.

sizeViewSuc_ :: QName -> DeepSizeView -> DeepSizeView

sizeViewPred :: Nat -> DeepSizeView -> DeepSizeView

sizeViewPred k v decrements v by k (must be possible!).

sizeViewOffset :: DeepSizeView -> Maybe Offset

sizeViewOffset v returns the number of successors or Nothing when infty.

removeSucs :: (DeepSizeView, DeepSizeView) -> (DeepSizeView, DeepSizeView)

Remove successors common to both sides.

unSizeView :: SizeView -> TCM Term

Turn a size view into a term.

unDeepSizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => DeepSizeView -> m Term

maxViewMax :: SizeMaxView -> SizeMaxView -> SizeMaxView

maxViewCons :: DeepSizeView -> SizeMaxView -> SizeMaxView

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'

sizeViewComparableWithMax v ws tries to find w in ws that compares with v and singles this out. Precondition: v /= DSizeInv.

maxViewSuc_ :: QName -> SizeMaxView -> SizeMaxView

unMaxView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => SizeMaxView -> m Term

addConstant :: QName -> Definition -> TCM ()

Add a constant to the signature. Lifts the definition to top level.

setTerminates :: QName -> Bool -> TCM ()

Set termination info of a defined function symbol.

setCompiledClauses :: QName -> CompiledClauses -> TCM ()

Set CompiledClauses of a defined function symbol.

setSplitTree :: QName -> SplitTree -> TCM ()

Set SplitTree of a defined function symbol.

modifyFunClauses :: QName -> ([Clause] -> [Clause]) -> TCM ()

Modify the clauses of a function.

addClauses :: QName -> [Clause] -> TCM ()

Lifts clauses to the top-level and adds them to definition. Also adjusts the funCopatternLHS field if necessary.

mkPragma :: String -> TCM CompilerPragma

addPragma :: BackendName -> QName -> String -> TCM ()

Add a compiler pragma `{-# COMPILE backend name text #-}`

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

Add a section to the signature.

The current context will be stored as the cumulative module parameters for this section.

setModuleCheckpoint :: ModuleName -> TCM ()

Sets the checkpoint for the given module to the current checkpoint.

getSection :: (Functor m, ReadTCState m) => ModuleName -> m (Maybe Section)

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

applySection

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

addDisplayForm :: QName -> DisplayForm -> TCM ()

Add a display form to a definition (could be in this or imported signature).

isLocal :: ReadTCState m => QName -> m Bool

getDisplayForms :: (HasConstInfo m, ReadTCState m) => QName -> m [LocalDisplayForm]

chaseDisplayForms :: QName -> TCM (Set QName)

Find all names used (recursively) by display forms of a given name.

hasLoopingDisplayForm :: QName -> TCM Bool

Check if a display form is looping.

canonicalName :: HasConstInfo m => QName -> m QName

sameDef :: HasConstInfo m => QName -> QName -> m (Maybe QName)

whatInduction :: MonadTCM tcm => QName -> tcm Induction

Can be called on either a (co)datatype, a record type or a (co)constructor.

singleConstructorType :: QName -> TCM Bool

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

Standard eliminator for SigError.

defaultGetRewriteRulesFor :: Monad m => m TCState -> QName -> m RewriteRules

getOriginalProjection :: HasConstInfo m => QName -> m QName

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)

getConInfo :: HasConstInfo m => ConHead -> m Definition

getPolarity :: HasConstInfo m => QName -> m [Polarity]

Look up the polarity of a definition.

getPolarity' :: HasConstInfo m => Comparison -> QName -> m [Polarity]

Look up polarity of a definition and compose with polarity represented by Comparison.

setPolarity :: QName -> [Polarity] -> TCM ()

Set the polarity of a definition.

getForcedArgs :: HasConstInfo m => QName -> m [IsForced]

Look up the forced arguments of a definition.

getArgOccurrence :: QName -> Nat -> TCM Occurrence

Get argument occurrence info for argument i of definition d (never fails).

setArgOccurrences :: QName -> [Occurrence] -> TCM ()

Sets the defArgOccurrences for the given identifier (which should already exist in the signature).

modifyArgOccurrences :: QName -> ([Occurrence] -> [Occurrence]) -> TCM ()

setTreeless :: QName -> TTerm -> TCM ()

setCompiledArgUse :: QName -> [Bool] -> TCM ()

getCompiled :: QName -> TCM (Maybe Compiled)

getErasedConArgs :: QName -> TCM [Bool]

Returns a list of length conArity. If no erasure analysis has been performed yet, this will be a list of Falses.

setErasedConArgs :: QName -> [Bool] -> TCM ()

getTreeless :: QName -> TCM (Maybe TTerm)

getCompiledArgUse :: QName -> TCM [Bool]

addDataCons :: QName -> [QName] -> TCM ()

add data constructors to a datatype

getMutual :: QName -> TCM (Maybe [QName])

Get the mutually recursive identifiers of a symbol from the signature.

getMutual_ :: Defn -> Maybe [QName]

Get the mutually recursive identifiers from a Definition.

setMutual :: QName -> [QName] -> TCM ()

Set the mutually recursive identifiers.

mutuallyRecursive :: QName -> QName -> TCM Bool

Check whether two definitions are mutually recursive.

definitelyNonRecursive_ :: Defn -> Bool

A functiondatarecord definition is nonRecursive if it is not even mutually recursive with itself.

getCurrentModuleFreeVars :: TCM Nat

Get the number of parameters to the current module.

getDefModule :: HasConstInfo m => QName -> m (Either SigError ModuleName)

getDefFreeVars :: (Functor m, Applicative m, ReadTCState m, MonadTCEnv m) => QName -> m Nat

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

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

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

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

instantiateRewriteRules :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRules -> m RewriteRules

makeAbstract :: Definition -> Maybe Definition

Give the abstract view of a definition.

inAbstractMode :: MonadTCEnv m => m a -> m a

Enter abstract mode. Abstract definition in the current module are transparent.

inConcreteMode :: MonadTCEnv m => m a -> m a

Not in abstract mode. All abstract definitions are opaque.

ignoreAbstractMode :: MonadTCEnv m => m a -> m a

Ignore abstract mode. All abstract definitions are transparent.

inConcreteOrAbstractMode :: (MonadTCEnv m, HasConstInfo m) => QName -> (Definition -> m a) -> m a

Enter concrete or abstract mode depending on whether the given identifier is concrete or abstract.

treatAbstractly :: MonadTCEnv m => QName -> m Bool

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

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

Get type of a constant, instantiated to the current context.

relOfConst :: HasConstInfo m => QName -> m Relevance

Get relevance of a constant.

modalityOfConst :: HasConstInfo m => QName -> m Modality

Get modality of a constant.

droppedPars :: Definition -> Int

The number of dropped parameters for a definition. 0 except for projection(-like) functions and constructors.

isProjection :: HasConstInfo m => QName -> m (Maybe Projection)

Is it the name of a record projection?

isProjection_ :: Defn -> Maybe Projection

isStaticFun :: Defn -> Bool

Is it a function marked STATIC?

isInlineFun :: Defn -> Bool

Is it a function marked INLINE?

isProperProjection :: Defn -> Bool

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 :: Defn -> Int

Number of dropped initial arguments of a projection(-like) function.

usesCopatterns :: HasConstInfo m => QName -> m Bool

Check whether a definition uses copatterns.

applyDef :: HasConstInfo m => ProjOrigin -> QName -> Arg Term -> m Term

Apply a function f to its first argument, producing the proper postfix projection if f is a projection.

class UnFreezeMeta a where

Unfreeze meta and its type if this is a meta again. Does not unfreeze deep occurrences of metas.

Methods

unfreezeMeta :: MonadMetaSolver m => a -> m ()

Instances

UnFreezeMeta MetaId

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => MetaId -> m ()

UnFreezeMeta LevelAtom

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => LevelAtom -> m ()

UnFreezeMeta PlusLevel

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => PlusLevel -> m ()

UnFreezeMeta Level

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => Level -> m ()

UnFreezeMeta Sort

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => Sort -> m ()

UnFreezeMeta Type

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => Type -> m ()

UnFreezeMeta Term

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => Term -> m ()

UnFreezeMeta a => UnFreezeMeta [a]

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => [a] -> m ()

UnFreezeMeta a => UnFreezeMeta (Abs a)

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

unfreezeMeta :: MonadMetaSolver m => Abs a -> m ()

class IsInstantiatedMeta a where

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

Instances

IsInstantiatedMeta MetaId

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => MetaId -> m Bool

IsInstantiatedMeta LevelAtom

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => LevelAtom -> m Bool

IsInstantiatedMeta PlusLevel

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => PlusLevel -> m Bool

IsInstantiatedMeta Level

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Level -> m Bool

IsInstantiatedMeta Term

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Term -> m Bool

IsInstantiatedMeta a => IsInstantiatedMeta [a]

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => [a] -> m Bool

IsInstantiatedMeta a => IsInstantiatedMeta (Maybe a)

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Maybe a -> m Bool

IsInstantiatedMeta a => IsInstantiatedMeta (Arg a)

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Arg a -> m Bool

IsInstantiatedMeta a => IsInstantiatedMeta (Abs a)

Does not worry about raising.

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Abs a -> m Bool

class (MonadConstraint m, MonadReduce m, MonadAddContext m, MonadTCEnv m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) => MonadMetaSolver m where

Monad service class for creating, solving and eta-expanding of metavariables.

Methods

newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId

Generate a new meta variable with some instantiation given. For instance, the instantiation could be a PostponedTypeCheckingProblem.

assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> m ()

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

Directly instantiate the metavariable. Skip pattern check, occurs check and frozen check. Used for eta expanding frozen metas.

etaExpandMeta :: [MetaKind] -> MetaId -> m ()

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

Update the status of the metavariable

speculateMetas :: m () -> m KeepMetas -> m ()

'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

MonadMetaSolver TCM

Defined in Agda.TypeChecking.MetaVars

Methods

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

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

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

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

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

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

(MonadTCEnv m, MonadReduce m, MonadAddContext m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) => MonadMetaSolver (PureConversionT m)

Defined in Agda.TypeChecking.Conversion.Pure

Methods

newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> PureConversionT m MetaId

assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> PureConversionT m ()

assignTerm' :: MetaId -> [Arg ArgName] -> Term -> PureConversionT m ()

etaExpandMeta :: [MetaKind] -> MetaId -> PureConversionT m ()

updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> PureConversionT m ()

speculateMetas :: PureConversionT m () -> PureConversionT m KeepMetas -> PureConversionT m ()

data KeepMetas

Constructors

KeepMetas

RollBackMetas

data MetaKind

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

Bounded MetaKind

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

minBound :: MetaKind

maxBound :: MetaKind

Enum MetaKind

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

succ :: MetaKind -> MetaKind

pred :: MetaKind -> MetaKind

toEnum :: Int -> MetaKind

fromEnum :: MetaKind -> Int

enumFrom :: MetaKind -> [MetaKind]

enumFromThen :: MetaKind -> MetaKind -> [MetaKind]

enumFromTo :: MetaKind -> MetaKind -> [MetaKind]

enumFromThenTo :: MetaKind -> MetaKind -> MetaKind -> [MetaKind]

Eq MetaKind

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

(==) :: MetaKind -> MetaKind -> Bool

(/=) :: MetaKind -> MetaKind -> Bool

Show MetaKind

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

showsPrec :: Int -> MetaKind -> ShowS

show :: MetaKind -> String

showList :: [MetaKind] -> ShowS

allMetaKinds :: [MetaKind]

All possible metavariable kinds.

dontAssignMetas :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a

Switch off assignment of metas.

getMetaStore :: ReadTCState m => m MetaStore

Get the meta store.

modifyMetaStore :: (MetaStore -> MetaStore) -> TCM ()

metasCreatedBy :: ReadTCState m => m a -> m (a, IntSet)

Run a computation and record which new metas it created.

lookupMeta' :: ReadTCState m => MetaId -> m (Maybe MetaVariable)

Lookup a meta variable.

lookupMeta :: (MonadFail m, ReadTCState m) => MetaId -> m MetaVariable

metaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type

Type of a term or sort meta.

updateMetaVarTCM :: MetaId -> (MetaVariable -> MetaVariable) -> TCM ()

Update the information associated with a meta variable.

insertMetaVar :: MetaId -> MetaVariable -> TCM ()

Insert a new meta variable with associated information into the meta store.

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

Compute the context variables that a meta should be applied to, accounting for pruning.

getMetaTypeInContext :: (MonadFail m, MonadTCEnv m, ReadTCState m, MonadReduce m) => MetaId -> m Type

Given a meta, return the type applied to the current context.

isGeneralizableMeta :: (ReadTCState m, MonadFail m) => MetaId -> m DoGeneralize

Is it a meta that might be generalized?

isInstantiatedMeta' :: (MonadFail m, ReadTCState m) => MetaId -> m (Maybe Term)

constraintMetas :: Constraint -> TCM (Set MetaId)

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.

createMetaInfo :: (MonadTCEnv m, ReadTCState m) => m MetaInfo

Create MetaInfo in the current environment.

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

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

Register an interaction point during scope checking. If there is no interaction id yet, create one.

findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId

Find an interaction point by Range by searching the whole map.

O(n): linear in the number of registered interaction points.

connectInteractionPoint :: MonadInteractionPoints m => InteractionId -> MetaId -> m ()

Hook up meta variable to interaction point.

removeInteractionPoint :: MonadInteractionPoints m => InteractionId -> m ()

Mark an interaction point as solved.

getInteractionPoints :: ReadTCState m => m [InteractionId]

Get a list of interaction ids.

getInteractionMetas :: ReadTCState m => m [MetaId]

Get all metas that correspond to unsolved interaction ids.

getInteractionIdsAndMetas :: ReadTCState m => m [(InteractionId, MetaId)]

Get all metas that correspond to unsolved interaction ids.

isInteractionMeta :: ReadTCState m => MetaId -> m (Maybe InteractionId)

Does the meta variable correspond to an interaction point?

Time: O(n) where n is the number of interaction metas.

lookupInteractionPoint :: (MonadFail m, ReadTCState m, MonadError TCErr m) => InteractionId -> m InteractionPoint

Get the information associated to an interaction point.

lookupInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m MetaId

Get MetaId for an interaction point. Precondition: interaction point is connected.

lookupInteractionMeta :: ReadTCState m => InteractionId -> m (Maybe MetaId)

Check whether an interaction id is already associated with a meta variable.

lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId

newMeta :: MonadMetaSolver m => Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId

Generate new meta variable.

newMetaTCM' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId

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

Get the Range for an interaction point.

getMetaRange :: (MonadFail m, ReadTCState m) => MetaId -> m Range

Get the Range for a meta variable.

getInteractionScope :: InteractionId -> TCM ScopeInfo

withMetaInfo' :: MetaVariable -> TCM a -> TCM a

withMetaInfo :: Closure Range -> TCM a -> TCM a

getMetaVariableSet :: ReadTCState m => m IntSet

getMetaVariables :: ReadTCState m => (MetaVariable -> Bool) -> m [MetaId]

getInstantiatedMetas :: ReadTCState m => m [MetaId]

getOpenMetas :: ReadTCState m => m [MetaId]

isOpenMeta :: MetaInstantiation -> Bool

listenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m ()

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

Unregister a listener.

getMetaListeners :: (MonadFail m, ReadTCState m) => MetaId -> m [Listener]

Get the listeners to a meta.

clearMetaListeners :: MonadMetaSolver m => MetaId -> m ()

withFreezeMetas :: TCM a -> TCM a

Freeze all so far unfrozen metas for the duration of the given computation.

freezeMetas :: TCM [MetaId]

Freeze all meta variables and return the list of metas that got frozen.

freezeMetas' :: (MetaId -> Bool) -> TCM [MetaId]

Freeze some meta variables and return the list of metas that got frozen.

unfreezeMetas :: TCM ()

Thaw all meta variables.

unfreezeMetas' :: (MetaId -> Bool) -> TCM ()

Thaw some metas, as indicated by the passed condition.

isFrozen :: (MonadFail m, ReadTCState m) => MetaId -> m Bool

activeBackendMayEraseType :: QName -> TCM Bool

Ask the active backend whether a type may be erased. See issue #3732.

backendInteraction :: [Backend] -> (TCM (Maybe Interface) -> TCM ()) -> TCM (Maybe Interface) -> TCM ()

parseBackendOptions :: [Backend] -> [String] -> CommandLineOptions -> OptM ([Backend], CommandLineOptions)

callBackend :: String -> IsMain -> Interface -> TCM ()

Call the compilerMain function of the given backend.

lookupBackend :: BackendName -> TCM (Maybe Backend)

Look for a backend of the given name.

activeBackend :: TCM (Maybe Backend)

Get the currently active backend (if any).