-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | A dependently typed functional programming language and proof assistant -- -- Agda is a dependently typed functional programming language: It has -- inductive families, which are similar to Haskell's GADTs, but they can -- be indexed by values and not just types. It also has parameterised -- modules, mixfix operators, Unicode characters, and an interactive -- Emacs interface (the type checker can assist in the development of -- your code). -- -- Agda is also a proof assistant: It is an interactive system for -- writing and checking proofs. Agda is based on intuitionistic type -- theory, a foundational system for constructive mathematics developed -- by the Swedish logician Per Martin-Löf. It has many similarities with -- other proof assistants based on dependent types, such as Coq, Idris, -- Lean and NuPRL. -- -- This package includes both a command-line program (agda) and an Emacs -- mode. If you want to use the Emacs mode you can set it up by running -- agda-mode setup (see the README). -- -- Note that the Agda package does not follow the package versioning -- policy, because it is not intended to be used by third-party packages. @package Agda @version 2.6.2.2.20221106 module Agda.Interaction.ExitCode data AgdaError -- | 1 UnknownError :: AgdaError -- | 42 TCMError :: AgdaError -- | 71 OptionError :: AgdaError -- | 113 CommandError :: AgdaError -- | 154 ImpossibleError :: AgdaError -- | Return the error corresponding to an exit code from the Agda process agdaErrorToInt :: AgdaError -> Int agdaErrorFromInt :: Int -> Maybe AgdaError -- | The computation exitSuccess is equivalent to exitWith -- ExitSuccess, It terminates the program successfully. exitSuccess :: IO a exitAgdaWith :: AgdaError -> IO a instance GHC.Enum.Bounded Agda.Interaction.ExitCode.AgdaError instance GHC.Enum.Enum Agda.Interaction.ExitCode.AgdaError instance GHC.Classes.Eq Agda.Interaction.ExitCode.AgdaError instance GHC.Show.Show Agda.Interaction.ExitCode.AgdaError -- | Defines CutOff type which is used in -- Agda.Interaction.Options. This module's purpose is to eliminate -- the dependency of Agda.TypeChecking.Monad.Base on the -- termination checker and everything it imports. module Agda.Termination.CutOff -- | Cut off structural order comparison at some depth in termination -- checker? data CutOff -- | c >= 0 means: record decrease up to including -- c+1. CutOff :: !Int -> CutOff DontCutOff :: CutOff -- | The default termination depth. defaultCutOff :: CutOff instance GHC.Classes.Ord Agda.Termination.CutOff.CutOff instance GHC.Classes.Eq Agda.Termination.CutOff.CutOff instance GHC.Show.Show Agda.Termination.CutOff.CutOff instance Control.DeepSeq.NFData Agda.Termination.CutOff.CutOff -- | Semirings. module Agda.Termination.Semiring -- | HasZero is needed for sparse matrices, to tell which is the -- element that does not have to be stored. It is a cut-down version of -- SemiRing which is definable without the implicit -- ?cutoff. class Eq a => HasZero a zeroElement :: HasZero a => a -- | Semirings. data Semiring a Semiring :: (a -> a -> a) -> (a -> a -> a) -> a -> Semiring a -- | Addition. [add] :: Semiring a -> a -> a -> a -- | Multiplication. [mul] :: Semiring a -> a -> a -> a -- | Zero. The one is never used in matrix multiplication , one :: a -- ^ -- One. [zero] :: Semiring a -> a integerSemiring :: Semiring Integer intSemiring :: Semiring Int -- | The standard semiring on Bools. boolSemiring :: Semiring Bool instance Agda.Termination.Semiring.HasZero GHC.Num.Integer.Integer instance Agda.Termination.Semiring.HasZero GHC.Types.Int -- | Contexts with at most one hole. module Agda.Utils.AffineHole data AffineHole r a -- | A constant term. ZeroHoles :: a -> AffineHole r a -- | A term with one hole and the (old) contents. OneHole :: (r -> a) -> r -> AffineHole r a -- | A term with many holes (error value). ManyHoles :: AffineHole r a instance GHC.Base.Functor (Agda.Utils.AffineHole.AffineHole r) instance GHC.Base.Applicative (Agda.Utils.AffineHole.AffineHole r) module Agda.Utils.Applicative -- | Guard: return the action f only if the boolean is -- True (?*>) :: Alternative f => Bool -> f a -> f a -- | Guard: return the value a only if the boolean is -- True (?$>) :: Alternative f => Bool -> a -> f a -- | Branch over a Foldable collection of values. foldA :: (Alternative f, Foldable t) => t a -> f a -- | Branch over a Foldable collection of values using the supplied -- action. foldMapA :: (Alternative f, Foldable t) => (a -> f b) -> t a -> f b -- | Better name for for. forA :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) -- | Agda strings uses Data.Text [1], which can only represent unicode -- scalar values [2], excluding the surrogate code points 3. To -- allow primStringFromList to be injective we make sure -- character values also exclude surrogate code points, mapping them to -- the replacement character U+FFFD. -- -- See #4999 for more information. -- -- module Agda.Utils.Char -- | The unicode replacement character � . replacementChar :: Char -- | Is a character a surrogate code point. isSurrogateCodePoint :: Char -> Bool -- | Map surrogate code points to the unicode replacement character. replaceSurrogateCodePoint :: Char -> Char -- | Total function to convert an integer to a character. Maps surrogate -- code points to the replacement character U+FFFD. integerToChar :: Integer -> Char -- | Expand environment variables in strings module Agda.Utils.Environment expandEnvironmentVariables :: String -> IO String instance GHC.Show.Show Agda.Utils.Environment.Token instance GHC.Classes.Eq Agda.Utils.Environment.Token -- | A pure MonadFail. module Agda.Utils.Fail newtype Fail a Fail :: Either String a -> Fail a [runFail] :: Fail a -> Either String a runFail_ :: Fail a -> a instance GHC.Base.Monad Agda.Utils.Fail.Fail instance GHC.Base.Applicative Agda.Utils.Fail.Fail instance GHC.Base.Functor Agda.Utils.Fail.Fail instance Control.Monad.Fail.MonadFail Agda.Utils.Fail.Fail module Agda.Utils.Function -- | Repeat a state transition f :: a -> (b, a) with output -- b while condition cond on the output is true. Return -- all intermediate results and the final result where cond is -- False. -- -- Postconditions (when it terminates): fst (last (iterWhile cond f -- a)) == False. all fst (init (interWhile cond f a)). iterWhile :: (b -> Bool) -> (a -> (b, a)) -> a -> [(b, a)] -- | Repeat something while a condition on some state is true. Return the -- last state (including the changes of the last transition, even if the -- condition became false then). repeatWhile :: (a -> (Bool, a)) -> a -> a -- | Monadic version of repeatWhile. repeatWhileM :: Monad m => (a -> m (Bool, a)) -> a -> m a -- | A version of the trampoline function. -- -- The usual function iterates f :: a -> Maybe a as long as -- Just{} is returned, and returns the last value of a -- upon Nothing. -- -- usualTrampoline f = trampolineWhile $ a -> maybe (False,a) -- (True,) (f a). -- -- trampolineWhile is very similar to repeatWhile, only -- that it discards the state on which the condition went False, -- and returns the last state on which the condition was True. trampolineWhile :: (a -> (Bool, a)) -> a -> a -- | Monadic version of trampolineWhile. trampolineWhileM :: Monad m => (a -> m (Bool, a)) -> a -> m a -- | More general trampoline, which allows some final computation from -- iteration state a into result type b. trampoline :: (a -> Either b a) -> a -> b -- | Monadic version of trampoline. trampolineM :: Monad m => (a -> m (Either b a)) -> a -> m b -- | Iteration to fixed-point. -- -- iterateUntil r f a0 iterates endofunction f, -- starting with a0, until r relates its result to its -- input, i.e., f a r a. -- -- This is the generic pattern behind saturation algorithms. -- -- If f is monotone with regard to r, meaning a -- r b implies f a r f b, and -- f-chains starting with a0 are finite then iteration -- is guaranteed to terminate. -- -- A typical instance will work on sets, and r could be set -- inclusion, and a0 the empty set, and f the step -- function of a saturation algorithm. iterateUntil :: (a -> a -> Bool) -> (a -> a) -> a -> a -- | Monadic version of iterateUntil. iterateUntilM :: Monad m => (a -> a -> Bool) -> (a -> m a) -> a -> m a -- | iterate' n f x applies f to x -- n times and returns the result. -- -- The applications are calculated strictly. iterate' :: Integral i => i -> (a -> a) -> a -> a -- | applyWhen b f a applies f to a when -- b. applyWhen :: Bool -> (a -> a) -> a -> a -- | applyUnless b f a applies f to a unless -- b. applyUnless :: Bool -> (a -> a) -> a -> a -- | Monadic version of applyWhen applyWhenM :: Monad m => m Bool -> (m a -> m a) -> m a -> m a -- | Monadic version of applyUnless applyUnlessM :: Monad m => m Bool -> (m a -> m a) -> m a -> m a module Agda.TypeChecking.SizedTypes.Utils debug :: IORef Bool setDebugging :: Bool -> IO () trace :: String -> a -> a traceM :: Applicative f => String -> f () class Eq a => Top a top :: Top a => a isTop :: Top a => a -> Bool class Plus a b c plus :: Plus a b c => a -> b -> c class MeetSemiLattice a meet :: MeetSemiLattice a => a -> a -> a -- | Semiring with idempotent + == dioid class (MeetSemiLattice a, Top a) => Dioid a compose :: Dioid a => a -> a -> a unitCompose :: Dioid a => a instance Agda.TypeChecking.SizedTypes.Utils.Plus GHC.Types.Int GHC.Types.Int GHC.Types.Int -- | Utilities for functors. module Agda.Utils.Functor -- | Composition: pure function after functorial (monadic) function. (<.>) :: Functor m => (b -> c) -> (a -> m b) -> a -> m c infixr 9 <.> -- | The true pure for loop. for is a misnomer, it should -- be forA. for :: Functor m => m a -> (a -> b) -> m b -- | A decoration is a functor that is traversable into any functor. -- -- The Functor superclass is given because of the limitations of -- the Haskell class system. traverseF actually implies -- functoriality. -- -- Minimal complete definition: traverseF or -- distributeF. class Functor t => Decoration t -- | traverseF is the defining property. traverseF :: (Decoration t, Functor m) => (a -> m b) -> t a -> m (t b) -- | Decorations commute into any functor. distributeF :: (Decoration t, Functor m) => t (m a) -> m (t a) -- | Any decoration is traversable with traverse = traverseF. Just -- like any Traversable is a functor, so is any decoration, given -- by just traverseF, a functor. dmap :: Decoration t => (a -> b) -> t a -> t b -- | Any decoration is a lens. set is a special case of -- dmap. dget :: Decoration t => t a -> a -- | An infix synonym for fmap. -- -- The name of this operator is an allusion to $. Note the -- similarities between their types: -- --
--    ($)  ::              (a -> b) ->   a ->   b
--   (<$>) :: Functor f => (a -> b) -> f a -> f b
--   
-- -- Whereas $ is function application, <$> is function -- application lifted over a Functor. -- --

Examples

-- -- Convert from a Maybe Int to a Maybe -- String using show: -- --
--   >>> show <$> Nothing
--   Nothing
--   
--   >>> show <$> Just 3
--   Just "3"
--   
-- -- Convert from an Either Int Int to an -- Either Int String using show: -- --
--   >>> show <$> Left 17
--   Left 17
--   
--   >>> show <$> Right 17
--   Right "17"
--   
-- -- Double each element of a list: -- --
--   >>> (*2) <$> [1,2,3]
--   [2,4,6]
--   
-- -- Apply even to the second element of a pair: -- --
--   >>> even <$> (2,2)
--   (2,True)
--   
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 <$> -- | Flipped version of <$. -- --

Examples

-- -- Replace the contents of a Maybe Int with a -- constant String: -- --
--   >>> Nothing $> "foo"
--   Nothing
--   
--   >>> Just 90210 $> "foo"
--   Just "foo"
--   
-- -- Replace the contents of an Either Int -- Int with a constant String, resulting in an -- Either Int String: -- --
--   >>> Left 8675309 $> "foo"
--   Left 8675309
--   
--   >>> Right 8675309 $> "foo"
--   Right "foo"
--   
-- -- Replace each element of a list with a constant String: -- --
--   >>> [1,2,3] $> "foo"
--   ["foo","foo","foo"]
--   
-- -- Replace the second element of a pair with a constant String: -- --
--   >>> (1,2) $> "foo"
--   (1,"foo")
--   
($>) :: Functor f => f a -> b -> f b infixl 4 $> -- | Infix version of for. (<&>) :: Functor m => m a -> (a -> b) -> m b infixl 1 <&> instance Agda.Utils.Functor.Decoration Data.Functor.Identity.Identity instance (Agda.Utils.Functor.Decoration d, Agda.Utils.Functor.Decoration t) => Agda.Utils.Functor.Decoration (Data.Functor.Compose.Compose d t) instance Agda.Utils.Functor.Decoration ((,) a) -- | Hash tables. module Agda.Utils.HashTable -- | Hash tables. data HashTable k v -- | An empty hash table. empty :: IO (HashTable k v) -- | Inserts the key and the corresponding value into the hash table. insert :: (Eq k, Hashable k) => HashTable k v -> k -> v -> IO () -- | Tries to find a value corresponding to the key in the hash table. lookup :: (Eq k, Hashable k) => HashTable k v -> k -> IO (Maybe v) -- | Converts the hash table to a list. -- -- The order of the elements in the list is unspecified. toList :: (Eq k, Hashable k) => HashTable k v -> IO [(k, v)] -- | ASTs for subset of GHC Haskell syntax. module Agda.Utils.Haskell.Syntax data Module Module :: ModuleName -> [ModulePragma] -> [ImportDecl] -> [Decl] -> Module data ModulePragma LanguagePragma :: [Name] -> ModulePragma -- | Unstructured pragma (Andreas, 2017-08-23, issue #2712). OtherPragma :: String -> ModulePragma data ImportDecl ImportDecl :: ModuleName -> Bool -> Maybe (Bool, [ImportSpec]) -> ImportDecl [importModule] :: ImportDecl -> ModuleName [importQualified] :: ImportDecl -> Bool [importSpecs] :: ImportDecl -> Maybe (Bool, [ImportSpec]) data ImportSpec IVar :: Name -> ImportSpec data Decl TypeDecl :: Name -> [TyVarBind] -> Type -> Decl DataDecl :: DataOrNew -> Name -> [TyVarBind] -> [ConDecl] -> [Deriving] -> Decl TypeSig :: [Name] -> Type -> Decl -- | Should not be used when LocalBind could be used. FunBind :: [Match] -> Decl -- | Should only be used in let or where. LocalBind :: Strictness -> Name -> Rhs -> Decl PatSyn :: Pat -> Pat -> Decl FakeDecl :: String -> Decl Comment :: String -> Decl data DataOrNew DataType :: DataOrNew NewType :: DataOrNew data ConDecl ConDecl :: Name -> [(Maybe Strictness, Type)] -> ConDecl data Strictness Lazy :: Strictness Strict :: Strictness type Deriving = (QName, [Type]) data Binds BDecls :: [Decl] -> Binds data Rhs UnGuardedRhs :: Exp -> Rhs GuardedRhss :: [GuardedRhs] -> Rhs data GuardedRhs GuardedRhs :: [Stmt] -> Exp -> GuardedRhs data Match Match :: Name -> [Pat] -> Rhs -> Maybe Binds -> Match data Type TyForall :: [TyVarBind] -> Type -> Type TyFun :: Type -> Type -> Type TyCon :: QName -> Type TyVar :: Name -> Type TyApp :: Type -> Type -> Type FakeType :: String -> Type data Pat PVar :: Name -> Pat PLit :: Literal -> Pat PAsPat :: Name -> Pat -> Pat PWildCard :: Pat PBangPat :: Pat -> Pat PApp :: QName -> [Pat] -> Pat PatTypeSig :: Pat -> Type -> Pat PIrrPat :: Pat -> Pat data Stmt Qualifier :: Exp -> Stmt Generator :: Pat -> Exp -> Stmt data Exp Var :: QName -> Exp Con :: QName -> Exp Lit :: Literal -> Exp InfixApp :: Exp -> QOp -> Exp -> Exp Ann :: Exp -> Type -> Exp App :: Exp -> Exp -> Exp Lambda :: [Pat] -> Exp -> Exp Let :: Binds -> Exp -> Exp If :: Exp -> Exp -> Exp -> Exp Case :: Exp -> [Alt] -> Exp ExpTypeSig :: Exp -> Type -> Exp NegApp :: Exp -> Exp FakeExp :: String -> Exp data Alt Alt :: Pat -> Rhs -> Maybe Binds -> Alt data Literal Int :: Integer -> Literal Frac :: Rational -> Literal Char :: Char -> Literal String :: Text -> Literal data ModuleName ModuleName :: String -> ModuleName data QName Qual :: ModuleName -> Name -> QName UnQual :: Name -> QName data Name Ident :: String -> Name Symbol :: String -> Name data QOp QVarOp :: QName -> QOp data TyVarBind UnkindedVar :: Name -> TyVarBind unit_con :: Exp instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.DataOrNew instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Strictness instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Literal instance GHC.Classes.Ord Agda.Utils.Haskell.Syntax.ModuleName instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.ModuleName instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Name instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.QName instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.QOp instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.TyVarBind instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Type instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Pat instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.ConDecl instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Stmt instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.GuardedRhs instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Binds instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Alt instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Exp instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Rhs instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Match instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Decl -- | Strictification of Haskell code module Agda.Compiler.MAlonzo.Strict -- | The function makeStrict makes every function argument, case and -- generator pattern, and LocalBind binding strict (except for -- those patterns that are marked as irrefutable, and anything in a -- FakeDecl or FakeExp). Note that only the outermost -- patterns are made strict. class MakeStrict a makeStrict :: MakeStrict a => a -> a instance Agda.Compiler.MAlonzo.Strict.MakeStrict a => Agda.Compiler.MAlonzo.Strict.MakeStrict [a] instance Agda.Compiler.MAlonzo.Strict.MakeStrict a => Agda.Compiler.MAlonzo.Strict.MakeStrict (GHC.Maybe.Maybe a) instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Module instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Decl instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Match instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Pat instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Binds instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Rhs instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.GuardedRhs instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Stmt instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Exp instance Agda.Compiler.MAlonzo.Strict.MakeStrict Agda.Utils.Haskell.Syntax.Alt -- | Auxiliary functions for the IO monad. module Agda.Utils.IO -- | Catch IOExceptions. class CatchIO m catchIO :: CatchIO m => m a -> (IOException -> m a) -> m a instance Agda.Utils.IO.CatchIO GHC.Types.IO instance Agda.Utils.IO.CatchIO m => Agda.Utils.IO.CatchIO (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.Utils.IO.CatchIO m => Agda.Utils.IO.CatchIO (Control.Monad.Trans.State.Lazy.StateT s m) -- | Binary IO. module Agda.Utils.IO.Binary -- | Returns a close function for the file together with the contents. readBinaryFile' :: FilePath -> IO (ByteString, IO ()) module Agda.Utils.IO.Directory -- | copyDirContent src dest recursively copies directory -- src onto dest. -- -- First, a to-do list of copy actions is created. Then, the to-do list -- is carried out. -- -- This avoids copying files we have just created again, which can happen -- if src and dest are not disjoint. (See issue #2705.) copyDirContent :: FilePath -> FilePath -> IO () -- | Common syntax highlighting functions for Emacs and JSON module Agda.Utils.IO.TempFile -- | Creates a temporary file, writes some stuff, and returns the filepath writeToTempFile :: String -> IO FilePath -- | Text IO using the UTF8 character encoding. module Agda.Utils.IO.UTF8 -- | A kind of exception that can be thrown by readTextFile and -- readFile. data ReadException -- | Reads a UTF8-encoded text file and converts many character sequences -- which may be interpreted as line or paragraph separators into 'n'. -- -- If the file cannot be decoded, then a ReadException is raised. readTextFile :: FilePath -> IO Text -- | Reads a UTF8-encoded text file and converts many character sequences -- which may be interpreted as line or paragraph separators into 'n'. -- -- If the file cannot be decoded, then a ReadException is raised. readFile :: FilePath -> IO String -- | Writes a UTF8-encoded text file. The native convention for line -- endings is used. writeFile :: FilePath -> String -> IO () -- | Writes a UTF8-encoded text file. The native convention for line -- endings is used. writeTextToFile :: FilePath -> Text -> IO () instance GHC.Show.Show Agda.Utils.IO.UTF8.ReadException instance GHC.Exception.Type.Exception Agda.Utils.IO.UTF8.ReadException -- | Utilities for Data.IORef. module Agda.Utils.IORef -- | Read IORef, modify it strictly, and return old value. readModifyIORef' :: IORef a -> (a -> a) -> IO a -- | An interface for reporting "impossible" errors module Agda.Utils.Impossible -- | "Impossible" errors, annotated with a file name and a line number -- corresponding to the source code location of the error. data Impossible -- | We reached a program point which should be unreachable. Impossible :: CallStack -> Impossible -- | Impossible with a different error message. Used when we reach -- a program point which can in principle be reached, but not for a -- certain run. Unreachable :: CallStack -> Impossible -- | We reached a program point without all the required primitives or -- BUILTIN to proceed forward. ImpMissingDefinitions neededDefs -- forThis ImpMissingDefinitions :: [String] -> String -> Impossible -- | Abort by throwing an "impossible" error. You should not use this -- function directly. Instead use IMPOSSIBLE throwImpossible :: Impossible -> a -- | Monads in which we can catch an "impossible" error, if possible. class CatchImpossible m -- | Catch any Impossible exception. catchImpossible :: CatchImpossible m => m a -> (Impossible -> m a) -> m a -- | Catch only Impossible exceptions selected by the filter. catchImpossibleJust :: CatchImpossible m => (Impossible -> Maybe b) -> m a -> (b -> m a) -> m a -- | Version of catchImpossible with argument order suiting short -- handlers. handleImpossible :: CatchImpossible m => (Impossible -> m a) -> m a -> m a -- | Version of catchImpossibleJust with argument order suiting -- short handlers. handleImpossibleJust :: CatchImpossible m => (Impossible -> Maybe b) -> (b -> m a) -> m a -> m a -- | Throw an Impossible error reporting the *caller's* call site. __IMPOSSIBLE__ :: HasCallStack => a impossible :: HasCallStack => Impossible -- | Throw an Unreachable error reporting the *caller's* call site. -- Note that this call to "withFileAndLine" will be filtered out due its -- filter on the srcLocModule. __UNREACHABLE__ :: HasCallStack => a instance Agda.Utils.Impossible.CatchImpossible GHC.Types.IO instance GHC.Classes.Eq Agda.Utils.Impossible.Impossible instance GHC.Classes.Ord Agda.Utils.Impossible.Impossible instance Control.DeepSeq.NFData Agda.Utils.Impossible.Impossible instance GHC.Show.Show Agda.Utils.Impossible.Impossible instance GHC.Exception.Type.Exception Agda.Utils.Impossible.Impossible -- | An empty type with some useful instances. module Agda.Utils.Empty data Empty absurd :: Empty -> a -- | toImpossible e extracts the Impossible value raised -- via IMPOSSIBLE to create the element e of -- type Empty. It proceeds by evaluating e to weak head -- normal form and catching the exception. We are forced to wrap things -- in a Maybe because of catchImpossible's type. toImpossible :: Empty -> IO Impossible instance Control.DeepSeq.NFData Agda.Utils.Empty.Empty instance GHC.Classes.Eq Agda.Utils.Empty.Empty instance GHC.Classes.Ord Agda.Utils.Empty.Empty instance GHC.Show.Show Agda.Utils.Empty.Empty -- | Representation of Set Bool as a 4-element -- enum type. -- -- All operations in constant time and space. -- -- Mimics the interface of Set. -- -- Import as: import qualified Agda.Utils.BoolSet as BoolSet import -- Agda.Utils.BoolSet (BoolSet) module Agda.Utils.BoolSet -- | Isomorphic to Set Bool. data BoolSet (\\) :: BoolSet -> BoolSet -> BoolSet complement :: BoolSet -> BoolSet delete :: Bool -> BoolSet -> BoolSet difference :: BoolSet -> BoolSet -> BoolSet elems :: BoolSet -> [Bool] -- | The empty set. empty :: BoolSet fromList :: [Bool] -> BoolSet fromAscList :: [Bool] -> BoolSet fromDistinctAscList :: [Bool] -> BoolSet insert :: Bool -> BoolSet -> BoolSet intersection :: BoolSet -> BoolSet -> BoolSet isSubsetOf :: BoolSet -> BoolSet -> Bool lookupMin :: BoolSet -> Maybe Bool member :: Bool -> BoolSet -> Bool -- | not . member b. notMember :: Bool -> BoolSet -> Bool null :: BoolSet -> Bool -- | A singleton set. singleton :: Bool -> BoolSet size :: BoolSet -> Int toList :: BoolSet -> [Bool] toAscList :: BoolSet -> [Bool] -- | toSingleton s == Just b iff s == singleton b. toSingleton :: BoolSet -> Maybe Bool -- | The full set. total :: BoolSet union :: BoolSet -> BoolSet -> BoolSet instance GHC.Enum.Bounded Agda.Utils.BoolSet.BoolSet instance GHC.Enum.Enum Agda.Utils.BoolSet.BoolSet instance GHC.Show.Show Agda.Utils.BoolSet.BoolSet instance GHC.Classes.Ord Agda.Utils.BoolSet.BoolSet instance GHC.Classes.Eq Agda.Utils.BoolSet.BoolSet -- | A simple overlay over Data.Map to manage unordered sets with -- duplicates. module Agda.Utils.Bag -- | A set with duplicates. Faithfully stores elements which are equal with -- regard to (==). newtype Bag a Bag :: Map a [a] -> Bag a -- | The list contains all occurrences of a (not just the -- duplicates!). Hence, the invariant: the list is never empty. [bag] :: Bag a -> Map a [a] -- | Is the bag empty? null :: Bag a -> Bool -- | Number of elements in the bag. Duplicates count. O(n). size :: Bag a -> Int -- | (bag ! a) finds all elements equal to a. O(log n). -- Total function, returns [] if none are. (!) :: Ord a => Bag a -> a -> [a] -- | O(log n). member :: Ord a => a -> Bag a -> Bool -- | O(log n). notMember :: Ord a => a -> Bag a -> Bool -- | Return the multiplicity of the given element. O(log n + count _ _). count :: Ord a => a -> Bag a -> Int -- | O(1) empty :: Bag a -- | O(1) singleton :: a -> Bag a union :: Ord a => Bag a -> Bag a -> Bag a unions :: Ord a => [Bag a] -> Bag a -- |
--   insert a b = union b (singleton a)
--   
insert :: Ord a => a -> Bag a -> Bag a -- |
--   fromList = unions . map singleton
--   
fromList :: Ord a => [a] -> Bag a -- | Returns the elements of the bag, grouped by equality (==). groups :: Bag a -> [[a]] -- | Returns the bag, with duplicates. toList :: Bag a -> [a] -- | Returns the bag without duplicates. keys :: Bag a -> [a] -- | Returns the bag, with duplicates. elems :: Bag a -> [a] toAscList :: Bag a -> [a] map :: Ord b => (a -> b) -> Bag a -> Bag b traverse' :: forall a b m. (Applicative m, Ord b) => (a -> m b) -> Bag a -> m (Bag b) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Utils.Bag.Bag a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.Bag.Bag a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.Bag.Bag a) instance GHC.Classes.Ord a => GHC.Base.Semigroup (Agda.Utils.Bag.Bag a) instance GHC.Classes.Ord a => GHC.Base.Monoid (Agda.Utils.Bag.Bag a) instance Data.Foldable.Foldable Agda.Utils.Bag.Bag module Agda.Auto.NarrowingSearch newtype Prio Prio :: Int -> Prio [getPrio] :: Prio -> Int class Trav a where { type Block a; } trav :: (Trav a, Monad m) => (forall b. TravWith b (Block a) => MM b (Block b) -> m ()) -> a -> m () -- | Trav instance a with block type blk type TravWith a blk = (Trav a, Block a ~ blk) data Term blk Term :: a -> Term blk -- | Result of type-checking. data Prop blk -- | Success. OK :: Prop blk -- | Definite failure. Error :: String -> Prop blk -- | Experimental. AddExtraRef :: String -> Metavar a blk -> Move' blk a -> Prop blk -- | Parallel conjunction of constraints. And :: Maybe [Term blk] -> MetaEnv (PB blk) -> MetaEnv (PB blk) -> Prop blk -- | Experimental, related to mcompoint. First arg is sidecondition. Sidecondition :: MetaEnv (PB blk) -> MetaEnv (PB blk) -> Prop blk -- | Forking proof on something that is not part of the term language. E.g. -- whether a term will reduce or not. Or :: Prio -> MetaEnv (PB blk) -> MetaEnv (PB blk) -> Prop blk -- | Obsolete. ConnectHandle :: OKHandle blk -> MetaEnv (PB blk) -> Prop blk data OKVal OKVal :: OKVal type OKHandle blk = MM OKVal blk type OKMeta blk = Metavar OKVal blk -- | Agsy's meta variables. -- -- a the type of the metavariable (what it can be instantiated -- with). blk the search control information (e.g. the scope of -- the meta). data Metavar a blk Metavar :: IORef (Maybe a) -> IORef Bool -> IORef [(QPB a blk, Maybe (CTree blk))] -> IORef [SubConstraints blk] -> IORef [Move' blk a] -> Metavar a blk -- | Maybe an instantiation (refinement). It is usually shallow, i.e., just -- one construct(or) with arguments again being metas. [mbind] :: Metavar a blk -> IORef (Maybe a) -- | Does this meta block a principal constraint (i.e., a type-checking -- constraint). [mprincipalpresent] :: Metavar a blk -> IORef Bool -- | List of observers, i.e., constraints blocked by this meta. [mobs] :: Metavar a blk -> IORef [(QPB a blk, Maybe (CTree blk))] -- | Used for experiments with independence of subproofs. [mcompoint] :: Metavar a blk -> IORef [SubConstraints blk] -- | Experimental. [mextrarefs] :: Metavar a blk -> IORef [Move' blk a] hequalMetavar :: Metavar a1 blk1 -> Metavar a2 bkl2 -> Bool newMeta :: IORef [SubConstraints blk] -> IO (Metavar a blk) initMeta :: IO (Metavar a blk) data CTree blk CTree :: IORef (PrioMeta blk) -> IORef (Maybe (SubConstraints blk)) -> IORef (Maybe (CTree blk)) -> IORef [OKMeta blk] -> CTree blk [ctpriometa] :: CTree blk -> IORef (PrioMeta blk) [ctsub] :: CTree blk -> IORef (Maybe (SubConstraints blk)) [ctparent] :: CTree blk -> IORef (Maybe (CTree blk)) [cthandles] :: CTree blk -> IORef [OKMeta blk] data SubConstraints blk SubConstraints :: IORef Bool -> IORef Int -> CTree blk -> CTree blk -> SubConstraints blk [scflip] :: SubConstraints blk -> IORef Bool [sccomcount] :: SubConstraints blk -> IORef Int [scsub1] :: SubConstraints blk -> CTree blk [scsub2] :: SubConstraints blk -> CTree blk newCTree :: Maybe (CTree blk) -> IO (CTree blk) newSubConstraints :: CTree blk -> IO (SubConstraints blk) data PrioMeta blk PrioMeta :: Prio -> Metavar a blk -> PrioMeta blk NoPrio :: Bool -> PrioMeta blk data Restore Restore :: IORef a -> a -> Restore type Undo = StateT [Restore] IO ureadIORef :: IORef a -> Undo a uwriteIORef :: IORef a -> a -> Undo () umodifyIORef :: IORef a -> (a -> a) -> Undo () ureadmodifyIORef :: IORef a -> (a -> a) -> Undo a runUndo :: Undo a -> IO a newtype RefCreateEnv blk a RefCreateEnv :: StateT (IORef [SubConstraints blk], Int) IO a -> RefCreateEnv blk a [runRefCreateEnv] :: RefCreateEnv blk a -> StateT (IORef [SubConstraints blk], Int) IO a newtype Cost Cost :: Int -> Cost [getCost] :: Cost -> Int data Move' blk a Move :: Cost -> RefCreateEnv blk a -> Move' blk a [moveCost] :: Move' blk a -> Cost [moveNext] :: Move' blk a -> RefCreateEnv blk a class Refinable a blk refinements :: Refinable a blk => blk -> [blk] -> Metavar a blk -> IO [Move' blk a] newPlaceholder :: RefCreateEnv blk (MM a blk) newOKHandle :: RefCreateEnv blk (OKHandle blk) dryInstantiate :: RefCreateEnv blk a -> IO a type BlkInfo blk = (Bool, Prio, Maybe blk) data MM a blk NotM :: a -> MM a blk Meta :: Metavar a blk -> MM a blk rm :: Empty -> MM a b -> a type MetaEnv = IO data MB a blk NotB :: a -> MB a blk Blocked :: Metavar b blk -> MetaEnv (MB a blk) -> MB a blk Failed :: String -> MB a blk data PB blk NotPB :: Prop blk -> PB blk PBlocked :: Metavar b blk -> BlkInfo blk -> MetaEnv (PB blk) -> PB blk PDoubleBlocked :: Metavar b1 blk -> Metavar b2 blk -> MetaEnv (PB blk) -> PB blk data QPB b blk QPBlocked :: BlkInfo blk -> MetaEnv (PB blk) -> QPB b blk QPDoubleBlocked :: IORef Bool -> MetaEnv (PB blk) -> QPB b blk mmcase :: Refinable a blk => MM a blk -> (a -> MetaEnv (MB b blk)) -> MetaEnv (MB b blk) mmmcase :: MM a blk -> MetaEnv (MB b blk) -> (a -> MetaEnv (MB b blk)) -> MetaEnv (MB b blk) mmpcase :: Refinable a blk => BlkInfo blk -> MM a blk -> (a -> MetaEnv (PB blk)) -> MetaEnv (PB blk) doubleblock :: (Refinable a blk, Refinable b blk) => MM a blk -> MM b blk -> MetaEnv (PB blk) -> MetaEnv (PB blk) mbcase :: MetaEnv (MB a blk) -> (a -> MetaEnv (MB b blk)) -> MetaEnv (MB b blk) mbpcase :: Prio -> Maybe blk -> MetaEnv (MB a blk) -> (a -> MetaEnv (PB blk)) -> MetaEnv (PB blk) mmbpcase :: MetaEnv (MB a blk) -> (forall b. Refinable b blk => MM b blk -> MetaEnv (PB blk)) -> (a -> MetaEnv (PB blk)) -> MetaEnv (PB blk) waitok :: OKHandle blk -> MetaEnv (MB b blk) -> MetaEnv (MB b blk) mbret :: a -> MetaEnv (MB a blk) mbfailed :: String -> MetaEnv (MB a blk) mpret :: Prop blk -> MetaEnv (PB blk) expandbind :: MM a blk -> MetaEnv (MM a blk) type HandleSol = IO () type SRes = Either Bool Int topSearch :: forall blk. IORef Int -> IORef Int -> HandleSol -> blk -> MetaEnv (PB blk) -> Cost -> Cost -> IO Bool extractblkinfos :: Metavar a blk -> IO [blk] recalcs :: [(QPB a blk, Maybe (CTree blk))] -> Undo Bool seqc :: Undo Bool -> Undo Bool -> Undo Bool recalc :: (QPB a blk, Maybe (CTree blk)) -> Undo Bool reccalc :: MetaEnv (PB blk) -> Maybe (CTree blk) -> Undo Bool calc :: forall blk. MetaEnv (PB blk) -> Maybe (CTree blk) -> Undo (Maybe [OKMeta blk]) choosePrioMeta :: Bool -> PrioMeta blk -> PrioMeta blk -> PrioMeta blk propagatePrio :: CTree blk -> Undo [OKMeta blk] data Choice LeftDisjunct :: Choice RightDisjunct :: Choice choose :: MM Choice blk -> Prio -> MetaEnv (PB blk) -> MetaEnv (PB blk) -> MetaEnv (PB blk) instance GHC.Num.Num Agda.Auto.NarrowingSearch.Prio instance GHC.Classes.Ord Agda.Auto.NarrowingSearch.Prio instance GHC.Classes.Eq Agda.Auto.NarrowingSearch.Prio instance GHC.Classes.Ord Agda.Auto.NarrowingSearch.Cost instance GHC.Classes.Eq Agda.Auto.NarrowingSearch.Cost instance GHC.Num.Num Agda.Auto.NarrowingSearch.Cost instance Agda.Auto.NarrowingSearch.Refinable Agda.Auto.NarrowingSearch.Choice blk instance Agda.Auto.NarrowingSearch.TravWith a blk => Agda.Auto.NarrowingSearch.Trav (Agda.Auto.NarrowingSearch.MM a blk) instance GHC.Classes.Eq (Agda.Auto.NarrowingSearch.Metavar a blk) instance GHC.Classes.Eq (Agda.Auto.NarrowingSearch.PrioMeta blk) instance GHC.Base.Functor (Agda.Auto.NarrowingSearch.RefCreateEnv blk) instance GHC.Base.Applicative (Agda.Auto.NarrowingSearch.RefCreateEnv blk) instance GHC.Base.Monad (Agda.Auto.NarrowingSearch.RefCreateEnv blk) instance Agda.Auto.NarrowingSearch.Refinable Agda.Auto.NarrowingSearch.OKVal blk -- | Possibly infinite sets of integers (but with finitely many consecutive -- segments). Used for checking guard coverage in int/nat cases in the -- treeless compiler. module Agda.Utils.IntSet.Infinite -- | Represents a set of integers. Invariants: - All cannot be the argument -- to Below or Above - at most one IntsBelow - at -- most one IntsAbove - if `Below lo` and `Below hi`, then `lo -- < hi` - if `Below lo .. (Some xs)` then `all (> lo) xs` - if -- `Above hi .. (Some xs)` then `all (< hi - 1) xs` data IntSet -- | No integers. empty :: IntSet -- | All integers. full :: IntSet -- | All integers `< n` below :: Integer -> IntSet -- | All integers `>= n` above :: Integer -> IntSet -- | A single integer. singleton :: Integer -> IntSet difference :: IntSet -> IntSet -> IntSet -- | Membership member :: Integer -> IntSet -> Bool -- | If finite, return the list of elements. toFiniteList :: IntSet -> Maybe [Integer] -- | Invariant. invariant :: IntSet -> Bool instance GHC.Show.Show Agda.Utils.IntSet.Infinite.IntSet instance GHC.Classes.Eq Agda.Utils.IntSet.Infinite.IntSet instance GHC.Base.Semigroup Agda.Utils.IntSet.Infinite.IntSet instance GHC.Base.Monoid Agda.Utils.IntSet.Infinite.IntSet -- | A cut-down implementation of lenses, with names taken from Edward -- Kmett's lens package. module Agda.Utils.Lens type LensMap i o = (i -> i) -> o -> o type LensSet i o = i -> o -> o type LensGet i o = o -> i -- | Van Laarhoven style homogeneous lenses. Mnemoic: "Lens inner outer". type Lens' i o = forall f. Functor f => (i -> f i) -> o -> f o lFst :: Lens' a (a, b) lSnd :: Lens' b (a, b) -- | Get inner part i of structure o as designated by -- Lens' i o. (^.) :: o -> Lens' i o -> i infixl 8 ^. -- | Set inner part i of structure o as designated by -- Lens' i o. set :: Lens' i o -> LensSet i o -- | Modify inner part i of structure o using a function -- i -> i. over :: Lens' i o -> LensMap i o -- | Focus on a part of the state for a stateful computation. focus :: Monad m => Lens' i o -> StateT i m a -> StateT o m a -- | Read a part of the state. use :: MonadState o m => Lens' i o -> m i -- | Write a part of the state. (.=) :: MonadState o m => Lens' i o -> i -> m () infix 4 .= -- | Modify a part of the state. (%=) :: MonadState o m => Lens' i o -> (i -> i) -> m () infix 4 %= -- | Modify a part of the state monadically. (%==) :: MonadState o m => Lens' i o -> (i -> m i) -> m () infix 4 %== -- | Modify a part of the state monadically, and return some result. (%%=) :: MonadState o m => Lens' i o -> (i -> m (i, r)) -> m r infix 4 %%= -- | Modify a part of the state locally. locallyState :: MonadState o m => Lens' i o -> (i -> i) -> m r -> m r -- | Ask for part of read-only state. view :: MonadReader o m => Lens' i o -> m i -- | Modify a part of the state in a subcomputation. locally :: MonadReader o m => Lens' i o -> (i -> i) -> m a -> m a locally' :: ((o -> o) -> m a -> m a) -> Lens' i o -> (i -> i) -> m a -> m a key :: Ord k => k -> Lens' (Maybe v) (Map k v) -- | Infix version of for. (<&>) :: Functor m => m a -> (a -> b) -> m b infixl 1 <&> module Agda.Utils.IndexedList -- | Existential wrapper for indexed types. data Some :: (k -> Type) -> Type [Some] :: f i -> Some f -- | Unpacking a wrapped value. withSome :: Some b -> (forall i. b i -> a) -> a -- | Lists indexed by a type-level list. A value of type All p -- [x₁..xₙ] is a sequence of values of types p x₁, .., -- p xₙ. data All :: (x -> Type) -> [x] -> Type [Nil] :: All p '[] [Cons] :: p x -> All p xs -> All p (x : xs) -- | Constructing an indexed list from a plain list. makeAll :: (a -> Some b) -> [a] -> Some (All b) -- | Turning an indexed list back into a plain list. forgetAll :: (forall x. b x -> a) -> All b xs -> [a] -- | An index into a type-level list. data Index :: [x] -> x -> Type [Zero] :: Index (x : xs) x [Suc] :: Index xs x -> Index (y : xs) x -- | Indices are just natural numbers. forgetIndex :: Index xs x -> Int -- | Mapping over an indexed list. mapWithIndex :: (forall x. Index xs x -> p x -> q x) -> All p xs -> All q xs -- | If you have an index you can get a lens for the given element. lIndex :: Index xs x -> Lens' (p x) (All p xs) -- | Looking up an element in an indexed list. lookupIndex :: All p xs -> Index xs x -> p x -- | All indices into an indexed list. allIndices :: All p xs -> All (Index xs) xs module Agda.Auto.Options data Mode MNormal :: Bool -> Bool -> Mode MCaseSplit :: Mode MRefine :: Bool -> Mode data AutoHintMode AHMNone :: AutoHintMode AHMModule :: AutoHintMode type Hints = [String] newtype TimeOut TimeOut :: Int -> TimeOut [getTimeOut] :: TimeOut -> Int -- | Options for Auto, default value and lenses data AutoOptions AutoOptions :: Hints -> TimeOut -> Int -> Mode -> AutoHintMode -> AutoOptions [autoHints] :: AutoOptions -> Hints [autoTimeOut] :: AutoOptions -> TimeOut [autoPick] :: AutoOptions -> Int [autoMode] :: AutoOptions -> Mode [autoHintMode] :: AutoOptions -> AutoHintMode initAutoOptions :: AutoOptions aoHints :: Lens' Hints AutoOptions aoTimeOut :: Lens' TimeOut AutoOptions aoPick :: Lens' Int AutoOptions aoMode :: Lens' Mode AutoOptions aoHintMode :: Lens' AutoHintMode AutoOptions -- | Tokenising the input (makes parseArgs cleaner) data AutoToken M :: AutoToken C :: AutoToken R :: AutoToken D :: AutoToken L :: AutoToken T :: String -> AutoToken S :: Int -> AutoToken H :: String -> AutoToken autoTokens :: [String] -> [AutoToken] parseTime :: String -> Int parseArgs :: String -> AutoOptions instance GHC.Show.Show Agda.Auto.Options.TimeOut -- | Examples how to use Agda.Utils.Lens. module Agda.Utils.Lens.Examples data Record a b Record :: a -> b -> Record a b [field1] :: Record a b -> a [field2] :: Record a b -> b -- | (View source:) This is how you implement a lens for a record field. lensField1 :: Lens' a (Record a b) lensField2 :: Lens' b (Record a b) module Agda.Utils.Map -- | Update monadically the value at one position (must exist!). adjustM :: (Functor f, Ord k) => (v -> f v) -> k -> Map k v -> f (Map k v) -- | Wrapper for adjustM for convenience. adjustM' :: (Functor f, Ord k) => (v -> f (a, v)) -> k -> Map k v -> f (a, Map k v) -- | Filter a map based on the keys. filterKeys :: (k -> Bool) -> Map k a -> Map k a -- | Extend Maybe by common operations for the Maybe type. -- -- Note: since this module is usually imported unqualified, we do not use -- short names, but all names contain Maybe, Just, or -- 'Nothing. module Agda.Utils.Maybe -- | Retain object when tag is True. boolToMaybe :: Bool -> a -> Maybe a -- | unionWith for collections of size <= 1. unionMaybeWith :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a -- | unionsWith for collections of size <= 1. unionsMaybeWith :: (a -> a -> a) -> [Maybe a] -> Maybe a -- | Unzipping a list of length <= 1. unzipMaybe :: Maybe (a, b) -> (Maybe a, Maybe b) -- | Filtering a singleton list. -- --
--   filterMaybe p a = listToMaybe (filter p [a])
--   
filterMaybe :: (a -> Bool) -> a -> Maybe a -- | Version of mapMaybe with different argument ordering. forMaybe :: [a] -> (a -> Maybe b) -> [b] -- | Version of maybe with different argument ordering. Often, we -- want to case on a Maybe, do something interesting in the -- Just case, but only a default action in the Nothing -- case. Then, the argument ordering of caseMaybe is preferable. -- --
--   caseMaybe m d f = flip (maybe d) m f
--   
caseMaybe :: Maybe a -> b -> (a -> b) -> b -- | caseMaybe with flipped branches. ifJust :: Maybe a -> (a -> b) -> b -> b -- | Monadic version of maybe. maybeM :: Monad m => m b -> (a -> m b) -> m (Maybe a) -> m b -- | Monadic version of fromMaybe. fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a -- | Monadic version of caseMaybe. That is, maybeM with a -- different argument ordering. caseMaybeM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b -- | caseMaybeM with flipped branches. ifJustM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b -- | A more telling name for forM_ for the Maybe collection -- type. Or: caseMaybe without the Nothing case. whenJust :: Monad m => Maybe a -> (a -> m ()) -> m () -- | caseMaybe without the Just case. whenNothing :: Monoid m => Maybe a -> m -> m -- | caseMaybeM without the Nothing case. whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () -- | caseMaybeM without the Just case. whenNothingM :: Monad m => m (Maybe a) -> m () -> m () -- | Lazy version of allJust . sequence. (allJust = -- mapM for the Maybe monad.) Only executes monadic effect -- while isJust. allJustM :: Monad m => [m (Maybe a)] -> m (Maybe [a]) -- | Lift a maybe to an Alternative. liftMaybe :: Alternative f => Maybe a -> f a module Agda.Utils.Memo -- | Simple, non-reentrant memoisation. memo :: MonadState s m => Lens' (Maybe a) s -> m a -> m a -- | Recursive memoisation, second argument is the value you get on -- recursive calls. memoRec :: MonadState s m => Lens' (Maybe a) s -> a -> m a -> m a memoUnsafe :: Ord a => (a -> b) -> a -> b memoUnsafeH :: (Eq a, Hashable a) => (a -> b) -> a -> b -- | More monoids. module Agda.Utils.Monoid -- | Maximum of on-negative (small) natural numbers. newtype MaxNat MaxNat :: Int -> MaxNat [getMaxNat] :: MaxNat -> Int instance GHC.Enum.Enum Agda.Utils.Monoid.MaxNat instance GHC.Show.Show Agda.Utils.Monoid.MaxNat instance GHC.Classes.Ord Agda.Utils.Monoid.MaxNat instance GHC.Classes.Eq Agda.Utils.Monoid.MaxNat instance GHC.Num.Num Agda.Utils.Monoid.MaxNat instance GHC.Base.Semigroup Agda.Utils.Monoid.MaxNat instance GHC.Base.Monoid Agda.Utils.Monoid.MaxNat -- | Overloaded null and empty for collections and -- sequences. module Agda.Utils.Null class Null a empty :: Null a => a -- | Satisfying null empty == True. null :: Null a => a -> Bool -- | Satisfying null empty == True. null :: (Null a, Eq a) => a -> Bool ifNull :: Null a => a -> b -> (a -> b) -> b ifNotNull :: Null a => a -> (a -> b) -> b -> b ifNullM :: (Monad m, Null a) => m a -> m b -> (a -> m b) -> m b ifNotNullM :: (Monad m, Null a) => m a -> (a -> m b) -> m b -> m b whenNull :: (Monad m, Null a) => a -> m () -> m () unlessNull :: (Monad m, Null a) => a -> (a -> m ()) -> m () whenNullM :: (Monad m, Null a) => m a -> m () -> m () unlessNullM :: (Monad m, Null a) => m a -> (a -> m ()) -> m () instance Agda.Utils.Null.Null () instance (Agda.Utils.Null.Null a, Agda.Utils.Null.Null b) => Agda.Utils.Null.Null (a, b) instance (Agda.Utils.Null.Null a, Agda.Utils.Null.Null b, Agda.Utils.Null.Null c) => Agda.Utils.Null.Null (a, b, c) instance (Agda.Utils.Null.Null a, Agda.Utils.Null.Null b, Agda.Utils.Null.Null c, Agda.Utils.Null.Null d) => Agda.Utils.Null.Null (a, b, c, d) instance Agda.Utils.Null.Null Data.ByteString.Internal.ByteString instance Agda.Utils.Null.Null Data.ByteString.Lazy.Internal.ByteString instance Agda.Utils.Null.Null Data.Text.Internal.Text instance Agda.Utils.Null.Null [a] instance Agda.Utils.Null.Null (Agda.Utils.Bag.Bag a) instance Agda.Utils.Null.Null (Data.IntMap.Internal.IntMap a) instance Agda.Utils.Null.Null Data.IntSet.Internal.IntSet instance Agda.Utils.Null.Null (Data.Map.Internal.Map k a) instance Agda.Utils.Null.Null (Data.HashMap.Internal.HashMap k a) instance Agda.Utils.Null.Null (Data.HashSet.Internal.HashSet a) instance Agda.Utils.Null.Null (Data.Sequence.Internal.Seq a) instance Agda.Utils.Null.Null (Data.Set.Internal.Set a) instance Agda.Utils.Null.Null (GHC.Maybe.Maybe a) instance Agda.Utils.Null.Null Text.PrettyPrint.HughesPJ.Doc instance Agda.Utils.Null.Null a => Agda.Utils.Null.Null (Data.Functor.Identity.Identity a) instance Agda.Utils.Null.Null a => Agda.Utils.Null.Null (GHC.Types.IO a) instance (Agda.Utils.Null.Null (m a), GHC.Base.Monad m) => Agda.Utils.Null.Null (Control.Monad.Trans.Except.ExceptT e m a) instance (Agda.Utils.Null.Null (m a), GHC.Base.Monad m) => Agda.Utils.Null.Null (Control.Monad.Trans.Reader.ReaderT r m a) instance (Agda.Utils.Null.Null (m a), GHC.Base.Monad m) => Agda.Utils.Null.Null (Control.Monad.Trans.State.Lazy.StateT s m a) instance (Agda.Utils.Null.Null (m a), GHC.Base.Monad m, GHC.Base.Monoid w) => Agda.Utils.Null.Null (Control.Monad.Trans.Writer.Lazy.WriterT w m a) -- | A strict version of the Maybe type. -- -- Import qualified, as in import qualified Agda.Utils.Maybe.Strict -- as Strict -- -- Copyright : (c) 2006-2007 Roman Leshchinskiy (c) 2013 Simon Meier -- License : BSD-style (see the file LICENSE) -- -- Copyright : (c) 2014 Andreas Abel module Agda.Utils.Maybe.Strict -- | unionWith for collections of size <= 1. unionMaybeWith :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a -- | Unzipping a list of length <= 1. unzipMaybe :: Maybe (a, b) -> (Maybe a, Maybe b) -- | Filtering a singleton list. -- --
--   filterMaybe p a = listToMaybe (filter p [a])
--   
filterMaybe :: (a -> Bool) -> a -> Maybe a -- | Version of mapMaybe with different argument ordering. forMaybe :: [a] -> (a -> Maybe b) -> [b] -- | Version of maybe with different argument ordering. Often, we -- want to case on a Maybe, do something interesting in the -- Just case, but only a default action in the Nothing -- case. Then, the argument ordering of caseMaybe is preferable. -- --
--   caseMaybe m err f = flip (maybe err) m f
--   
caseMaybe :: Maybe a -> b -> (a -> b) -> b -- | Monadic version of maybe. maybeM :: Monad m => m b -> (a -> m b) -> m (Maybe a) -> m b -- | Monadic version of fromMaybe. fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a -- | Monadic version of caseMaybe. That is, maybeM with a -- different argument ordering. caseMaybeM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b -- | caseMaybeM with flipped branches. ifJustM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b -- | A more telling name for forM for the Maybe collection -- type. Or: caseMaybe without the Nothing case. whenJust :: Monad m => Maybe a -> (a -> m ()) -> m () -- | caseMaybeM without the Nothing case. whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () instance GHC.Base.Applicative Data.Strict.Maybe.Maybe instance Agda.Utils.Null.Null (Data.Strict.Maybe.Maybe a) module Agda.Utils.PartialOrd -- | The result of comparing two things (of the same type). data PartialOrdering -- | Less than. POLT :: PartialOrdering -- | Less or equal than. POLE :: PartialOrdering -- | Equal POEQ :: PartialOrdering -- | Greater or equal. POGE :: PartialOrdering -- | Greater than. POGT :: PartialOrdering -- | No information (incomparable). POAny :: PartialOrdering -- | Comparing the information content of two elements of -- PartialOrdering. More precise information is smaller. -- -- Includes equality: x leqPO x == True. leqPO :: PartialOrdering -> PartialOrdering -> Bool -- | Opposites. -- -- related a po b iff related b (oppPO po) a. oppPO :: PartialOrdering -> PartialOrdering -- | Combining two pieces of information (picking the least information). -- Used for the dominance ordering on tuples. -- -- orPO is associative, commutative, and idempotent. -- orPO has dominant element POAny, but no neutral -- element. orPO :: PartialOrdering -> PartialOrdering -> PartialOrdering -- | Chains (transitivity) x R y S z. -- -- seqPO is associative, commutative, and idempotent. -- seqPO has dominant element POAny and neutral element -- (unit) POEQ. seqPO :: PartialOrdering -> PartialOrdering -> PartialOrdering -- | Embed Ordering. fromOrdering :: Ordering -> PartialOrdering -- | Represent a non-empty disjunction of Orderings as -- PartialOrdering. fromOrderings :: [Ordering] -> PartialOrdering -- | A PartialOrdering information is a disjunction of -- Ordering informations. toOrderings :: PartialOrdering -> [Ordering] type Comparable a = a -> a -> PartialOrdering -- | Decidable partial orderings. class PartialOrd a comparable :: PartialOrd a => Comparable a -- | Any Ord is a PartialOrd. comparableOrd :: Ord a => Comparable a -- | Are two elements related in a specific way? -- -- related a o b holds iff comparable a b is contained -- in o. related :: PartialOrd a => a -> PartialOrdering -> a -> Bool -- | Pointwise comparison wrapper. newtype Pointwise a Pointwise :: a -> Pointwise a [pointwise] :: Pointwise a -> a -- | Inclusion comparison wrapper. newtype Inclusion a Inclusion :: a -> Inclusion a [inclusion] :: Inclusion a -> a instance GHC.Enum.Bounded Agda.Utils.PartialOrd.PartialOrdering instance GHC.Enum.Enum Agda.Utils.PartialOrd.PartialOrdering instance GHC.Show.Show Agda.Utils.PartialOrd.PartialOrdering instance GHC.Classes.Eq Agda.Utils.PartialOrd.PartialOrdering instance GHC.Base.Functor Agda.Utils.PartialOrd.Pointwise instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.PartialOrd.Pointwise a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.PartialOrd.Pointwise a) instance GHC.Base.Functor Agda.Utils.PartialOrd.Inclusion instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.PartialOrd.Inclusion a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Utils.PartialOrd.Inclusion a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.PartialOrd.Inclusion a) instance GHC.Classes.Ord a => Agda.Utils.PartialOrd.PartialOrd (Agda.Utils.PartialOrd.Inclusion [a]) instance GHC.Classes.Ord a => Agda.Utils.PartialOrd.PartialOrd (Agda.Utils.PartialOrd.Inclusion (Data.Set.Internal.Set a)) instance Agda.Utils.PartialOrd.PartialOrd a => Agda.Utils.PartialOrd.PartialOrd (Agda.Utils.PartialOrd.Pointwise [a]) instance Agda.Utils.PartialOrd.PartialOrd GHC.Types.Int instance Agda.Utils.PartialOrd.PartialOrd GHC.Num.Integer.Integer instance Agda.Utils.PartialOrd.PartialOrd () instance Agda.Utils.PartialOrd.PartialOrd a => Agda.Utils.PartialOrd.PartialOrd (GHC.Maybe.Maybe a) instance (Agda.Utils.PartialOrd.PartialOrd a, Agda.Utils.PartialOrd.PartialOrd b) => Agda.Utils.PartialOrd.PartialOrd (Data.Either.Either a b) instance (Agda.Utils.PartialOrd.PartialOrd a, Agda.Utils.PartialOrd.PartialOrd b) => Agda.Utils.PartialOrd.PartialOrd (a, b) instance Agda.Utils.PartialOrd.PartialOrd Agda.Utils.PartialOrd.PartialOrdering instance GHC.Base.Semigroup Agda.Utils.PartialOrd.PartialOrdering instance GHC.Base.Monoid Agda.Utils.PartialOrd.PartialOrdering -- | Partially ordered monoids. module Agda.Utils.POMonoid -- | Partially ordered semigroup. -- -- Law: composition must be monotone. -- --
--   related x POLE x' && related y POLE y' ==>
--   related (x <> y) POLE (x' <> y')
--   
class (PartialOrd a, Semigroup a) => POSemigroup a -- | Partially ordered monoid. -- -- Law: composition must be monotone. -- --
--   related x POLE x' && related y POLE y' ==>
--   related (x <> y) POLE (x' <> y')
--   
class (PartialOrd a, Semigroup a, Monoid a) => POMonoid a -- | Completing POMonoids with inverses to form a Galois connection. -- -- Law: composition and inverse composition form a Galois connection. -- --
--   related (inverseCompose p x) POLE y == related x POLE (p <> y)
--   
class POMonoid a => LeftClosedPOMonoid a inverseCompose :: LeftClosedPOMonoid a => a -> a -> a -- | hasLeftAdjoint x checks whether x^-1 := x -- inverseCompose mempty is such that x -- inverseCompose y == x^-1 <> y for any y. hasLeftAdjoint :: LeftClosedPOMonoid a => a -> Bool module Agda.Utils.Pointer data Ptr a newPtr :: a -> Ptr a derefPtr :: Ptr a -> a setPtr :: a -> Ptr a -> Ptr a updatePtr :: (a -> a) -> Ptr a -> Ptr a -- | If f a contains many copies of a they will all be -- the same pointer in the result. If the function is well-behaved (i.e. -- preserves the implicit equivalence, this shouldn't matter). updatePtrM :: Functor f => (a -> f a) -> Ptr a -> f (Ptr a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.Pointer.Ptr a) instance GHC.Base.Functor Agda.Utils.Pointer.Ptr instance Data.Foldable.Foldable Agda.Utils.Pointer.Ptr instance Data.Traversable.Traversable Agda.Utils.Pointer.Ptr instance GHC.Classes.Eq (Agda.Utils.Pointer.Ptr a) instance GHC.Classes.Ord (Agda.Utils.Pointer.Ptr a) instance Data.Hashable.Class.Hashable (Agda.Utils.Pointer.Ptr a) instance Control.DeepSeq.NFData (Agda.Utils.Pointer.Ptr a) module Agda.Utils.ProfileOptions -- | Various things that can be measured when checking an Agda development. -- Turned on with the `--profile` flag, for instance `--profile=sharing` -- to turn on the Sharing option. Internal, Modules, -- and Definitions are mutually exclusive. -- -- NOTE: Changing this data type requires bumping the interface version -- number in currentInterfaceVersion. data ProfileOption -- | Measure time taken by various parts of the system (type checking, -- serialization, etc) Internal :: ProfileOption -- | Measure time spent on individual (Agda) modules Modules :: ProfileOption -- | Measure time spent on individual (Agda) definitions Definitions :: ProfileOption -- | Measure things related to sharing Sharing :: ProfileOption -- | Collect detailed statistics about serialization Serialize :: ProfileOption -- | Collect statistics about constraint solving Constraints :: ProfileOption -- | Count number of created metavariables Metas :: ProfileOption -- | Measure time of interactive commands Interactive :: ProfileOption -- | Collect statistics about conversion checking Conversion :: ProfileOption -- | A set of ProfileOptions data ProfileOptions -- | The empty set of profiling options. noProfileOptions :: ProfileOptions -- | Parse and add a profiling option to a set of profiling options. -- Returns Left with a helpful error message if the option doesn't -- parse or if it's incompatible with existing options. The special -- string "all" adds all options compatible with the given set and -- prefering the first of incompatible options. So `--profile=all` sets -- Internal over Modules and Definitions, but -- `--profile=modules --profile=all` sets Modules and not -- Internal. addProfileOption :: String -> ProfileOptions -> Either String ProfileOptions -- | Check if a given profiling option is present in a set of profiling -- options. containsProfileOption :: ProfileOption -> ProfileOptions -> Bool -- | Use only for serialization. profileOptionsToList :: ProfileOptions -> [ProfileOption] -- | Use only for serialization. profileOptionsFromList :: [ProfileOption] -> ProfileOptions -- | Strings accepted by addProfileOption validProfileOptionStrings :: [String] instance GHC.Generics.Generic Agda.Utils.ProfileOptions.ProfileOption instance GHC.Enum.Bounded Agda.Utils.ProfileOptions.ProfileOption instance GHC.Enum.Enum Agda.Utils.ProfileOptions.ProfileOption instance GHC.Classes.Ord Agda.Utils.ProfileOptions.ProfileOption instance GHC.Classes.Eq Agda.Utils.ProfileOptions.ProfileOption instance GHC.Show.Show Agda.Utils.ProfileOptions.ProfileOption instance Control.DeepSeq.NFData Agda.Utils.ProfileOptions.ProfileOptions instance GHC.Classes.Eq Agda.Utils.ProfileOptions.ProfileOptions instance GHC.Show.Show Agda.Utils.ProfileOptions.ProfileOptions instance Control.DeepSeq.NFData Agda.Utils.ProfileOptions.ProfileOption module Agda.Utils.SemiRing -- | Semirings (https://en.wikipedia.org/wiki/Semiring). class SemiRing a ozero :: SemiRing a => a oone :: SemiRing a => a oplus :: SemiRing a => a -> a -> a otimes :: SemiRing a => a -> a -> a -- | Star semirings -- (https://en.wikipedia.org/wiki/Semiring#Star_semirings). class SemiRing a => StarSemiRing a ostar :: StarSemiRing a => a -> a instance Agda.Utils.SemiRing.StarSemiRing () instance Agda.Utils.SemiRing.StarSemiRing a => Agda.Utils.SemiRing.StarSemiRing (GHC.Maybe.Maybe a) instance Agda.Utils.SemiRing.SemiRing () instance Agda.Utils.SemiRing.SemiRing a => Agda.Utils.SemiRing.SemiRing (GHC.Maybe.Maybe a) -- | Some semigroup instances used in several places module Agda.Utils.Semigroup -- | The class of semigroups (types with an associative binary operation). -- -- Instances should satisfy the following: -- -- class Semigroup a -- | An associative operation. -- --
--   >>> [1,2,3] <> [4,5,6]
--   [1,2,3,4,5,6]
--   
(<>) :: Semigroup a => a -> a -> a infixr 6 <> instance (GHC.Base.Applicative m, GHC.Base.Semigroup doc) => GHC.Base.Semigroup (Control.Monad.Trans.Reader.ReaderT s m doc) instance (GHC.Base.Monad m, GHC.Base.Semigroup doc) => GHC.Base.Semigroup (Control.Monad.Trans.State.Lazy.StateT s m doc) -- | Constructing singleton collections. module Agda.Utils.Singleton -- | A create-only possibly empty collection is a monoid with the -- possibility to inject elements. class (Semigroup coll, Monoid coll, Singleton el coll) => Collection el coll | coll -> el fromList :: Collection el coll => [el] -> coll -- | Overloaded singleton constructor for collections. class Singleton el coll | coll -> el singleton :: Singleton el coll => el -> coll instance Agda.Utils.Singleton.Collection a [a] instance Agda.Utils.Singleton.Collection a ([a] -> [a]) instance Agda.Utils.Singleton.Collection a (Data.Semigroup.Internal.Endo [a]) instance Agda.Utils.Singleton.Collection a (Data.DList.Internal.DList a) instance Agda.Utils.Singleton.Collection a (Data.Sequence.Internal.Seq a) instance Agda.Utils.Singleton.Collection GHC.Types.Int Data.IntSet.Internal.IntSet instance Agda.Utils.Singleton.Collection (GHC.Types.Int, a) (Data.IntMap.Internal.IntMap a) instance GHC.Classes.Ord a => Agda.Utils.Singleton.Collection a (Data.Set.Internal.Set a) instance GHC.Classes.Ord k => Agda.Utils.Singleton.Collection (k, a) (Data.Map.Internal.Map k a) instance (GHC.Classes.Eq a, Data.Hashable.Class.Hashable a) => Agda.Utils.Singleton.Collection a (Data.HashSet.Internal.HashSet a) instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Agda.Utils.Singleton.Collection (k, a) (Data.HashMap.Internal.HashMap k a) instance Agda.Utils.Singleton.Singleton a (GHC.Maybe.Maybe a) instance Agda.Utils.Singleton.Singleton a [a] instance Agda.Utils.Singleton.Singleton a ([a] -> [a]) instance Agda.Utils.Singleton.Singleton a (Data.Semigroup.Internal.Endo [a]) instance Agda.Utils.Singleton.Singleton a (Data.DList.Internal.DList a) instance Agda.Utils.Singleton.Singleton a (GHC.Base.NonEmpty a) instance Agda.Utils.Singleton.Singleton a (Data.Sequence.Internal.Seq a) instance Agda.Utils.Singleton.Singleton a (Data.Set.Internal.Set a) instance Agda.Utils.Singleton.Singleton GHC.Types.Int Data.IntSet.Internal.IntSet instance Agda.Utils.Singleton.Singleton (k, a) (Data.Map.Internal.Map k a) instance Agda.Utils.Singleton.Singleton (GHC.Types.Int, a) (Data.IntMap.Internal.IntMap a) instance Data.Hashable.Class.Hashable a => Agda.Utils.Singleton.Singleton a (Data.HashSet.Internal.HashSet a) instance Data.Hashable.Class.Hashable k => Agda.Utils.Singleton.Singleton (k, a) (Data.HashMap.Internal.HashMap k a) -- | Create clusters of non-overlapping things. module Agda.Utils.Cluster -- | Given a function f :: a -> NonEmpty c which returns a -- non-empty list of characteristics of a, partition a list of -- as into groups such that each element in a group shares at -- least one characteristic with at least one other element of the group. cluster :: Ord c => (a -> NonEmpty c) -> [a] -> [NonEmpty a] -- | Partition a list of as paired with a non-empty list of -- characteristics into groups such that each element in a group shares -- at least one characteristic with at least one other element of the -- group. cluster' :: Ord c => [(a, NonEmpty c)] -> [NonEmpty a] -- | Small sets represented as immutable bit arrays for fast membership -- checking. -- -- Membership checking is O(1), but all other operations are O(n) where n -- is the size of the element type. The element type needs to implement -- Bounded and Ix. -- -- Mimics the interface of Set. -- -- Import as: import qualified Agda.Utils.SmallSet as SmallSet -- import Agda.Utils.SmallSet (SmallSet) module Agda.Utils.SmallSet data SmallSet a -- | The Ix class is used to map a contiguous subrange of values in -- a type onto integers. It is used primarily for array indexing (see the -- array package). -- -- The first argument (l,u) of each of these operations is a -- pair specifying the lower and upper bounds of a contiguous subrange of -- values. -- -- An implementation is entitled to assume the following laws about these -- operations: -- -- class Ord a => Ix a -- | Time O(n). (\\) :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a -- | Time O(n). complement :: SmallSetElement a => SmallSet a -> SmallSet a -- | Time O(n). delete :: SmallSetElement a => a -> SmallSet a -> SmallSet a -- | Time O(n). difference :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a -- | Time O(n). elems :: SmallSetElement a => SmallSet a -> [a] -- | The empty set. Time O(n). empty :: SmallSetElement a => SmallSet a -- | Time O(n). fromList :: SmallSetElement a => [a] -> SmallSet a -- | Time O(n). fromAscList :: SmallSetElement a => [a] -> SmallSet a -- | Time O(n). fromDistinctAscList :: SmallSetElement a => [a] -> SmallSet a -- | Time O(n). insert :: SmallSetElement a => a -> SmallSet a -> SmallSet a -- | Time O(n). intersection :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a -- | Time O(n). isSubsetOf :: SmallSetElement a => SmallSet a -> SmallSet a -> Bool -- | Time O(n). mapMembership :: SmallSetElement a => (Bool -> Bool) -> SmallSet a -> SmallSet a -- | Time O(1). member :: SmallSetElement a => a -> SmallSet a -> Bool -- | not . member a. Time O(1). notMember :: SmallSetElement a => a -> SmallSet a -> Bool -- | Time O(n)! null :: SmallSetElement a => SmallSet a -> Bool -- | A singleton set. Time O(n). singleton :: SmallSetElement a => a -> SmallSet a -- | Time O(n). toList :: SmallSetElement a => SmallSet a -> [a] -- | Time O(n). toAscList :: SmallSetElement a => SmallSet a -> [a] -- | The full set. Time O(n). total :: SmallSetElement a => SmallSet a -- | Time O(n). union :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a -- | Time O(n). zipMembershipWith :: SmallSetElement a => (Bool -> Bool -> Bool) -> SmallSet a -> SmallSet a -> SmallSet a instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Utils.SmallSet.SmallSet a) instance (GHC.Ix.Ix a, GHC.Show.Show a) => GHC.Show.Show (Agda.Utils.SmallSet.SmallSet a) instance GHC.Ix.Ix a => GHC.Classes.Ord (Agda.Utils.SmallSet.SmallSet a) instance GHC.Ix.Ix a => GHC.Classes.Eq (Agda.Utils.SmallSet.SmallSet a) module Agda.Utils.Suffix -- | Is the character one of the subscripts '₀'-'₉'? isSubscriptDigit :: Char -> Bool -- | Converts '0'-'9' to '₀'-'₉' -- -- Precondition: The digit needs to be in range. toSubscriptDigit :: Char -> Char -- | Converts '₀'-'₉' to '0'-'9'. -- -- Precondition: The digit needs to be in range. fromSubscriptDigit :: Char -> Char -- | Classification of identifier variants. data Suffix -- | Identifier ends in Integer many primes. Prime :: Integer -> Suffix -- | Identifier ends in number Integer (ordinary digits). Index :: Integer -> Suffix -- | Identifier ends in number Integer (subscript digits). Subscript :: Integer -> Suffix -- | Increase the suffix by one. nextSuffix :: Suffix -> Suffix -- | Parse suffix. suffixView :: String -> (String, Maybe Suffix) -- | Print suffix. renderSuffix :: Suffix -> String addSuffix :: String -> Suffix -> String -- | Tools for 3-way partitioning. module Agda.Utils.Three -- | Enum type with 3 elements. data Three One :: Three Two :: Three Three :: Three -- | Partition a list into 3 groups. -- -- Preserves the relative order or elements. partition3 :: (a -> Three) -> [a] -> ([a], [a], [a]) -- | Disjoint sum of three. data Either3 a b c In1 :: a -> Either3 a b c In2 :: b -> Either3 a b c In3 :: c -> Either3 a b c -- | Partition a list into 3 groups. -- -- Preserves the relative order or elements. partitionEithers3 :: [Either3 a b c] -> ([a], [b], [c]) mapEither3M :: Applicative m => (a -> m (Either3 b c d)) -> [a] -> m ([b], [c], [d]) forEither3M :: Applicative m => [a] -> (a -> m (Either3 b c d)) -> m ([b], [c], [d]) instance GHC.Enum.Enum Agda.Utils.Three.Three instance GHC.Enum.Bounded Agda.Utils.Three.Three instance GHC.Show.Show Agda.Utils.Three.Three instance GHC.Classes.Ord Agda.Utils.Three.Three instance GHC.Classes.Eq Agda.Utils.Three.Three instance (GHC.Show.Show a, GHC.Show.Show b, GHC.Show.Show c) => GHC.Show.Show (Agda.Utils.Three.Either3 a b c) instance (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c) => GHC.Classes.Ord (Agda.Utils.Three.Either3 a b c) instance (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c) => GHC.Classes.Eq (Agda.Utils.Three.Either3 a b c) -- | Strict tries (based on Data.Map.Strict and -- Agda.Utils.Maybe.Strict). module Agda.Utils.Trie -- | Finite map from [k] to v. -- -- With the strict Maybe type, Trie is also strict in -- v. data Trie k v Trie :: !Maybe v -> !Map k (Trie k v) -> Trie k v empty :: Null a => a -- | Singleton trie. singleton :: [k] -> v -> Trie k v -- | everyPrefix k v is a trie where every prefix of k -- (including k itself) is mapped to v. everyPrefix :: [k] -> v -> Trie k v -- | Insert. Overwrites existing value if present. -- --
--   insert = insertWith ( new old -> new)
--   
insert :: Ord k => [k] -> v -> Trie k v -> Trie k v -- | Insert with function merging new value with old value. insertWith :: Ord k => (v -> v -> v) -> [k] -> v -> Trie k v -> Trie k v -- | Left biased union. -- -- union = unionWith ( new old -> new). union :: Ord k => Trie k v -> Trie k v -> Trie k v -- | Pointwise union with merge function for values. unionWith :: Ord k => (v -> v -> v) -> Trie k v -> Trie k v -> Trie k v -- | Adjust value at key, leave subtree intact. adjust :: Ord k => [k] -> (Maybe v -> Maybe v) -> Trie k v -> Trie k v -- | Delete value at key, but leave subtree intact. delete :: Ord k => [k] -> Trie k v -> Trie k v -- | Convert to ascending list. toList :: Ord k => Trie k v -> [([k], v)] -- | Convert to ascending list. toAscList :: Ord k => Trie k v -> [([k], v)] -- | Convert to list where nodes at the same level are ordered according to -- the given ordering. toListOrderedBy :: Ord k => (v -> v -> Ordering) -> Trie k v -> [([k], v)] -- | Returns the value associated with the given key, if any. lookup :: Ord k => [k] -> Trie k v -> Maybe v -- | Is the given key present in the trie? member :: Ord k => [k] -> Trie k v -> Bool -- | Collect all values along a given path. lookupPath :: Ord k => [k] -> Trie k v -> [v] -- | Get the subtrie rooted at the given key. lookupTrie :: Ord k => [k] -> Trie k v -> Trie k v -- | Create new values based on the entire subtrie. Almost, but not quite -- comonad extend. mapSubTries :: Ord k => (Trie k u -> Maybe v) -> Trie k u -> Trie k v -- | Filter a trie. filter :: Ord k => (v -> Bool) -> Trie k v -> Trie k v -- | Key lens. valueAt :: Ord k => [k] -> Lens' (Maybe v) (Trie k v) instance Data.Foldable.Foldable (Agda.Utils.Trie.Trie k) instance GHC.Base.Functor (Agda.Utils.Trie.Trie k) instance (GHC.Classes.Eq v, GHC.Classes.Eq k) => GHC.Classes.Eq (Agda.Utils.Trie.Trie k v) instance (GHC.Show.Show v, GHC.Show.Show k) => GHC.Show.Show (Agda.Utils.Trie.Trie k v) instance (Control.DeepSeq.NFData k, Control.DeepSeq.NFData v) => Control.DeepSeq.NFData (Agda.Utils.Trie.Trie k v) instance Agda.Utils.Null.Null (Agda.Utils.Trie.Trie k v) module Agda.Utils.Tuple -- | Bifunctoriality for pairs. (-*-) :: (a -> c) -> (b -> d) -> (a, b) -> (c, d) infix 2 -*- -- |
--   mapFst f = f -*- id
--   
mapFst :: (a -> c) -> (a, b) -> (c, b) -- |
--   mapSnd g = id -*- g
--   
mapSnd :: (b -> d) -> (a, b) -> (a, d) -- | Lifted pairing. (/\) :: (a -> b) -> (a -> c) -> a -> (b, c) infix 3 /\ fst3 :: (a, b, c) -> a snd3 :: (a, b, c) -> b thd3 :: (a, b, c) -> c -- | Swap the components of a pair. swap :: (a, b) -> (b, a) uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e -- | Monadic version of -*-. mapPairM :: Applicative m => (a -> m c) -> (b -> m d) -> (a, b) -> m (c, d) -- | Monadic mapFst. mapFstM :: Applicative m => (a -> m c) -> (a, b) -> m (c, b) -- | Monadic mapSnd. mapSndM :: Applicative m => (b -> m d) -> (a, b) -> m (a, d) data Pair a Pair :: a -> a -> Pair a instance Data.Traversable.Traversable Agda.Utils.Tuple.Pair instance Data.Foldable.Foldable Agda.Utils.Tuple.Pair instance GHC.Base.Functor Agda.Utils.Tuple.Pair instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.Tuple.Pair a) instance GHC.Base.Applicative Agda.Utils.Tuple.Pair -- | Utility functions for lists. module Agda.Utils.List -- | Append a single element at the end. Time: O(length); use only on small -- lists. snoc :: [a] -> a -> [a] -- | Case distinction for lists, with list first. O(1). -- -- Cf. ifNull. caseList :: [a] -> b -> (a -> [a] -> b) -> b -- | Case distinction for lists, with list first. O(1). -- -- Cf. ifNull. caseListM :: Monad m => m [a] -> m b -> (a -> [a] -> m b) -> m b -- | Case distinction for lists, with list last. O(1). listCase :: b -> (a -> [a] -> b) -> [a] -> b -- | Head function (safe). Returns a default value on empty lists. O(1). -- --
--   headWithDefault 42 []      = 42
--   headWithDefault 42 [1,2,3] = 1
--   
headWithDefault :: a -> [a] -> a -- | Tail function (safe). O(1). tailMaybe :: [a] -> Maybe [a] -- | Tail function (safe). Returns a default list on empty lists. O(1). tailWithDefault :: [a] -> [a] -> [a] -- | Last element (safe). O(n). lastMaybe :: [a] -> Maybe a -- | Last element (safe). Returns a default list on empty lists. O(n). lastWithDefault :: a -> [a] -> a -- | Last element of non-empty list (safe). O(n). last1 a as = last (a -- : as) last1 :: a -> [a] -> a -- | Last two elements (safe). O(n). last2 :: [a] -> Maybe (a, a) -- | Opposite of cons (:), safe. O(1). uncons :: [a] -> Maybe (a, [a]) -- | Maybe cons. O(1). mcons ma as = maybeToList ma ++ as mcons :: Maybe a -> [a] -> [a] -- | init and last in one go, safe. O(n). initLast :: [a] -> Maybe ([a], a) -- | init and last of non-empty list, safe. O(n). -- initLast1 a as = (init (a:as), last (a:as) initLast1 :: a -> [a] -> ([a], a) -- | init of non-empty list, safe. O(n). init1 a as = init -- (a:as) init1 :: a -> [a] -> [a] -- | init, safe. O(n). initMaybe :: [a] -> Maybe [a] -- | init, safe. O(n). initWithDefault :: [a] -> [a] -> [a] -- | Lookup function (safe). O(min n index). (!!!) :: [a] -> Int -> Maybe a -- | A variant of !! that might provide more informative error -- messages if the index is out of bounds. -- -- Precondition: The index should not be out of bounds. (!!) :: HasCallStack => [a] -> Int -> a -- | Lookup function with default value for index out of range. O(min n -- index). -- -- The name is chosen akin to genericIndex. indexWithDefault :: a -> [a] -> Int -> a -- | Find an element satisfying a predicate and return it with its index. -- O(n) in the worst case, e.g. findWithIndex f xs = Nothing. -- -- TODO: more efficient implementation!? findWithIndex :: (a -> Bool) -> [a] -> Maybe (a, Int) -- | A generalised variant of elemIndex. O(n). genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i -- | downFrom n = [n-1,..1,0]. O(n). downFrom :: Integral a => a -> [a] -- | Update the first element of a list, if it exists. O(1). updateHead :: (a -> a) -> [a] -> [a] -- | Update the last element of a list, if it exists. O(n). updateLast :: (a -> a) -> [a] -> [a] -- | Update nth element of a list, if it exists. O(min index n). -- -- Precondition: the index is >= 0. updateAt :: Int -> (a -> a) -> [a] -> [a] type Prefix a = [a] " The list before the split point." type Suffix a = [a] " The list after the split point." -- | splitExactlyAt n xs = Just (ys, zs) iff xs = ys ++ -- zs and genericLength ys = n. splitExactlyAt :: Integral n => n -> [a] -> Maybe (Prefix a, Suffix a) -- | Drop from the end of a list. O(length). -- --
--   dropEnd n = reverse . drop n . reverse
--   
-- -- Forces the whole list even for n==0. dropEnd :: forall a. Int -> [a] -> Prefix a -- | Split off the largest suffix whose elements satisfy a predicate. O(n). -- -- spanEnd p xs = (ys, zs) where xs = ys ++ zs and -- all p zs and maybe True (not . p) (lastMaybe yz). spanEnd :: forall a. (a -> Bool) -> [a] -> (Prefix a, Suffix a) -- | Breaks a list just after an element satisfying the predicate is -- found. -- --
--   >>> breakAfter1 even 1 [3,5,2,4,7,8]
--   ([1,3,5,2],[4,7,8])
--   
breakAfter1 :: (a -> Bool) -> a -> [a] -> (List1 a, [a]) -- | Breaks a list just after an element satisfying the predicate is -- found. -- --
--   >>> breakAfter even [1,3,5,2,4,7,8]
--   ([1,3,5,2],[4,7,8])
--   
breakAfter :: (a -> Bool) -> [a] -> ([a], [a]) -- | A generalized version of takeWhile. (Cf. mapMaybe -- vs. filter). @O(length . takeWhileJust f). -- -- takeWhileJust f = fst . spanJust f. takeWhileJust :: (a -> Maybe b) -> [a] -> Prefix b -- | A generalized version of span. O(length . fst . spanJust -- f). spanJust :: (a -> Maybe b) -> [a] -> (Prefix b, Suffix a) -- | Partition a list into Nothings and Justs. O(n). -- --
--   partitionMaybe f = partitionEithers . map ( a -> maybe (Left a) Right (f a))
--   
-- -- Note: mapMaybe f = snd . partitionMaybe f. partitionMaybe :: (a -> Maybe b) -> [a] -> ([a], [b]) -- | Like filter, but additionally return the last partition of the -- list where the predicate is False everywhere. O(n). filterAndRest :: (a -> Bool) -> [a] -> ([a], Suffix a) -- | Like mapMaybe, but additionally return the last partition of -- the list where the function always returns Nothing. O(n). mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b], Suffix a) -- | Sublist relation. isSublistOf :: Eq a => [a] -> [a] -> Bool -- | All ways of removing one element from a list. O(n²). holes :: [a] -> [(a, [a])] -- | Compute the common prefix of two lists. O(min n m). commonPrefix :: Eq a => [a] -> [a] -> Prefix a -- | Drops from both lists simultaneously until one list is empty. O(min n -- m). dropCommon :: [a] -> [b] -> (Suffix a, Suffix b) -- | Check if a list has a given prefix. If so, return the list minus the -- prefix. O(length prefix). stripPrefixBy :: (a -> a -> Bool) -> Prefix a -> [a] -> Maybe (Suffix a) -- | Compute the common suffix of two lists. O(n + m). commonSuffix :: Eq a => [a] -> [a] -> Suffix a -- | stripSuffix suf xs = Just pre iff xs = pre ++ suf. -- O(n). stripSuffix :: Eq a => Suffix a -> [a] -> Maybe (Prefix a) type ReversedSuffix a = [a] -- | stripReversedSuffix rsuf xs = Just pre iff xs = pre ++ -- reverse suf. O(n). stripReversedSuffix :: forall a. Eq a => ReversedSuffix a -> [a] -> Maybe (Prefix a) -- | Internal state for stripping suffix. data StrSufSt a -- | Error. SSSMismatch :: StrSufSt a -- | "Negative string" to remove from end. List may be empty. SSSStrip :: ReversedSuffix a -> StrSufSt a -- | "Positive string" (result). Non-empty list. SSSResult :: [a] -> StrSufSt a -- | Returns a list with one boolean for each non-empty suffix of the list, -- starting with the longest suffix (the entire list). Each boolean is -- True exactly when every element in the corresponding suffix -- satisfies the predicate. -- -- An example: suffixesSatisfying isLower AbCde -- = [False, False, False, True, True] -- -- For total predicates p and finite and total lists xs -- the following holds: suffixesSatisfying p xs = map -- (all p) (init (tails xs)) suffixesSatisfying :: (a -> Bool) -> [a] -> [Bool] -- | Find the longest suffix of the first string xs that is a -- prefix of the second string ys. So, basically, find the -- overlap where the strings can be glued together. Returns the index -- where the overlap starts and the length of the overlap. The length of -- the overlap plus the index is the length of the first string. Note -- that in the worst case, the empty overlap (length xs,0) is -- returned. -- -- Worst-case time complexity is quadratic: O(min(n,m)²) where -- n = length xs and m = length ys. -- -- There might be asymptotically better implementations following -- Knuth-Morris-Pratt (KMP), but for rather short lists this is good -- enough. findOverlap :: forall a. Eq a => [a] -> [a] -> (Int, Int) -- | groupOn f = groupBy ((==) `on` f) . -- sortBy (compare `on` f). O(n log n). groupOn :: Ord b => (a -> b) -> [a] -> [[a]] -- | A variant of groupBy which applies the predicate to consecutive -- pairs. O(n). DEPRECATED in favor of groupBy'. groupBy' :: (a -> a -> Bool) -> [a] -> [[a]] -- | Chop up a list in chunks of a given length. O(n). chop :: Int -> [a] -> [[a]] -- | Chop a list at the positions when the predicate holds. Contrary to -- wordsBy, consecutive separator elements will result in an -- empty segment in the result. O(n). -- --
--   intercalate [x] (chopWhen (== x) xs) == xs
--   
chopWhen :: forall a. (a -> Bool) -> [a] -> [[a]] -- | Check membership for the same list often. Use partially applied to -- create membership predicate hasElem xs :: a -> Bool. -- -- -- -- Specification: hasElem xs == (elem xs). hasElem :: Ord a => [a] -> a -> Bool -- | Check whether a list is sorted. O(n). -- -- Assumes that the Ord instance implements a partial order. sorted :: Ord a => [a] -> Bool -- | Check whether all elements in a list are distinct from each other. -- Assumes that the Eq instance stands for an equivalence -- relation. -- -- O(n²) in the worst case distinct xs == True. distinct :: Eq a => [a] -> Bool -- | An optimised version of distinct. O(n log n). -- -- Precondition: The list's length must fit in an Int. fastDistinct :: Ord a => [a] -> Bool -- | Returns an (arbitrary) representative for each list element that -- occurs more than once. O(n log n). duplicates :: Ord a => [a] -> [a] -- | Remove the first representative for each list element. Thus, returns -- all duplicate copies. O(n log n). -- -- allDuplicates xs == sort $ xs \ nub xs. allDuplicates :: Ord a => [a] -> [a] -- | Partition a list into first and later occurrences of elements (modulo -- some quotient given by a representation function). -- -- Time: O(n log n). -- -- Specification: -- --
--   nubAndDuplicatesOn f xs = (ys, xs List.\\ ys)
--     where ys = nubOn f xs
--   
nubAndDuplicatesOn :: Ord b => (a -> b) -> [a] -> ([a], [a]) -- | Efficient variant of nubBy for lists, using a set to store -- already seen elements. O(n log n) -- -- Specification: -- --
--   nubOn f xs == 'nubBy' ((==) `'on'` f) xs.
--   
nubOn :: Ord b => (a -> b) -> [a] -> [a] -- | A variant of nubOn that is parametrised by a function that is -- used to select which element from a group of equal elements that is -- returned. The returned elements keep the order that they had in the -- input list. -- -- Precondition: The length of the input list must be at most -- maxBound :: Int. nubFavouriteOn :: forall a b c. (Ord b, Eq c, Hashable c) => (a -> b) -> (a -> c) -> [a] -> [a] -- | Efficient variant of nubBy for finite lists. O(n log n). -- --
--   uniqOn f == 'List.sortBy' (compare `'on'` f) . 'nubBy' ((==) `'on'` f)
--   
-- -- If there are several elements with the same f-representative, -- the first of these is kept. uniqOn :: Ord b => (a -> b) -> [a] -> [a] -- | Checks if all the elements in the list are equal. Assumes that the -- Eq instance stands for an equivalence relation. O(n). allEqual :: Eq a => [a] -> Bool -- | Non-efficient, monadic nub. O(n²). nubM :: Monad m => (a -> a -> m Bool) -> [a] -> m [a] -- | Requires both lists to have the same length. O(n). -- -- Otherwise, Nothing is returned. zipWith' :: (a -> b -> c) -> [a] -> [b] -> Maybe [c] -- | Like zipWith but keep the rest of the second list as-is (in -- case the second list is longer). O(n). -- --
--   zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs
--   
zipWithKeepRest :: (a -> b -> b) -> [a] -> [b] -> [b] unzipWith :: (a -> (b, c)) -> [a] -> ([b], [c]) -- | Implemented using tree recursion, don't run me at home! O(3^(min n -- m)). editDistanceSpec :: Eq a => [a] -> [a] -> Int -- | Implemented using dynamic programming and Data.Array. O(n*m). editDistance :: forall a. Eq a => [a] -> [a] -> Int mergeStrictlyOrderedBy :: (a -> a -> Bool) -> [a] -> [a] -> Maybe [a] -- | Non-empty lists. -- -- Better name List1 for non-empty lists, plus missing -- functionality. -- -- Import: @ -- -- {-# LANGUAGE PatternSynonyms #-} -- -- import Agda.Utils.List1 (List1, pattern (:|)) import qualified -- Agda.Utils.List1 as List1 -- -- @ module Agda.Utils.List1 type List1 = NonEmpty type String1 = List1 Char -- | Safe version of fromList. fromListSafe :: List1 a -> [a] -> List1 a -- | Return the last element and the rest. initLast :: List1 a -> ([a], a) -- | Build a list with one element. -- -- More precise type for snoc. snoc :: [a] -> a -> List1 a -- | More precise type for groupBy'. -- -- A variant of groupBy which applies the predicate to consecutive -- pairs. O(n). groupBy' :: forall a. (a -> a -> Bool) -> [a] -> [List1 a] -- | Split a list into sublists. Generalisation of the prelude function -- words. Same as wordsBy and wordsBy, but with -- the non-emptyness guarantee on the chunks. O(n). -- --
--   words xs == wordsBy isSpace xs
--   
wordsBy :: (a -> Bool) -> [a] -> [List1 a] -- | Breaks a list just after an element satisfying the predicate is -- found. -- --
--   >>> breakAfter even [1,3,5,2,4,7,8]
--   ([1,3,5,2],[4,7,8])
--   
breakAfter :: (a -> Bool) -> List1 a -> (List1 a, [a]) -- | Concatenate one or more non-empty lists. concat :: [List1 a] -> [a] -- | Like union. Duplicates in the first list are not removed. -- O(nm). union :: Eq a => List1 a -> List1 a -> List1 a ifNull :: [a] -> b -> (List1 a -> b) -> b ifNotNull :: [a] -> (List1 a -> b) -> b -> b unlessNull :: Null m => [a] -> (List1 a -> m) -> m -- | Checks if all the elements in the list are equal. Assumes that the -- Eq instance stands for an equivalence relation. O(n). allEqual :: Eq a => List1 a -> Bool -- | Like catMaybes. catMaybes :: List1 (Maybe a) -> [a] -- | Like filter. mapMaybe :: (a -> Maybe b) -> List1 a -> [b] -- | Like partitionEithers. partitionEithers :: List1 (Either a b) -> ([a], [b]) -- | Like lefts. lefts :: List1 (Either a b) -> [a] -- | Like rights. rights :: List1 (Either a b) -> [b] -- | Non-efficient, monadic nub. O(n²). nubM :: Monad m => (a -> a -> m Bool) -> List1 a -> m (List1 a) -- | Like zipWithM. zipWithM :: Applicative m => (a -> b -> m c) -> List1 a -> List1 b -> m (List1 c) -- | Like zipWithM. zipWithM_ :: Applicative m => (a -> b -> m c) -> List1 a -> List1 b -> m () -- | List foldr but with a base case for the singleton list. foldr :: (a -> b -> b) -> (a -> b) -> List1 a -> b -- | Non-empty (and non-strict) list type. data NonEmpty a (:|) :: a -> [a] -> NonEmpty a infixr 5 :| -- | The zipWith function generalizes zip. Rather than -- tupling the elements, the elements are combined using the function -- passed as the first argument. zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c -- | The zip function takes two streams and returns a stream of -- corresponding pairs. zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) -- | Compute n-ary logic exclusive OR operation on NonEmpty list. xor :: NonEmpty Bool -> Bool -- | The unzip function is the inverse of the zip function. unzip :: Functor f => f (a, b) -> (f a, f b) -- | The unfoldr function is analogous to Data.List's -- unfoldr operation. unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b -- | unfold produces a new stream by repeatedly applying the -- unfolding function to the seed value to produce an element of type -- b and a new seed value. When the unfolding function returns -- Nothing instead of a new seed value, the stream ends. unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b -- | uncons produces the first element of the stream, and a stream -- of the remaining elements, if any. uncons :: NonEmpty a -> (a, Maybe (NonEmpty a)) -- | transpose for NonEmpty, behaves the same as -- transpose The rows/columns need not be the same length, in -- which case > transpose . transpose /= id transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a) -- | takeWhile p xs returns the longest prefix of the -- stream xs for which the predicate p holds. takeWhile :: (a -> Bool) -> NonEmpty a -> [a] -- | take n xs returns the first n elements of -- xs. take :: Int -> NonEmpty a -> [a] -- | The tails function takes a stream xs and returns all -- the suffixes of xs. tails :: Foldable f => f a -> NonEmpty [a] -- | Extract the possibly-empty tail of the stream. tail :: NonEmpty a -> [a] -- | splitAt n xs returns a pair consisting of the prefix -- of xs of length n and the remaining stream -- immediately following this prefix. -- --
--   'splitAt' n xs == ('take' n xs, 'drop' n xs)
--   xs == ys ++ zs where (ys, zs) = 'splitAt' n xs
--   
splitAt :: Int -> NonEmpty a -> ([a], [a]) -- | span p xs returns the longest prefix of xs -- that satisfies p, together with the remainder of the stream. -- --
--   'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)
--   xs == ys ++ zs where (ys, zs) = 'span' p xs
--   
span :: (a -> Bool) -> NonEmpty a -> ([a], [a]) -- | sortWith for NonEmpty, behaves the same as: -- --
--   sortBy . comparing
--   
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a -- | sortBy for NonEmpty, behaves the same as sortBy sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a -- | Sort a stream. sort :: Ord a => NonEmpty a -> NonEmpty a -- | some1 x sequences x one or more times. some1 :: Alternative f => f a -> f (NonEmpty a) -- | Construct a NonEmpty list from a single element. singleton :: a -> NonEmpty a -- | scanr1 is a variant of scanr that has no starting value -- argument. scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a -- | scanr is the right-to-left dual of scanl. Note that -- --
--   head (scanr f z xs) == foldr f z xs.
--   
scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b -- | scanl1 is a variant of scanl that has no starting value -- argument: -- --
--   scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...]
--   
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a -- | scanl is similar to foldl, but returns a stream of -- successive reduced values from the left: -- --
--   scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...]
--   
-- -- Note that -- --
--   last (scanl f z xs) == foldl f z xs.
--   
scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b -- | reverse a finite NonEmpty stream. reverse :: NonEmpty a -> NonEmpty a -- | repeat x returns a constant stream, where all elements -- are equal to x. repeat :: a -> NonEmpty a -- | Attach a list at the beginning of a NonEmpty. -- --
--   >>> prependList [] (1 :| [2,3])
--   1 :| [2,3]
--   
-- --
--   >>> prependList [negate 1, 0] (1 :| [2, 3])
--   -1 :| [0,1,2,3]
--   
prependList :: [a] -> NonEmpty a -> NonEmpty a -- | The partition function takes a predicate p and a -- stream xs, and returns a pair of lists. The first list -- corresponds to the elements of xs for which p holds; -- the second corresponds to the elements of xs for which -- p does not hold. -- --
--   'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)
--   
partition :: (a -> Bool) -> NonEmpty a -> ([a], [a]) -- | The nubBy function behaves just like nub, except it uses -- a user-supplied equality predicate instead of the overloaded == -- function. nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a -- | The nub function removes duplicate elements from a list. In -- particular, it keeps only the first occurrence of each element. (The -- name nub means 'essence'.) It is a special case of -- nubBy, which allows the programmer to supply their own -- inequality test. nub :: Eq a => NonEmpty a -> NonEmpty a -- | nonEmpty efficiently turns a normal list into a NonEmpty -- stream, producing Nothing if the input is empty. nonEmpty :: [a] -> Maybe (NonEmpty a) -- | Map a function over a NonEmpty stream. map :: (a -> b) -> NonEmpty a -> NonEmpty b -- | Number of elements in NonEmpty list. length :: NonEmpty a -> Int -- | Extract the last element of the stream. last :: NonEmpty a -> a -- | iterate f x produces the infinite sequence of repeated -- applications of f to x. -- --
--   iterate f x = x :| [f x, f (f x), ..]
--   
iterate :: (a -> a) -> a -> NonEmpty a -- | The isPrefixOf function returns True if the first -- argument is a prefix of the second. isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool -- | 'intersperse x xs' alternates elements of the list with copies of -- x. -- --
--   intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]
--   
intersperse :: a -> NonEmpty a -> NonEmpty a -- | insert x xs inserts x into the last position -- in xs where it is still less than or equal to the next -- element. In particular, if the list is sorted beforehand, the result -- will also be sorted. insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a -- | The inits function takes a stream xs and returns all -- the finite prefixes of xs. inits :: Foldable f => f a -> NonEmpty [a] -- | Extract everything except the last element of the stream. init :: NonEmpty a -> [a] -- | Extract the first element of the stream. head :: NonEmpty a -> a -- | groupWith1 is to group1 as groupWith is to -- group groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) -- | groupWith operates like group, but uses the provided -- projection when comparing for equality groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a] -- | groupBy1 is to group1 as groupBy is to -- group. groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a) -- | groupBy operates like group, but uses the provided -- equality predicate instead of ==. groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a] -- | groupAllWith1 is to groupWith1 as groupAllWith is -- to groupWith groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) -- | groupAllWith operates like groupWith, but sorts the list -- first so that each equivalence class has, at most, one list in the -- output groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a] -- | group1 operates like group, but uses the knowledge that -- its input is non-empty to produce guaranteed non-empty output. group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a) -- | The group function takes a stream and returns a list of streams -- such that flattening the resulting list is equal to the argument. -- Moreover, each stream in the resulting list contains only equal -- elements. For example, in list notation: -- --
--   'group' $ 'cycle' "Mississippi"
--     = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...
--   
group :: (Foldable f, Eq a) => f a -> [NonEmpty a] -- | filter p xs removes any elements from xs that -- do not satisfy p. filter :: (a -> Bool) -> NonEmpty a -> [a] -- | dropWhile p xs returns the suffix remaining after -- takeWhile p xs. dropWhile :: (a -> Bool) -> NonEmpty a -> [a] -- | drop n xs drops the first n elements off the -- front of the sequence xs. drop :: Int -> NonEmpty a -> [a] -- | cycle xs returns the infinite repetition of -- xs: -- --
--   cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]
--   
cycle :: NonEmpty a -> NonEmpty a -- | Synonym for <|. cons :: a -> NonEmpty a -> NonEmpty a -- | The break p function is equivalent to span -- (not . p). break :: (a -> Bool) -> NonEmpty a -> ([a], [a]) -- | Attach a list at the end of a NonEmpty. -- --
--   >>> appendList (1 :| [2,3]) []
--   1 :| [2,3]
--   
-- --
--   >>> appendList (1 :| [2,3]) [4,5]
--   1 :| [2,3,4,5]
--   
appendList :: NonEmpty a -> [a] -> NonEmpty a -- | A monomorphic version of <> for NonEmpty. -- --
--   >>> append (1 :| []) (2 :| [3])
--   1 :| [2,3]
--   
append :: NonEmpty a -> NonEmpty a -> NonEmpty a -- | Prepend an element to the stream. (<|) :: a -> NonEmpty a -> NonEmpty a infixr 5 <| -- | xs !! n returns the element of the stream xs at -- index n. Note that the head of the stream has index 0. -- -- Beware: a negative or out-of-bounds index will cause an error. (!!) :: NonEmpty a -> Int -> a infixl 9 !! -- | The IsList class and its methods are intended to be used in -- conjunction with the OverloadedLists extension. class IsList l where { -- | The Item type function returns the type of items of the -- structure l. type family Item l; } -- | The fromList function constructs the structure l from -- the given list of Item l fromList :: IsList l => [Item l] -> l -- | The fromListN function takes the input list's length and -- potentially uses it to construct the structure l more -- efficiently compared to fromList. If the given number does not -- equal to the input list's length the behaviour of fromListN is -- not specified. -- --
--   fromListN (length xs) xs == fromList xs
--   
fromListN :: IsList l => Int -> [Item l] -> l -- | The toList function extracts a list of Item l from the -- structure l. It should satisfy fromList . toList = id. toList :: IsList l => l -> [Item l] -- | The Item type function returns the type of items of the -- structure l. type family Item l module Agda.Utils.String -- | quote adds double quotes around the string, replaces newline -- characters with n, and escapes double quotes and backslashes -- within the string. This is different from the behaviour of -- show: -- --
--   > putStrLn $ show "\x2200"
--   "\8704"
--   > putStrLn $ quote "\x2200"
--   "∀"
--   
-- -- (The code examples above have been tested using version 4.2.0.0 of the -- base library.) quote :: String -> String -- | Turns the string into a Haskell string literal, avoiding escape codes. haskellStringLiteral :: String -> String -- | Adds hyphens around the given string -- --
--   >>> putStrLn $ delimiter "Title"
--   ———— Title —————————————————————————————————————————————————
--   
delimiter :: String -> String -- | Adds a final newline if there is not already one. addFinalNewLine :: String -> String -- | Indents every line the given number of steps. indent :: Integral i => i -> String -> String -- | Show a number using comma to separate powers of 1,000. showThousandSep :: Show a => a -> String -- | Remove leading whitespace. ltrim :: String -> String -- | Remove trailing whitespace. rtrim :: String -> String -- | Remove leading and trailing whitesapce. trim :: String -> String instance (Data.String.IsString (m a), GHC.Base.Monad m) => Data.String.IsString (Control.Monad.Trans.Reader.ReaderT r m a) instance (Data.String.IsString (m a), GHC.Base.Monad m) => Data.String.IsString (Control.Monad.Trans.State.Lazy.StateT s m a) -- | Collection size. -- -- For TermSize see Agda.Syntax.Internal. module Agda.Utils.Size -- | The size of a collection (i.e., its length). class Sized a size :: Sized a => a -> Int size :: (Sized a, Foldable t, t b ~ a) => a -> Int -- | Thing decorated with its size. The thing should fit into main memory, -- thus, the size is an Int. data SizedThing a SizedThing :: !Int -> a -> SizedThing a [theSize] :: SizedThing a -> !Int [sizedThing] :: SizedThing a -> a -- | Cache the size of an object. sizeThing :: Sized a => a -> SizedThing a instance Agda.Utils.Size.Sized (Agda.Utils.Size.SizedThing a) instance Agda.Utils.Null.Null a => Agda.Utils.Null.Null (Agda.Utils.Size.SizedThing a) instance Agda.Utils.Size.Sized [a] instance Agda.Utils.Size.Sized (Data.Set.Internal.Set a) instance Agda.Utils.Size.Sized (Data.HashMap.Internal.HashMap k a) instance Agda.Utils.Size.Sized (Data.HashSet.Internal.HashSet a) instance Agda.Utils.Size.Sized (Data.IntMap.Internal.IntMap a) instance Agda.Utils.Size.Sized (Agda.Utils.List1.List1 a) instance Agda.Utils.Size.Sized (Data.Map.Internal.Map k a) instance Agda.Utils.Size.Sized (Data.Sequence.Internal.Seq a) instance Agda.Utils.Size.Sized Data.IntSet.Internal.IntSet module Agda.Utils.Permutation -- | Partial permutations. Examples: -- -- permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] (proper permutation). -- -- permute [1,0] [x0,x1,x2] = [x1,x0] (partial permuation). -- -- permute [1,0,1,2] [x0,x1,x2] = [x1,x0,x1,x2] (not a -- permutation because not invertible). -- -- Agda typing would be: Perm : {m : Nat}(n : Nat) -> Vec (Fin n) -- m -> Permutation m is the size of the -- permutation. data Permutation Perm :: Int -> [Int] -> Permutation [permRange] :: Permutation -> Int [permPicks] :: Permutation -> [Int] -- | permute [1,2,0] [x0,x1,x2] = [x1,x2,x0] More precisely, -- permute indices list = sublist, generates sublist -- from list by picking the elements of list as indicated by -- indices. permute [1,3,0] [x0,x1,x2,x3] = [x1,x3,x0] -- -- Agda typing: permute (Perm {m} n is) : Vec A m -> Vec A n -- -- Precondition for permute (Perm _ is) xs: Every -- index in is must be non-negative and, if xs is -- finite, then every index must also be smaller than the length of -- xs. -- -- The implementation is supposed to be extensionally equal to the -- following one (if different exceptions are identified), but in some -- cases more efficient: permute (Perm _ is) xs = map -- (xs !!) is permute :: Permutation -> [a] -> [a] -- | Invert a Permutation on a partial finite int map. inversePermute -- perm f = f' such that permute perm f' = f -- -- Example, with map represented as [Maybe a]: f = -- [Nothing, Just a, Just b ] perm = Perm 4 [3,0,2] f' = [ Just a , -- Nothing , Just b , Nothing ] Zipping perm with -- f gives [(0,a),(2,b)], after compression with -- catMaybes. This is an IntMap which can easily -- written out into a substitution again. class InversePermute a b inversePermute :: InversePermute a b => Permutation -> a -> b -- | Identity permutation. idP :: Int -> Permutation -- | Restrict a permutation to work on n elements, discarding -- picks >=n. takeP :: Int -> Permutation -> Permutation -- | Pick the elements that are not picked by the permutation. droppedP :: Permutation -> Permutation -- | liftP k takes a Perm {m} n to a Perm {m+k} -- (n+k). Analogous to liftS, but Permutations operate on de -- Bruijn LEVELS, not indices. liftP :: Int -> Permutation -> Permutation -- |
--   permute (compose p1 p2) == permute p1 . permute p2
--   
composeP :: Permutation -> Permutation -> Permutation -- | invertP err p is the inverse of p where defined, -- otherwise defaults to err. composeP p (invertP err p) == -- p invertP :: Int -> Permutation -> Permutation -- | Turn a possible non-surjective permutation into a surjective -- permutation. compactP :: Permutation -> Permutation -- |
--   permute (reverseP p) xs ==
--       reverse $ permute p $ reverse xs
--   
-- -- Example: permute (reverseP (Perm 4 [1,3,0])) [x0,x1,x2,x3] == -- permute (Perm 4 $ map (3-) [0,3,1]) [x0,x1,x2,x3] == permute (Perm 4 -- [3,0,2]) [x0,x1,x2,x3] == [x3,x0,x2] == reverse [x2,x0,x3] == reverse -- $ permute (Perm 4 [1,3,0]) [x3,x2,x1,x0] == reverse $ permute (Perm 4 -- [1,3,0]) $ reverse [x0,x1,x2,x3] -- -- With reverseP, you can convert a permutation on de Bruijn -- indices to one on de Bruijn levels, and vice versa. reverseP :: Permutation -> Permutation -- | permPicks (flipP p) = permute p (downFrom (permRange p)) or -- permute (flipP (Perm n xs)) [0..n-1] = permute (Perm n xs) -- (downFrom n) -- -- Can be use to turn a permutation from (de Bruijn) levels to levels to -- one from levels to indices. -- -- See numberPatVars. flipP :: Permutation -> Permutation -- | expandP i n π in the domain of π replace the -- ith element by n elements. expandP :: Int -> Int -> Permutation -> Permutation -- | Stable topologic sort. The first argument decides whether its first -- argument is an immediate parent to its second argument. topoSort :: (a -> a -> Bool) -> [a] -> Maybe Permutation topoSortM :: Monad m => (a -> a -> m Bool) -> [a] -> m (Maybe Permutation) -- | Delayed dropping which allows undropping. data Drop a Drop :: Int -> a -> Drop a -- | Non-negative number of things to drop. [dropN] :: Drop a -> Int -- | Where to drop from. [dropFrom] :: Drop a -> a -- | Things that support delayed dropping. class DoDrop a doDrop :: DoDrop a => Drop a -> a dropMore :: DoDrop a => Int -> Drop a -> Drop a unDrop :: DoDrop a => Int -> Drop a -> Drop a instance GHC.Generics.Generic Agda.Utils.Permutation.Permutation instance GHC.Classes.Eq Agda.Utils.Permutation.Permutation instance Data.Traversable.Traversable Agda.Utils.Permutation.Drop instance Data.Foldable.Foldable Agda.Utils.Permutation.Drop instance GHC.Base.Functor Agda.Utils.Permutation.Drop instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.Permutation.Drop a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Utils.Permutation.Drop a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.Permutation.Drop a) instance Agda.Utils.Permutation.DoDrop [a] instance Agda.Utils.Permutation.DoDrop Agda.Utils.Permutation.Permutation instance Agda.Utils.Permutation.InversePermute [GHC.Maybe.Maybe a] [(GHC.Types.Int, a)] instance Agda.Utils.Permutation.InversePermute [GHC.Maybe.Maybe a] (Data.IntMap.Internal.IntMap a) instance Agda.Utils.Permutation.InversePermute [GHC.Maybe.Maybe a] [GHC.Maybe.Maybe a] instance Agda.Utils.Permutation.InversePermute (GHC.Types.Int -> a) [GHC.Maybe.Maybe a] instance GHC.Show.Show Agda.Utils.Permutation.Permutation instance Agda.Utils.Size.Sized Agda.Utils.Permutation.Permutation instance Agda.Utils.Null.Null Agda.Utils.Permutation.Permutation instance Control.DeepSeq.NFData Agda.Utils.Permutation.Permutation -- | Lists of length at least 2. -- -- Import as: import Agda.Utils.List2 (List2(List2)) import -- qualified Agda.Utils.List2 as List2 module Agda.Utils.List2 -- | Lists of length ≥2. data List2 a List2 :: a -> a -> [a] -> List2 a -- | Unsafe! O(1). fromList1 :: List1 a -> List2 a -- | Safe. O(1). toList1 :: List2 a -> List1 a -- | Safe. O(1). fromListMaybe :: [a] -> Maybe (List2 a) -- | Safe. O(1). fromList1Maybe :: List1 a -> Maybe (List2 a) -- | Any List1 is either a singleton or a List2. O(1). fromList1Either :: List1 a -> Either a (List2 a) -- | Inverse of fromList1Either. O(1). toList1Either :: Either a (List2 a) -> List1 a -- | O(1). cons :: a -> List1 a -> List2 a -- | O(length first list). append :: List1 a -> List1 a -> List2 a -- | O(length first list). appendList :: List2 a -> [a] -> List2 a -- | Safe. O(1). head :: List2 a -> a -- | Safe. O(1). tail :: List2 a -> List1 a -- | Safe. O(n). init :: List2 a -> List1 a break :: (a -> Bool) -> List2 a -> ([a], [a]) -- | The toList function extracts a list of Item l from the -- structure l. It should satisfy fromList . toList = id. toList :: IsList l => l -> [Item l] instance Data.Traversable.Traversable Agda.Utils.List2.List2 instance Data.Foldable.Foldable Agda.Utils.List2.List2 instance GHC.Base.Functor Agda.Utils.List2.List2 instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.List2.List2 a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Utils.List2.List2 a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.List2.List2 a) instance GHC.Exts.IsList (Agda.Utils.List2.List2 a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Utils.List2.List2 a) -- | Logically consistent comparison of floating point numbers. module Agda.Utils.Float -- | Return Just x if it's a finite number, otherwise return Nothing. asFinite :: Double -> Maybe Double isPosInf :: Double -> Bool isNegInf :: Double -> Bool isPosZero :: Double -> Bool isNegZero :: Double -> Bool -- | Checks whether or not the Double is within a safe range of operation. isSafeInteger :: Double -> Bool doubleEq :: Double -> Double -> Bool doubleLe :: Double -> Double -> Bool doubleLt :: Double -> Double -> Bool intToDouble :: Integral a => a -> Double doublePlus :: Double -> Double -> Double doubleMinus :: Double -> Double -> Double doubleTimes :: Double -> Double -> Double doubleNegate :: Double -> Double doubleDiv :: Double -> Double -> Double doublePow :: Double -> Double -> Double doubleSqrt :: Double -> Double doubleExp :: Double -> Double doubleLog :: Double -> Double doubleSin :: Double -> Double doubleCos :: Double -> Double doubleTan :: Double -> Double doubleASin :: Double -> Double doubleACos :: Double -> Double doubleATan :: Double -> Double doubleATan2 :: Double -> Double -> Double doubleSinh :: Double -> Double doubleCosh :: Double -> Double doubleTanh :: Double -> Double doubleASinh :: Double -> Double doubleACosh :: Double -> Double doubleATanh :: Double -> Double doubleRound :: Double -> Maybe Integer doubleFloor :: Double -> Maybe Integer doubleCeiling :: Double -> Maybe Integer -- | Denotational equality for floating point numbers, checks bitwise -- equality. -- -- NOTE: Denotational equality distinguishes NaNs, so its results may -- vary depending on the architecture and compilation flags. -- Unfortunately, this is a problem with floating-point numbers in -- general. doubleDenotEq :: Double -> Double -> Bool -- | I guess "denotational orderings" are now a thing? The point is that we -- need an Ord instance which provides a total ordering, and is -- consistent with the denotational equality. -- -- NOTE: The ordering induced via doubleToWord64 is total, and is -- consistent with doubleDenotEq. However, it is *deeply* -- unintuitive. For one, it considers all negative numbers to be larger -- than positive numbers. doubleDenotOrd :: Double -> Double -> Ordering doubleToWord64 :: Double -> Maybe Word64 -- | Decode a Double to an integer ratio. doubleToRatio :: Double -> (Integer, Integer) -- | Encode an integer ratio as a double. ratioToDouble :: Integer -> Integer -> Double -- | Decode a Double to its mantissa and its exponent, normalised such that -- the mantissa is the smallest possible number without loss of accuracy. doubleDecode :: Double -> Maybe (Integer, Integer) -- | Encode a mantissa and an exponent as a Double. doubleEncode :: Integer -> Integer -> Maybe Double -- | Remove suffix .0 from printed floating point number. toStringWithoutDotZero :: Double -> String -- | Pretty printing functions. module Agda.Utils.Pretty -- | While Show is for rendering data in Haskell syntax, -- Pretty is for displaying data to the world, i.e., the user and -- the environment. -- -- Atomic data has no inner document structure, so just implement -- pretty as pretty a = text $ ... a .... class Pretty a pretty :: Pretty a => a -> Doc prettyPrec :: Pretty a => Int -> a -> Doc prettyList :: Pretty a => [a] -> Doc -- | Use instead of show when printing to world. prettyShow :: Pretty a => a -> String sep :: Foldable t => t Doc -> Doc fsep :: Foldable t => t Doc -> Doc hsep :: Foldable t => t Doc -> Doc hcat :: Foldable t => t Doc -> Doc vcat :: Foldable t => t Doc -> Doc punctuate :: Foldable t => Doc -> t Doc -> [Doc] pwords :: String -> [Doc] fwords :: String -> Doc -- | Separate, but only if both separees are not null. hsepWith :: Doc -> Doc -> Doc -> Doc -- | Comma separated list, without the brackets. prettyList_ :: Pretty a => [a] -> Doc -- | Pretty print a set. prettySet :: Pretty a => [a] -> Doc -- | Pretty print an association list. prettyMap :: (Pretty k, Pretty v) => [(k, v)] -> Doc -- | Pretty print a single association. prettyAssign :: (Pretty k, Pretty v) => (k, v) -> Doc -- | Apply parens to Doc if boolean is true. mparens :: Bool -> Doc -> Doc -- | Only wrap in parens if not empty parensNonEmpty :: Doc -> Doc -- | align max rows lays out the elements of rows in two -- columns, with the second components aligned. The alignment column of -- the second components is at most max characters to the right -- of the left-most column. -- -- Precondition: max > 0. align :: Int -> [(String, Doc)] -> Doc -- | Handles strings with newlines properly (preserving indentation) multiLineText :: String -> Doc -- |
--   a ? b = hang a 2 b
--   
() :: Doc -> Doc -> Doc infixl 6 -- |
--   pshow = text . show
--   
pshow :: Show a => a -> Doc singPlural :: Sized a => a -> c -> c -> c -- | Used for with-like telescopes prefixedThings :: Doc -> [Doc] -> Doc -- | The abstract type of documents. A Doc represents a set of -- layouts. A Doc with no occurrences of Union or NoDoc represents just -- one layout. data Doc -- | Some text, but without any width. Use for non-printing text such as a -- HTML or Latex tags zeroWidthText :: String -> Doc -- | A document of height 1 containing a literal string. text -- satisfies the following laws: -- -- -- -- The side condition on the last law is necessary because -- text "" has height 1, while empty has no -- height. text :: String -> Doc space :: Doc -- | Some text with any width. (text s = sizedText (length s) s) sizedText :: Int -> String -> Doc semi :: Doc rparen :: Doc -- | Render the Doc to a String using the given Style. renderStyle :: Style -> Doc -> String -- | Render the Doc to a String using the default Style -- (see style). render :: Doc -> String rbrack :: Doc rbrace :: Doc rational :: Rational -> Doc quotes :: Doc -> Doc -- | Same as text. Used to be used for Bytestrings. ptext :: String -> Doc parens :: Doc -> Doc -- | Nest (or indent) a document by a given number of positions (which may -- also be negative). nest satisfies the laws: -- -- -- -- The side condition on the last law is needed because empty is a -- left identity for <>. nest :: Int -> Doc -> Doc lparen :: Doc lbrack :: Doc lbrace :: Doc -- | Returns True if the document is empty isEmpty :: Doc -> Bool integer :: Integer -> Doc int :: Int -> Doc -- |
--   hang d1 n d2 = sep [d1, nest n d2]
--   
hang :: Doc -> Int -> Doc -> Doc -- | The general rendering interface. Please refer to the Style -- and Mode types for a description of rendering mode, line -- length and ribbons. fullRender :: Mode -> Int -> Float -> (TextDetails -> a -> a) -> a -> Doc -> a float :: Float -> Doc -- | "Paragraph fill" version of cat. fcat :: [Doc] -> Doc equals :: Doc doubleQuotes :: Doc -> Doc double :: Double -> Doc comma :: Doc colon :: Doc -- | A document of height and width 1, containing a literal character. char :: Char -> Doc -- | Either hcat or vcat. cat :: [Doc] -> Doc brackets :: Doc -> Doc braces :: Doc -> Doc -- | Beside, separated by space, unless one of the arguments is -- empty. <+> is associative, with identity -- empty. (<+>) :: Doc -> Doc -> Doc infixl 6 <+> -- | Above, with no overlapping. $+$ is associative, with identity -- empty. ($+$) :: Doc -> Doc -> Doc infixl 5 $+$ -- | Above, except that if the last line of the first argument stops at -- least one position before the first line of the second begins, these -- two lines are overlapped. For example: -- --
--   text "hi" $$ nest 5 (text "there")
--   
-- -- lays out as -- --
--   hi   there
--   
-- -- rather than -- --
--   hi
--        there
--   
-- -- $$ is associative, with identity empty, and also -- satisfies -- -- ($$) :: Doc -> Doc -> Doc infixl 5 $$ -- | A single Char fragment pattern Chr :: () => {-# UNPACK #-} !Char -> TextDetails -- | Used to represent a Fast String fragment but now deprecated and -- identical to the Str constructor. pattern PStr :: () => String -> TextDetails -- | A rendering style. Allows us to specify constraints to choose among -- the many different rendering options. data Style Style :: Mode -> Int -> Float -> Style -- | The rendering mode. [mode] :: Style -> Mode -- | Maximum length of a line, in characters. [lineLength] :: Style -> Int -- | Ratio of line length to ribbon length. A ribbon refers to the -- characters on a line excluding indentation. So a -- lineLength of 100, with a ribbonsPerLine of 2.0 -- would only allow up to 50 characters of ribbon to be displayed on a -- line, while allowing it to be indented up to 50 characters. [ribbonsPerLine] :: Style -> Float -- | Rendering mode. data Mode -- | Normal rendering (lineLength and ribbonsPerLine -- respected'). PageMode :: Mode -- | With zig-zag cuts. ZigZagMode :: Mode -- | No indentation, infinitely long lines (lineLength ignored), but -- explicit new lines, i.e., text "one" $$ text "two", are -- respected. LeftMode :: Mode -- | All on one line, lineLength ignored and explicit new lines -- ($$) are turned into spaces. OneLineMode :: Mode -- | The default style (mode=PageMode, lineLength=100, -- ribbonsPerLine=1.5). style :: Style -- | An associative operation. -- --
--   >>> [1,2,3] <> [4,5,6]
--   [1,2,3,4,5,6]
--   
(<>) :: Semigroup a => a -> a -> a infixr 6 <> instance Agda.Utils.Pretty.Pretty GHC.Types.Bool instance Agda.Utils.Pretty.Pretty GHC.Types.Int instance Agda.Utils.Pretty.Pretty GHC.Int.Int32 instance Agda.Utils.Pretty.Pretty GHC.Num.Integer.Integer instance Agda.Utils.Pretty.Pretty GHC.Word.Word64 instance Agda.Utils.Pretty.Pretty GHC.Types.Double instance Agda.Utils.Pretty.Pretty Data.Text.Internal.Text instance Agda.Utils.Pretty.Pretty GHC.Types.Char instance Agda.Utils.Pretty.Pretty Text.PrettyPrint.HughesPJ.Doc instance Agda.Utils.Pretty.Pretty () instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (GHC.Maybe.Maybe a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty [a] instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Utils.List1.List1 a) instance Agda.Utils.Pretty.Pretty Data.IntSet.Internal.IntSet instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Data.Set.Internal.Set a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Data.IntMap.Internal.IntMap a) instance (Agda.Utils.Pretty.Pretty k, Agda.Utils.Pretty.Pretty v) => Agda.Utils.Pretty.Pretty (Data.Map.Internal.Map k v) -- | Time-related utilities. module Agda.Utils.Time -- | Timestamps. type ClockTime = UTCTime -- | The current time. getClockTime :: IO ClockTime getCPUTime :: MonadIO m => m CPUTime -- | Measure the time of a computation. Of course, does not work with -- exceptions. measureTime :: MonadIO m => m a -> m (a, CPUTime) -- | CPU time in pico (10^-12) seconds. newtype CPUTime CPUTime :: Integer -> CPUTime fromMilliseconds :: Integer -> CPUTime instance Control.DeepSeq.NFData Agda.Utils.Time.CPUTime instance GHC.Real.Integral Agda.Utils.Time.CPUTime instance GHC.Enum.Enum Agda.Utils.Time.CPUTime instance GHC.Real.Real Agda.Utils.Time.CPUTime instance GHC.Num.Num Agda.Utils.Time.CPUTime instance GHC.Classes.Ord Agda.Utils.Time.CPUTime instance GHC.Show.Show Agda.Utils.Time.CPUTime instance GHC.Classes.Eq Agda.Utils.Time.CPUTime instance Agda.Utils.Pretty.Pretty Agda.Utils.Time.CPUTime -- | Parser combinators with support for left recursion, following -- Johnson's "Memoization in Top-Down Parsing". -- -- This implementation is based on an implementation due to Atkey -- (attached to an edlambda-members mailing list message from 2011-02-15 -- titled 'Slides for "Introduction to Parser Combinators"'). -- -- Note that non-memoised left recursion is not guaranteed to work. -- -- The code contains an important deviation from Johnson's paper: the -- check for subsumed results is not included. This means that one can -- get the same result multiple times when parsing using ambiguous -- grammars. As an example, parsing the empty string using S ∷= ε | -- ε succeeds twice. This change also means that parsing fails to -- terminate for some cyclic grammars that would otherwise be handled -- successfully, such as S ∷= S | ε. However, the library is not -- intended to handle infinitely ambiguous grammars. (It is unclear to -- the author of this module whether the change leads to more -- non-termination for grammars that are not cyclic.) module Agda.Utils.Parser.MemoisedCPS class (Functor p, Applicative p, Alternative p, Monad p) => ParserClass p k r tok | p -> k, p -> r, p -> tok -- | Runs the parser. parse :: ParserClass p k r tok => p a -> [tok] -> [a] -- | Tries to print the parser, or returns empty, depending on the -- implementation. This function might not terminate. grammar :: (ParserClass p k r tok, Show k) => p a -> Doc -- | Parses a token satisfying the given predicate. The computed value is -- returned. sat' :: ParserClass p k r tok => (tok -> Maybe a) -> p a -- | Uses the given function to modify the printed representation (if any) -- of the given parser. annotate :: ParserClass p k r tok => (DocP -> DocP) -> p a -> p a -- | Memoises the given parser. -- -- Every memoised parser must be annotated with a unique key. -- (Parametrised parsers must use distinct keys for distinct inputs.) memoise :: (ParserClass p k r tok, Eq k, Hashable k, Show k) => k -> p r -> p r -- | Memoises the given parser, but only if printing, not if parsing. -- -- Every memoised parser must be annotated with a unique key. -- (Parametrised parsers must use distinct keys for distinct inputs.) memoiseIfPrinting :: (ParserClass p k r tok, Eq k, Hashable k, Show k) => k -> p r -> p r -- | Parses a token satisfying the given predicate. sat :: ParserClass p k r tok => (tok -> Bool) -> p tok -- | Parses a single token. token :: ParserClass p k r tok => p tok -- | Parses a given token. tok :: (ParserClass p k r tok, Eq tok, Show tok) => tok -> p tok -- | Uses the given document as the printed representation of the given -- parser. The document's precedence is taken to be atomP. doc :: ParserClass p k r tok => Doc -> p a -> p a -- | Documents paired with precedence levels. type DocP = (Doc, Int) -- | Precedence of >>=. bindP :: Int -- | Precedence of |. choiceP :: Int -- | Precedence of *. seqP :: Int -- | Precedence of and +. starP :: Int -- | Precedence of atoms. atomP :: Int -- | The parser type. -- -- The parameters of the type Parser k r tok a have the -- following meanings: -- -- data Parser k r tok a -- | An extended parser type, with some support for printing parsers. data ParserWithGrammar k r tok a instance GHC.Base.Monad (Agda.Utils.Parser.MemoisedCPS.ParserWithGrammar k r tok) instance GHC.Base.Functor (Agda.Utils.Parser.MemoisedCPS.ParserWithGrammar k r tok) instance GHC.Base.Applicative (Agda.Utils.Parser.MemoisedCPS.ParserWithGrammar k r tok) instance GHC.Base.Alternative (Agda.Utils.Parser.MemoisedCPS.ParserWithGrammar k r tok) instance Agda.Utils.Parser.MemoisedCPS.ParserClass (Agda.Utils.Parser.MemoisedCPS.ParserWithGrammar k r tok) k r tok instance Agda.Utils.Parser.MemoisedCPS.ParserClass (Agda.Utils.Parser.MemoisedCPS.Parser k r tok) k r tok instance GHC.Base.Monad (Agda.Utils.Parser.MemoisedCPS.Parser k r tok) instance GHC.Base.Functor (Agda.Utils.Parser.MemoisedCPS.Parser k r tok) instance GHC.Base.Applicative (Agda.Utils.Parser.MemoisedCPS.Parser k r tok) instance GHC.Base.Alternative (Agda.Utils.Parser.MemoisedCPS.Parser k r tok) module Agda.Utils.CallStack -- | CallStacks are a lightweight method of obtaining a partial -- call-stack at any point in the program. -- -- A function can request its call-site with the HasCallStack -- constraint. For example, we can define -- --
--   putStrLnWithCallStack :: HasCallStack => String -> IO ()
--   
-- -- as a variant of putStrLn that will get its call-site and -- print it, along with the string given as argument. We can access the -- call-stack inside putStrLnWithCallStack with -- callStack. -- --
--   >>> :{
--   putStrLnWithCallStack :: HasCallStack => String -> IO ()
--   putStrLnWithCallStack msg = do
--     putStrLn msg
--     putStrLn (prettyCallStack callStack)
--   :}
--   
-- -- Thus, if we call putStrLnWithCallStack we will get a -- formatted call-stack alongside our string. -- --
--   >>> putStrLnWithCallStack "hello"
--   hello
--   CallStack (from HasCallStack):
--     putStrLnWithCallStack, called at <interactive>:... in interactive:Ghci...
--   
-- -- GHC solves HasCallStack constraints in three steps: -- --
    --
  1. If there is a CallStack in scope -- i.e. the enclosing -- function has a HasCallStack constraint -- GHC will append the -- new call-site to the existing CallStack.
  2. --
  3. If there is no CallStack in scope -- e.g. in the GHCi -- session above -- and the enclosing definition does not have an -- explicit type signature, GHC will infer a HasCallStack -- constraint for the enclosing definition (subject to the monomorphism -- restriction).
  4. --
  5. If there is no CallStack in scope and the enclosing -- definition has an explicit type signature, GHC will solve the -- HasCallStack constraint for the singleton CallStack -- containing just the current call-site.
  6. --
-- -- CallStacks do not interact with the RTS and do not require -- compilation with -prof. On the other hand, as they are built -- up explicitly via the HasCallStack constraints, they will -- generally not contain as much information as the simulated call-stacks -- maintained by the RTS. -- -- A CallStack is a [(String, SrcLoc)]. The -- String is the name of function that was called, the -- SrcLoc is the call-site. The list is ordered with the most -- recently called function at the head. -- -- NOTE: The intrepid user may notice that HasCallStack is just an -- alias for an implicit parameter ?callStack :: CallStack. This -- is an implementation detail and should not be considered part -- of the CallStack API, we may decide to change the -- implementation in the future. data CallStack -- | Return the current CallStack. -- -- Does *not* include the call-site of callStack. callStack :: HasCallStack => CallStack -- | Pretty print a SrcLoc. prettySrcLoc :: SrcLoc -> String -- | A single location in the source code. data SrcLoc SrcLoc :: [Char] -> [Char] -> [Char] -> Int -> Int -> Int -> Int -> SrcLoc [srcLocPackage] :: SrcLoc -> [Char] [srcLocModule] :: SrcLoc -> [Char] [srcLocFile] :: SrcLoc -> [Char] [srcLocStartLine] :: SrcLoc -> Int [srcLocStartCol] :: SrcLoc -> Int [srcLocEndLine] :: SrcLoc -> Int [srcLocEndCol] :: SrcLoc -> Int -- | Request a CallStack. -- -- NOTE: The implicit parameter ?callStack :: CallStack is an -- implementation detail and should not be considered part of the -- CallStack API, we may decide to change the implementation in -- the future. type HasCallStack = ?callStack :: CallStack -- | Extract a list of call-sites from the CallStack. -- -- The list is ordered by most recent call. getCallStack :: CallStack -> [([Char], SrcLoc)] -- | Convert a list of call-sites to a CallStack. fromCallSiteList :: [([Char], SrcLoc)] -> CallStack -- | Type of a filter for CallSite type CallSiteFilter = CallSite -> Bool -- | Type of an entry in a CallStack type CallSite = (SrcFun, SrcLoc) -- | Type of a column of a SrcLoc type SrcLocCol = Int -- | Type of a line number of a SrcLoc type SrcLocLine = Int -- | Type of a filename of a SrcLoc | e.g. -- `srcfullAgdaUtilsFoo.hs` type SrcLocFile = String -- | Type of the name of a function in a CallSite | e.g. -- proveEverything type SrcFun = String -- | Type of the module name of a SrcLoc | e.g. Foo type SrcLocModule = String -- | Type of the package name of a SrcLoc | e.g. `Agda-2.…` type SrcLocPackage = String -- | The same as the un-exported internal function in GHC.Exceptions -- (prettyCallStackLines) Prints like: doFoo, called at -- foo.hs:190:24 in main:Main prettyCallSite :: CallSite -> String -- | Pretty-print a CallStack. This has a few differences from -- GHC.Stack.prettyCallStackLines. We omit the "CallStack (from -- GetCallStack)" header line for brevity. If there is only one entry -- (which is common, due to the manual nature of the -- HasCallStack constraint), shows the entry on one line. If -- there are multiple, then the following lines are indented. prettyCallStack :: CallStack -> String -- | Get the most recent CallSite in a CallStack, if -- there is one. headCallSite :: CallStack -> Maybe CallSite -- | CallStack comprising only the most recent CallSite truncatedCallStack :: CallStack -> CallStack -- | Transform a CallStack by transforming its list of -- CallSite overCallSites :: ([CallSite] -> [CallSite]) -> CallStack -> CallStack -- | Transform a CallStack by filtering each CallSite filterCallStack :: CallSiteFilter -> CallStack -> CallStack -- | Pops n entries off a CallStack using popCallStack. -- Note that frozen callstacks are unaffected. popnCallStack :: Word -> CallStack -> CallStack withNBackCallStack :: HasCallStack => Word -> (CallStack -> b) -> b withCurrentCallStack :: HasCallStack => (CallStack -> b) -> b withCallerCallStack :: HasCallStack => (CallStack -> b) -> b -- | Code for instructing Emacs to do things module Agda.Interaction.EmacsCommand -- | Simple Emacs Lisp expressions. data Lisp a -- | Atom. A :: a -> Lisp a Cons :: Lisp a -> Lisp a -> Lisp a -- | List. L :: [Lisp a] -> Lisp a Q :: Lisp a -> Lisp a -- | Formats a response command. -- -- Replaces 'n' with spaces to ensure that each command is a -- single line. response :: Lisp String -> String -- | Writes a response command to standard output. putResponse :: Lisp String -> IO () display_info' :: Bool -> String -> String -> Lisp String -- | Clear the running info buffer. clearRunningInfo :: Lisp String -- | Clear the warning buffer clearWarning :: Lisp String -- | Display running information about what the type-checker is up to. displayRunningInfo :: String -> Lisp String instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Interaction.EmacsCommand.Lisp a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Interaction.EmacsCommand.Lisp a) -- | Utilities for the Either type. module Agda.Utils.Either -- | Loop while we have an exception. whileLeft :: Monad m => (a -> Either b c) -> (a -> b -> m a) -> (a -> c -> m d) -> a -> m d -- | Monadic version of either with a different argument ordering. caseEitherM :: Monad m => m (Either a b) -> (a -> m c) -> (b -> m c) -> m c -- | 'Either _ b' is a functor. mapLeft :: (a -> c) -> Either a b -> Either c b -- | 'Either a' is a functor. mapRight :: (b -> d) -> Either a b -> Either a d -- | Either is bitraversable. Note: From base >= -- 4.10.0.0 already present in Bitraversable. traverseEither :: Functor f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) -- | Return True if the given value is a Left-value, -- False otherwise. -- --

Examples

-- -- Basic usage: -- --
--   >>> isLeft (Left "foo")
--   True
--   
--   >>> isLeft (Right 3)
--   False
--   
-- -- Assuming a Left value signifies some sort of error, we can use -- isLeft to write a very simple error-reporting function that -- does absolutely nothing in the case of success, and outputs "ERROR" if -- any error occurred. -- -- This example shows how isLeft might be used to avoid pattern -- matching when one does not care about the value contained in the -- constructor: -- --
--   >>> import Control.Monad ( when )
--   
--   >>> let report e = when (isLeft e) $ putStrLn "ERROR"
--   
--   >>> report (Right 1)
--   
--   >>> report (Left "parse error")
--   ERROR
--   
isLeft :: Either a b -> Bool -- | Return True if the given value is a Right-value, -- False otherwise. -- --

Examples

-- -- Basic usage: -- --
--   >>> isRight (Left "foo")
--   False
--   
--   >>> isRight (Right 3)
--   True
--   
-- -- Assuming a Left value signifies some sort of error, we can use -- isRight to write a very simple reporting function that only -- outputs "SUCCESS" when a computation has succeeded. -- -- This example shows how isRight might be used to avoid pattern -- matching when one does not care about the value contained in the -- constructor: -- --
--   >>> import Control.Monad ( when )
--   
--   >>> let report e = when (isRight e) $ putStrLn "SUCCESS"
--   
--   >>> report (Left "parse error")
--   
--   >>> report (Right 1)
--   SUCCESS
--   
isRight :: Either a b -> Bool -- | Analogue of fromMaybe. fromLeft :: (b -> a) -> Either a b -> a -- | Analogue of fromMaybe. fromRight :: (a -> b) -> Either a b -> b -- | Analogue of fromMaybeM. fromLeftM :: Monad m => (b -> m a) -> m (Either a b) -> m a -- | Analogue of fromMaybeM. fromRightM :: Monad m => (a -> m b) -> m (Either a b) -> m b -- | Safe projection from Left. -- --
--   maybeLeft (Left a) = Just a
--   maybeLeft Right{}  = Nothing
--   
maybeLeft :: Either a b -> Maybe a -- | Safe projection from Right. -- --
--   maybeRight (Right b) = Just b
--   maybeRight Left{}    = Nothing
--   
maybeRight :: Either a b -> Maybe b -- | Returns Just input_with_tags_stripped if all elements -- are to the Left, and otherwise Nothing. allLeft :: [Either a b] -> Maybe [a] -- | Returns Just input_with_tags_stripped if all elements -- are to the right, and otherwise Nothing. -- --
--   allRight xs ==
--     if all isRight xs then
--       Just (map ((Right x) -> x) xs)
--      else
--       Nothing
--   
allRight :: [Either a b] -> Maybe [b] -- | Groups a list into alternating chunks of Left and Right -- values groupByEither :: forall a b. [Either a b] -> [Either (List1 a) (List1 b)] -- | Convert Maybe to Either e, given an error -- e for the Nothing case. maybeToEither :: e -> Maybe a -> Either e a -- | Swap tags Left and Right. swapEither :: Either a b -> Either b a module Agda.Utils.Monad -- | Binary bind. (==<<) :: Monad m => (a -> b -> m c) -> (m a, m b) -> m c whenM :: Monad m => m Bool -> m () -> m () unlessM :: Monad m => m Bool -> m () -> m () -- | Monadic guard. guardM :: (Monad m, MonadPlus m) => m Bool -> m () -- | Monadic if-then-else. ifM :: Monad m => m Bool -> m a -> m a -> m a -- |
--   ifNotM mc = ifM (not $ mc)
--   
ifNotM :: Monad m => m Bool -> m a -> m a -> m a -- | Lazy monadic conjunction. and2M :: Monad m => m Bool -> m Bool -> m Bool andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool allM :: (Foldable f, Monad m) => f a -> (a -> m Bool) -> m Bool -- | Lazy monadic disjunction. or2M :: Monad m => m Bool -> m Bool -> m Bool orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool anyM :: (Foldable f, Monad m) => f a -> (a -> m Bool) -> m Bool -- | Lazy monadic disjunction with Either truth values. Returns -- the last error message if all fail. altM1 :: Monad m => (a -> m (Either err b)) -> [a] -> m (Either err b) -- | Lazy monadic disjunction with accumulation of errors in a monoid. -- Errors are discarded if we succeed. orEitherM :: (Monoid e, Monad m, Functor m) => [m (Either e b)] -> m (Either e b) -- | Generalized version of traverse_ :: Applicative m => (a -> m -- ()) -> [a] -> m () Executes effects and collects results in -- left-to-right order. Works best with left-associative monoids. -- -- Note that there is an alternative -- --
--   mapM' f t = foldr mappend mempty $ mapM f t
--   
-- -- that collects results in right-to-left order (effects still -- left-to-right). It might be preferable for right associative monoids. mapM' :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b -- | Generalized version of for_ :: Applicative m => [a] -> (a -- -> m ()) -> m () forM' :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b mapMM :: (Traversable t, Monad m) => (a -> m b) -> m (t a) -> m (t b) forMM :: (Traversable t, Monad m) => m (t a) -> (a -> m b) -> m (t b) mapMM_ :: (Foldable t, Monad m) => (a -> m ()) -> m (t a) -> m () forMM_ :: (Foldable t, Monad m) => m (t a) -> (a -> m ()) -> m () -- | A monadic version of mapMaybe :: (a -> Maybe b) -> -- [a] -> [b]. mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] -- | A version of mapMaybeM with a computation for the -- input list. mapMaybeMM :: Monad m => (a -> m (Maybe b)) -> m [a] -> m [b] -- | The for version of mapMaybeM. forMaybeM :: Monad m => [a] -> (a -> m (Maybe b)) -> m [b] -- | The for version of mapMaybeMM. forMaybeMM :: Monad m => m [a] -> (a -> m (Maybe b)) -> m [b] -- | A monadic version of dropWhile :: (a -> Bool) -> [a] -- -> [a]. dropWhileM :: Monad m => (a -> m Bool) -> [a] -> m [a] -- | A monadic version of dropWhileEnd :: (a -> Bool) -> -- [a] -> m [a]. Effects happen starting at the end of the list -- until p becomes false. dropWhileEndM :: Monad m => (a -> m Bool) -> [a] -> m [a] -- | A `monadic' version of @partition :: (a -> Bool) -- -> [a] -> ([a],[a]) partitionM :: (Functor m, Applicative m) => (a -> m Bool) -> [a] -> m ([a], [a]) -- | Translates Maybe to MonadPlus. fromMaybeMP :: MonadPlus m => Maybe a -> m a -- | Generalises the catMaybes function from lists to an arbitrary -- MonadPlus. catMaybesMP :: MonadPlus m => m (Maybe a) -> m a -- | Branch over elements of a monadic Foldable data structure. scatterMP :: (MonadPlus m, Foldable t) => m (t a) -> m a -- | Finally for the Error class. Errors in the finally part take -- precedence over prior errors. finally :: MonadError e m => m a -> m () -> m a -- | Try a computation, return Nothing if an Error occurs. tryMaybe :: (MonadError e m, Functor m) => m a -> m (Maybe a) -- | Run a command, catch the exception and return it. tryCatch :: (MonadError e m, Functor m) => m () -> m (Maybe e) -- | Like guard, but raise given error when condition fails. guardWithError :: MonadError e m => e -> Bool -> m () -- | Bracket without failure. Typically used to preserve state. bracket_ :: Monad m => m a -> (a -> m ()) -> m b -> m b -- | Restore state after computation. localState :: MonadState s m => m a -> m a embedWriter :: (Monoid w, Monad m) => Writer w a -> WriterT w m a -- | Conditional execution of Applicative expressions. For example, -- --
--   when debug (putStrLn "Debugging")
--   
-- -- will output the string Debugging if the Boolean value -- debug is True, and otherwise do nothing. when :: Applicative f => Bool -> f () -> f () -- | The reverse of when. unless :: Applicative f => Bool -> f () -> f () -- | Monads that also support choice and failure. class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) -- | The identity of mplus. It should also satisfy the equations -- --
--   mzero >>= f  =  mzero
--   v >> mzero   =  mzero
--   
-- -- The default definition is -- --
--   mzero = empty
--   
mzero :: MonadPlus m => m a -- | An associative operation. The default definition is -- --
--   mplus = (<|>)
--   
mplus :: MonadPlus m => m a -> m a -> m a -- | An infix synonym for fmap. -- -- The name of this operator is an allusion to $. Note the -- similarities between their types: -- --
--    ($)  ::              (a -> b) ->   a ->   b
--   (<$>) :: Functor f => (a -> b) -> f a -> f b
--   
-- -- Whereas $ is function application, <$> is function -- application lifted over a Functor. -- --

Examples

-- -- Convert from a Maybe Int to a Maybe -- String using show: -- --
--   >>> show <$> Nothing
--   Nothing
--   
--   >>> show <$> Just 3
--   Just "3"
--   
-- -- Convert from an Either Int Int to an -- Either Int String using show: -- --
--   >>> show <$> Left 17
--   Left 17
--   
--   >>> show <$> Right 17
--   Right "17"
--   
-- -- Double each element of a list: -- --
--   >>> (*2) <$> [1,2,3]
--   [2,4,6]
--   
-- -- Apply even to the second element of a pair: -- --
--   >>> even <$> (2,2)
--   (2,True)
--   
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 <$> -- | Sequential application. -- -- A few functors support an implementation of <*> that is -- more efficient than the default one. -- --

Example

-- -- Used in combination with (<$>), -- (<*>) can be used to build a record. -- --
--   >>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
--   
-- --
--   >>> produceFoo :: Applicative f => f Foo
--   
-- --
--   >>> produceBar :: Applicative f => f Bar
--   
--   >>> produceBaz :: Applicative f => f Baz
--   
-- --
--   >>> mkState :: Applicative f => f MyState
--   
--   >>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
--   
(<*>) :: Applicative f => f (a -> b) -> f a -> f b infixl 4 <*> -- | Replace all locations in the input with the same value. The default -- definition is fmap . const, but this may be -- overridden with a more efficient version. (<$) :: Functor f => a -> f b -> f a infixl 4 <$ -- | ListT done right, see -- https://www.haskell.org/haskellwiki/ListT_done_right_alternative -- -- There is also the list-t package on hackage (Nikita Volkov) -- but it again depends on other packages we do not use yet, so we rather -- implement the few bits we need afresh. module Agda.Utils.ListT -- | Lazy monadic computation of a list of results. newtype ListT m a ListT :: m (Maybe (a, ListT m a)) -> ListT m a [runListT] :: ListT m a -> m (Maybe (a, ListT m a)) -- | Boilerplate function to lift MonadReader through the -- ListT transformer. mapListT :: (m (Maybe (a, ListT m a)) -> n (Maybe (b, ListT n b))) -> ListT m a -> ListT n b -- | Inverse to mapListT. unmapListT :: (ListT m a -> ListT n b) -> m (Maybe (a, ListT m a)) -> n (Maybe (b, ListT n b)) -- | The empty lazy list. nilListT :: Monad m => ListT m a -- | Consing a value to a lazy list. consListT :: Monad m => a -> ListT m a -> ListT m a -- | Singleton lazy list. sgListT :: Monad m => a -> ListT m a -- | Case distinction over lazy list. caseListT :: Monad m => ListT m a -> m b -> (a -> ListT m a -> m b) -> m b -- | Folding a lazy list, effects left-to-right. foldListT :: Monad m => (a -> m b -> m b) -> m b -> ListT m a -> m b -- | Lazy monadic disjunction of lazy monadic list, effects left-to-right anyListT :: Monad m => ListT m a -> (a -> m Bool) -> m Bool -- | Lazy monadic conjunction of lazy monadic list, effects left-to-right allListT :: Monad m => ListT m a -> (a -> m Bool) -> m Bool -- | Force all values in the lazy list, effects left-to-right sequenceListT :: Monad m => ListT m a -> m [a] -- | The join operation of the ListT m monad. concatListT :: Monad m => ListT m (ListT m a) -> ListT m a -- | We can `run' a computation of a ListT as it is monadic -- itself. runMListT :: Monad m => m (ListT m a) -> ListT m a -- | Monadic cons. consMListT :: Monad m => m a -> ListT m a -> ListT m a -- | Monadic singleton. sgMListT :: Monad m => m a -> ListT m a -- | Extending a monadic function to ListT. mapMListT :: Monad m => (a -> m b) -> ListT m a -> ListT m b -- | Alternative implementation using foldListT. mapMListT_alt :: Monad m => (a -> m b) -> ListT m a -> ListT m b -- | Change from one monad to another liftListT :: (Monad m, Monad m') => (forall a. m a -> m' a) -> ListT m a -> ListT m' a instance GHC.Base.Functor m => GHC.Base.Functor (Agda.Utils.ListT.ListT m) instance GHC.Base.Monad m => GHC.Base.Semigroup (Agda.Utils.ListT.ListT m a) instance GHC.Base.Monad m => GHC.Base.Monoid (Agda.Utils.ListT.ListT m a) instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Alternative (Agda.Utils.ListT.ListT m) instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Agda.Utils.ListT.ListT m) instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Agda.Utils.ListT.ListT m) instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Monad (Agda.Utils.ListT.ListT m) instance Control.Monad.Trans.Class.MonadTrans Agda.Utils.ListT.ListT instance (GHC.Base.Applicative m, Control.Monad.IO.Class.MonadIO m) => Control.Monad.IO.Class.MonadIO (Agda.Utils.ListT.ListT m) instance (GHC.Base.Applicative m, Control.Monad.Reader.Class.MonadReader r m) => Control.Monad.Reader.Class.MonadReader r (Agda.Utils.ListT.ListT m) instance (GHC.Base.Applicative m, Control.Monad.State.Class.MonadState s m) => Control.Monad.State.Class.MonadState s (Agda.Utils.ListT.ListT m) instance GHC.Base.Monad m => Control.Monad.Fail.MonadFail (Agda.Utils.ListT.ListT m) -- | Operations on file names. module Agda.Utils.FileName -- | Paths which are known to be absolute. -- -- Note that the Eq and Ord instances do not check if -- different paths point to the same files or directories. newtype AbsolutePath AbsolutePath :: Text -> AbsolutePath -- | Extract the AbsolutePath to be used as FilePath. filePath :: AbsolutePath -> FilePath -- | Constructs AbsolutePaths. -- -- Precondition: The path must be absolute and valid. mkAbsolute :: FilePath -> AbsolutePath -- | Makes the path absolute. -- -- This function may raise an __IMPOSSIBLE__ error if -- canonicalizePath does not return an absolute path. absolute :: FilePath -> IO AbsolutePath -- | Resolve symlinks etc. Preserves sameFile. canonicalizeAbsolutePath :: AbsolutePath -> IO AbsolutePath -- | Tries to establish if the two file paths point to the same file (or -- directory). False negatives may be returned. sameFile :: AbsolutePath -> AbsolutePath -> IO Bool -- | Case-sensitive doesFileExist for Windows. -- -- This is case-sensitive only on the file name part, not on the -- directory part. (Ideally, path components coming from module name -- components should be checked case-sensitively and the other path -- components should be checked case insensitively.) doesFileExistCaseSensitive :: FilePath -> IO Bool -- | True if the first file is newer than the second file. If a file -- doesn't exist it is considered to be infinitely old. isNewerThan :: FilePath -> FilePath -> IO Bool -- | A partial version of makeRelative with flipped arguments, -- returning Nothing if the given path cannot be relativized to -- the given root. relativizeAbsolutePath :: AbsolutePath -> AbsolutePath -> Maybe FilePath instance Control.DeepSeq.NFData Agda.Utils.FileName.AbsolutePath instance Data.Hashable.Class.Hashable Agda.Utils.FileName.AbsolutePath instance GHC.Classes.Ord Agda.Utils.FileName.AbsolutePath instance GHC.Classes.Eq Agda.Utils.FileName.AbsolutePath instance GHC.Show.Show Agda.Utils.FileName.AbsolutePath instance Agda.Utils.Pretty.Pretty Agda.Utils.FileName.AbsolutePath -- | Instead of checking time-stamps we compute a hash of the module source -- and store it in the interface file. This module contains the functions -- to do that. module Agda.Utils.Hash type Hash = Word64 hashByteString :: ByteString -> Hash hashTextFile :: AbsolutePath -> IO Hash -- | Hashes a piece of Text. hashText :: Text -> Hash combineHashes :: [Hash] -> Hash -- | Hashing a module name for unique identifiers. hashString :: String -> Word64 -- | Tools for benchmarking and accumulating results. Nothing Agda-specific -- in here. module Agda.Utils.Benchmark -- | Account we can bill computation time to. type Account a = [a] -- | Record when we started billing the current account. type CurrentAccount a = Maybe (Account a, CPUTime) type Timings a = Trie a CPUTime data BenchmarkOn a BenchmarkOff :: BenchmarkOn a BenchmarkOn :: BenchmarkOn a BenchmarkSome :: (Account a -> Bool) -> BenchmarkOn a isBenchmarkOn :: Account a -> BenchmarkOn a -> Bool -- | Benchmark structure is a trie, mapping accounts (phases and subphases) -- to CPU time spent on their performance. data Benchmark a Benchmark :: !BenchmarkOn a -> !CurrentAccount a -> !Timings a -> Benchmark a -- | Are we benchmarking at all? [benchmarkOn] :: Benchmark a -> !BenchmarkOn a -- | What are we billing to currently? [currentAccount] :: Benchmark a -> !CurrentAccount a -- | The accounts and their accumulated timing bill. [timings] :: Benchmark a -> !Timings a -- | Semantic editor combinator. mapBenchmarkOn :: (BenchmarkOn a -> BenchmarkOn a) -> Benchmark a -> Benchmark a -- | Semantic editor combinator. mapCurrentAccount :: (CurrentAccount a -> CurrentAccount a) -> Benchmark a -> Benchmark a -- | Semantic editor combinator. mapTimings :: (Timings a -> Timings a) -> Benchmark a -> Benchmark a -- | Add to specified CPU time account. addCPUTime :: Ord a => Account a -> CPUTime -> Benchmark a -> Benchmark a -- | Monad with access to benchmarking data. class (Ord (BenchPhase m), Functor m, MonadIO m) => MonadBench m where { type BenchPhase m; } getBenchmark :: MonadBench m => m (Benchmark (BenchPhase m)) putBenchmark :: MonadBench m => Benchmark (BenchPhase m) -> m () modifyBenchmark :: MonadBench m => (Benchmark (BenchPhase m) -> Benchmark (BenchPhase m)) -> m () -- | We need to be able to terminate benchmarking in case of an exception. finally :: MonadBench m => m b -> m c -> m b getsBenchmark :: MonadBench m => (Benchmark (BenchPhase m) -> c) -> m c -- | Turn benchmarking on/off. setBenchmarking :: MonadBench m => BenchmarkOn (BenchPhase m) -> m () -- | Bill current account with time up to now. Switch to new account. -- Return old account (if any). switchBenchmarking :: MonadBench m => Maybe (Account (BenchPhase m)) -> m (Maybe (Account (BenchPhase m))) -- | Resets the account and the timing information. reset :: MonadBench m => m () -- | Bill a computation to a specific account. Works even if the -- computation is aborted by an exception. billTo :: MonadBench m => Account (BenchPhase m) -> m c -> m c -- | Bill a CPS function to an account. Can't handle exceptions. billToCPS :: MonadBench m => Account (BenchPhase m) -> ((b -> m c) -> m c) -> (b -> m c) -> m c -- | Bill a pure computation to a specific account. billPureTo :: MonadBench m => Account (BenchPhase m) -> c -> m c instance GHC.Generics.Generic (Agda.Utils.Benchmark.BenchmarkOn a) instance GHC.Generics.Generic (Agda.Utils.Benchmark.Benchmark a) instance Agda.Utils.Benchmark.MonadBench m => Agda.Utils.Benchmark.MonadBench (Control.Monad.Trans.Reader.ReaderT r m) instance (Agda.Utils.Benchmark.MonadBench m, GHC.Base.Monoid w) => Agda.Utils.Benchmark.MonadBench (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.Utils.Benchmark.MonadBench m => Agda.Utils.Benchmark.MonadBench (Control.Monad.Trans.State.Lazy.StateT r m) instance Agda.Utils.Benchmark.MonadBench m => Agda.Utils.Benchmark.MonadBench (Control.Monad.Trans.Except.ExceptT e m) instance Agda.Utils.Benchmark.MonadBench m => Agda.Utils.Benchmark.MonadBench (Agda.Utils.ListT.ListT m) instance Agda.Utils.Null.Null (Agda.Utils.Benchmark.Benchmark a) instance (GHC.Classes.Ord a, Agda.Utils.Pretty.Pretty a) => Agda.Utils.Pretty.Pretty (Agda.Utils.Benchmark.Benchmark a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Utils.Benchmark.Benchmark a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Utils.Benchmark.BenchmarkOn a) -- | Partly invertible finite maps. -- -- Time complexities are given under the assumption that all relevant -- instance functions, as well as arguments of function type, take -- constant time, and "n" is the number of keys involved in the -- operation. module Agda.Utils.BiMap -- | Partial injections from a type to some tag type. -- -- The idea is that tag should be injective on its domain: if -- tag x = tag y = Just i, then x = -- y. However, this property does not need to hold globally. The -- preconditions of the BiMap operations below specify for which -- sets of values tag must be injective. class HasTag a where { type Tag a; } tag :: HasTag a => a -> Maybe (Tag a) -- | Checks if the function tag is injective for the values in the -- given list for which the function is defined. tagInjectiveFor :: (Eq v, Eq (Tag v), HasTag v) => [v] -> Bool -- | Finite maps from k to v, with a way to quickly get -- from v to k for certain values of type v -- (those for which tag is defined). -- -- Every value of this type must satisfy biMapInvariant. data BiMap k v BiMap :: !Map k v -> !Map (Tag v) k -> BiMap k v [biMapThere] :: BiMap k v -> !Map k v [biMapBack] :: BiMap k v -> !Map (Tag v) k -- | The invariant for BiMap. biMapInvariant :: (Eq k, Eq v, Ord (Tag v), HasTag v) => BiMap k v -> Bool -- | Is the value a source key? O(log n). source :: Ord k => k -> BiMap k v -> Bool -- | Is the value a target key? O(log n). target :: Ord (Tag v) => Tag v -> BiMap k v -> Bool -- | Lookup. O(log n). lookup :: Ord k => k -> BiMap k v -> Maybe v -- | Inverse lookup. O(log n). invLookup :: Ord (Tag v) => Tag v -> BiMap k v -> Maybe k -- | Singleton map. O(1). singleton :: HasTag v => k -> v -> BiMap k v -- | Insertion. Overwrites existing values. O(log n). -- -- Precondition: See insertPrecondition. insert :: (Ord k, HasTag v, Ord (Tag v)) => k -> v -> BiMap k v -> BiMap k v -- | The precondition for insert k v m: If v has a -- tag (tag v ≠ Nothing), then m -- must not contain any mapping k' ↦ v' for which k ≠ -- k' and tag v = tag v'. insertPrecondition :: (Eq k, Eq v, Eq (Tag v), HasTag v) => k -> v -> BiMap k v -> Bool -- | Modifies the value at the given position, if any. If the function -- returns Nothing, then the value is removed. O(log n). -- -- The precondition for alterM f k m is that, if the -- value v is inserted into m, and tag -- v is defined, then no key other than k may map to a -- value v' for which tag v' = tag v. alterM :: forall k v m. (Ord k, Ord (Tag v), HasTag v, Monad m) => (Maybe v -> m (Maybe v)) -> k -> BiMap k v -> m (BiMap k v) -- | Modifies the value at the given position, if any. If the function -- returns Nothing, then the value is removed. O(log n). -- -- Precondition: See alterPrecondition. alter :: forall k v. (Ord k, Ord (Tag v), HasTag v) => (Maybe v -> Maybe v) -> k -> BiMap k v -> BiMap k v -- | The precondition for alter f k m is that, if the value -- v is inserted into m, and tag v is -- defined, then no key other than k may map to a value -- v' for which tag v' = tag v. alterPrecondition :: (Ord k, Eq v, Eq (Tag v), HasTag v) => (Maybe v -> Maybe v) -> k -> BiMap k v -> Bool -- | Modifies the value at the given position, if any. If the function -- returns Nothing, then the value is removed. O(log n). -- -- Precondition: See updatePrecondition. update :: (Ord k, Ord (Tag v), HasTag v) => (v -> Maybe v) -> k -> BiMap k v -> BiMap k v -- | The precondition for update f k m is that, if the -- value v is inserted into m, and tag -- v is defined, then no key other than k may map to a -- value v' for which tag v' = tag v. updatePrecondition :: (Ord k, Eq v, Eq (Tag v), HasTag v) => (v -> Maybe v) -> k -> BiMap k v -> Bool -- | Modifies the value at the given position, if any. O(log n). -- -- Precondition: See adjustPrecondition. adjust :: (Ord k, Ord (Tag v), HasTag v) => (v -> v) -> k -> BiMap k v -> BiMap k v -- | The precondition for adjust f k m is that, if the -- value v is inserted into m, and tag -- v is defined, then no key other than k may map to a -- value v' for which tag v' = tag v. adjustPrecondition :: (Ord k, Eq v, Eq (Tag v), HasTag v) => (v -> v) -> k -> BiMap k v -> Bool -- | Inserts a binding into the map. If a binding for the key already -- exists, then the value obtained by applying the function to the key, -- the new value and the old value is inserted, and the old value is -- returned. -- -- Precondition: See insertLookupWithKeyPrecondition. insertLookupWithKey :: forall k v. (Ord k, Ord (Tag v), HasTag v) => (k -> v -> v -> v) -> k -> v -> BiMap k v -> (Maybe v, BiMap k v) -- | The precondition for insertLookupWithKey f k v m is -- that, if the value v' is inserted into m, and -- tag v' is defined, then no key other than k -- may map to a value v'' for which tag v'' = -- tag v'. insertLookupWithKeyPrecondition :: (Ord k, Eq v, Eq (Tag v), HasTag v) => (k -> v -> v -> v) -> k -> v -> BiMap k v -> Bool -- | Changes all the values using the given function, which is also given -- access to keys. O(n log n). -- -- Precondition: See mapWithKeyPrecondition. mapWithKey :: (Ord k, Ord (Tag v), HasTag v) => (k -> v -> v) -> BiMap k v -> BiMap k v -- | The precondition for mapWithKey f m: For any two -- distinct mappings k₁ ↦ v₁, k₂ ↦ v₂ in m for -- which the tags of f k₁ v₁ and f k₂ v₂ are defined -- the values of f must be distinct (f k₁ v₁ ≠ f k₂ -- v₂). Furthermore tag must be injective for { f k v | -- (k, v) ∈ m }. mapWithKeyPrecondition :: (Eq k, Eq v, Eq (Tag v), HasTag v) => (k -> v -> v) -> BiMap k v -> Bool -- | Changes all the values using the given function, which is also given -- access to keys. O(n). -- -- Precondition: See mapWithKeyFixedTagsPrecondition. Note that -- tags must not change. mapWithKeyFixedTags :: (k -> v -> v) -> BiMap k v -> BiMap k v -- | The precondition for mapWithKeyFixedTags f m is that, -- if m maps k to v, then tag (f k -- v) == tag v. mapWithKeyFixedTagsPrecondition :: (Eq v, Eq (Tag v), HasTag v) => (k -> v -> v) -> BiMap k v -> Bool -- | Left-biased union. For the time complexity, see union. -- -- Precondition: See unionPrecondition. union :: (Ord k, Ord (Tag v)) => BiMap k v -> BiMap k v -> BiMap k v unionPrecondition :: (Ord k, Eq v, Eq (Tag v), HasTag v) => BiMap k v -> BiMap k v -> Bool -- | Conversion from lists of pairs. Later entries take precedence over -- earlier ones. O(n log n). -- -- Precondition: See fromListPrecondition. fromList :: (Ord k, Ord (Tag v), HasTag v) => [(k, v)] -> BiMap k v fromListPrecondition :: (Eq k, Eq v, Eq (Tag v), HasTag v) => [(k, v)] -> Bool -- | Conversion to lists of pairs, with the keys in ascending order. O(n). toList :: BiMap k v -> [(k, v)] -- | The keys, in ascending order. O(n). keys :: BiMap k v -> [k] -- | The values, ordered according to the corresponding keys. O(n). elems :: BiMap k v -> [v] -- | Conversion from two lists that contain distinct keys/tags, with the -- keys/tags in ascending order. O(n). -- -- Precondition: See fromDistinctAscendingListsPrecondition. fromDistinctAscendingLists :: ([(k, v)], [(Tag v, k)]) -> BiMap k v fromDistinctAscendingListsPrecondition :: (Ord k, Eq v, Ord (Tag v), HasTag v) => ([(k, v)], [(Tag v, k)]) -> Bool -- | Generates input suitable for fromDistinctAscendingLists. O(n). toDistinctAscendingLists :: BiMap k v -> ([(k, v)], [(Tag v, k)]) instance GHC.Generics.Generic (Agda.Utils.BiMap.BiMap k v) instance Agda.Utils.Null.Null (Agda.Utils.BiMap.BiMap k v) instance (GHC.Classes.Eq k, GHC.Classes.Eq v) => GHC.Classes.Eq (Agda.Utils.BiMap.BiMap k v) instance (GHC.Classes.Ord k, GHC.Classes.Ord v) => GHC.Classes.Ord (Agda.Utils.BiMap.BiMap k v) instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Agda.Utils.BiMap.BiMap k v) -- | Choice of Unicode or ASCII glyphs. module Agda.Syntax.Concrete.Glyph -- | We want to know whether we are allowed to insert unicode characters or -- not. data UnicodeOrAscii UnicodeOk :: UnicodeOrAscii AsciiOnly :: UnicodeOrAscii unsafeSetUnicodeOrAscii :: UnicodeOrAscii -> IO () -- | Return the glyph set based on a given (unicode or ascii) glyph mode specialCharactersForGlyphs :: UnicodeOrAscii -> SpecialCharacters braces' :: Doc -> Doc dbraces :: Doc -> Doc forallQ :: Doc leftIdiomBrkt :: Doc rightIdiomBrkt :: Doc emptyIdiomBrkt :: Doc arrow :: Doc lambda :: Doc -- | Picking the appropriate set of special characters depending on whether -- we are allowed to use unicode or have to limit ourselves to ascii. data SpecialCharacters SpecialCharacters :: (Doc -> Doc) -> Doc -> Doc -> Doc -> Doc -> Doc -> Doc -> SpecialCharacters [_dbraces] :: SpecialCharacters -> Doc -> Doc [_lambda] :: SpecialCharacters -> Doc [_arrow] :: SpecialCharacters -> Doc [_forallQ] :: SpecialCharacters -> Doc [_leftIdiomBrkt] :: SpecialCharacters -> Doc [_rightIdiomBrkt] :: SpecialCharacters -> Doc [_emptyIdiomBrkt] :: SpecialCharacters -> Doc instance GHC.Generics.Generic Agda.Syntax.Concrete.Glyph.UnicodeOrAscii instance GHC.Enum.Bounded Agda.Syntax.Concrete.Glyph.UnicodeOrAscii instance GHC.Enum.Enum Agda.Syntax.Concrete.Glyph.UnicodeOrAscii instance GHC.Classes.Eq Agda.Syntax.Concrete.Glyph.UnicodeOrAscii instance GHC.Show.Show Agda.Syntax.Concrete.Glyph.UnicodeOrAscii instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Glyph.UnicodeOrAscii -- | This module defines the names of all BUILTINs. module Agda.Syntax.Builtin builtinNat :: String builtinSuc :: String builtinZero :: String builtinNatPlus :: String builtinNatMinus :: String builtinNatTimes :: String builtinNatDivSucAux :: String builtinNatModSucAux :: String builtinNatEquals :: String builtinNatLess :: String builtinInteger :: String builtinIntegerPos :: String builtinIntegerNegSuc :: String builtinWord64 :: 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 builtinMaybe :: String builtinNothing :: String builtinJust :: String builtinPath :: String builtinPathP :: String builtinInterval :: String builtinIZero :: String builtinIOne :: String builtinPartial :: String builtinPartialP :: String builtinIMin :: String builtinIMax :: String builtinINeg :: String builtinIsOne :: String builtinItIsOne :: String builtinIsOne1 :: String builtinIsOne2 :: String builtinIsOneEmpty :: String builtinComp :: String builtinPOr :: String builtinTrans :: String builtinHComp :: String builtinSub :: String builtinSubIn :: String builtinSubOut :: 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 builtinId :: String builtinReflId :: String builtinConId :: String builtinIdElim :: String builtinSizeUniv :: String builtinSize :: String builtinSizeLt :: String builtinSizeSuc :: String builtinSizeInf :: String builtinSizeMax :: String builtinInf :: String builtinSharp :: String builtinFlat :: String builtinEquality :: String builtinRefl :: String builtinRewrite :: String builtinLevelMax :: String builtinLevel :: String builtinLevelZero :: String builtinLevelSuc :: String builtinSet :: String builtinProp :: String builtinSetOmega :: String builtinStrictSet :: String builtinSSetOmega :: String builtinLockUniv :: String builtinIntervalUniv :: String builtinFromNat :: String builtinFromNeg :: String builtinFromString :: String builtinQName :: String builtinAgdaSort :: String builtinAgdaSortSet :: String builtinAgdaSortLit :: String builtinAgdaSortProp :: String builtinAgdaSortPropLit :: String builtinAgdaSortInf :: String builtinAgdaSortUnsupported :: String builtinHiding :: String builtinHidden :: String builtinInstance :: String builtinVisible :: String builtinRelevance :: String builtinRelevant :: String builtinIrrelevant :: String builtinQuantity :: String builtinQuantity0 :: String builtinQuantityω :: String builtinModality :: String builtinModalityConstructor :: String builtinAssoc :: String builtinAssocLeft :: String builtinAssocRight :: String builtinAssocNon :: String builtinPrecedence :: String builtinPrecRelated :: String builtinPrecUnrelated :: String builtinFixity :: String builtinFixityFixity :: String builtinArgInfo :: String builtinArgArgInfo :: String builtinArg :: 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 builtinAgdaErrorPartPatt :: 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 builtinAgdaTCMDeclareData :: String builtinAgdaTCMDefineData :: String builtinAgdaTCMDefineFun :: String builtinAgdaTCMGetType :: String builtinAgdaTCMGetDefinition :: String builtinAgdaTCMQuoteTerm :: String builtinAgdaTCMUnquoteTerm :: String builtinAgdaTCMQuoteOmegaTerm :: String builtinAgdaTCMBlockOnMeta :: String builtinAgdaTCMCommit :: String builtinAgdaTCMIsMacro :: String builtinAgdaTCMFormatErrorParts :: String builtinAgdaTCMDebugPrint :: String builtinAgdaTCMWithNormalisation :: String builtinAgdaTCMWithReconsParams :: String builtinAgdaTCMOnlyReduceDefs :: String builtinAgdaTCMDontReduceDefs :: String builtinAgdaTCMNoConstraints :: String builtinAgdaTCMRunSpeculative :: String builtinAgdaTCMExec :: String builtinAgdaTCMGetInstances :: 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. -- -- {-# BUILTIN TYPE Type #-} -- -- The type of Type would be Type : Level → Setω which -- is not valid Agda. isBuiltinNoDef :: String -> Bool builtinsNoDef :: [String] sizeBuiltins :: [String] module Agda.Interaction.Options.Warnings -- | A WarningMode has two components: a set of warnings to be -- displayed and a flag stating whether warnings should be turned into -- fatal errors. data WarningMode WarningMode :: Set WarningName -> Bool -> WarningMode [_warningSet] :: WarningMode -> Set WarningName [_warn2Error] :: WarningMode -> Bool warningSet :: Lens' (Set WarningName) WarningMode warn2Error :: Lens' Bool WarningMode -- | The defaultWarningMode is a curated set of warnings covering -- non-fatal errors and disabling style-related ones defaultWarningSet :: String allWarnings :: Set WarningName usualWarnings :: Set WarningName noWarnings :: Set WarningName unsolvedWarnings :: Set WarningName incompleteMatchWarnings :: Set WarningName errorWarnings :: Set WarningName defaultWarningMode :: WarningMode -- | Some warnings are errors and cannot be turned off. data WarningModeError Unknown :: String -> WarningModeError NoNoError :: String -> WarningModeError prettyWarningModeError :: WarningModeError -> String -- | warningModeUpdate str computes the action of str -- over the current WarningMode: it may reset the set of -- warnings, add or remove a specific flag or demand that any warning be -- turned into an error warningModeUpdate :: String -> Either WarningModeError WarningModeUpdate -- | Common sets of warnings warningSets :: [(String, (Set WarningName, String))] -- | The WarningName data enumeration is meant to have a -- one-to-one correspondance to existing warnings in the codebase. data WarningName OverlappingTokensWarning_ :: WarningName UnsupportedAttribute_ :: WarningName MultipleAttributes_ :: WarningName LibUnknownField_ :: WarningName EmptyAbstract_ :: WarningName EmptyConstructor_ :: WarningName EmptyField_ :: WarningName EmptyGeneralize_ :: WarningName EmptyInstance_ :: WarningName EmptyMacro_ :: WarningName EmptyMutual_ :: WarningName EmptyPostulate_ :: WarningName EmptyPrimitive_ :: WarningName EmptyPrivate_ :: WarningName EmptyRewritePragma_ :: WarningName EmptyWhere_ :: WarningName HiddenGeneralize_ :: WarningName InvalidCatchallPragma_ :: WarningName InvalidConstructor_ :: WarningName InvalidConstructorBlock_ :: WarningName InvalidCoverageCheckPragma_ :: WarningName InvalidNoPositivityCheckPragma_ :: WarningName InvalidNoUniverseCheckPragma_ :: WarningName InvalidRecordDirective_ :: WarningName InvalidTerminationCheckPragma_ :: WarningName MissingDeclarations_ :: WarningName MissingDefinitions_ :: WarningName NotAllowedInMutual_ :: WarningName OpenPublicAbstract_ :: WarningName OpenPublicPrivate_ :: WarningName PolarityPragmasButNotPostulates_ :: WarningName PragmaCompiled_ :: WarningName PragmaNoTerminationCheck_ :: WarningName ShadowingInTelescope_ :: WarningName UnknownFixityInMixfixDecl_ :: WarningName UnknownNamesInFixityDecl_ :: WarningName UnknownNamesInPolarityPragmas_ :: WarningName UselessAbstract_ :: WarningName UselessInstance_ :: WarningName UselessPrivate_ :: WarningName AbsurdPatternRequiresNoRHS_ :: WarningName AsPatternShadowsConstructorOrPatternSynonym_ :: WarningName CantGeneralizeOverSorts_ :: WarningName ClashesViaRenaming_ :: WarningName CoverageIssue_ :: WarningName CoverageNoExactSplit_ :: WarningName DeprecationWarning_ :: WarningName DuplicateUsing_ :: WarningName FixityInRenamingModule_ :: WarningName GenericNonFatalError_ :: WarningName GenericUseless_ :: WarningName GenericWarning_ :: WarningName IllformedAsClause_ :: WarningName InstanceArgWithExplicitArg_ :: WarningName InstanceWithExplicitArg_ :: WarningName InstanceNoOutputTypeName_ :: WarningName InversionDepthReached_ :: WarningName ModuleDoesntExport_ :: WarningName NoGuardednessFlag_ :: WarningName NotInScope_ :: WarningName NotStrictlyPositive_ :: WarningName UnsupportedIndexedMatch_ :: WarningName OldBuiltin_ :: WarningName PragmaCompileErased_ :: WarningName RewriteMaybeNonConfluent_ :: WarningName RewriteNonConfluent_ :: WarningName RewriteAmbiguousRules_ :: WarningName RewriteMissingRule_ :: WarningName SafeFlagEta_ :: WarningName SafeFlagInjective_ :: WarningName SafeFlagNoCoverageCheck_ :: WarningName SafeFlagNonTerminating_ :: WarningName SafeFlagNoPositivityCheck_ :: WarningName SafeFlagNoUniverseCheck_ :: WarningName SafeFlagPolarity_ :: WarningName SafeFlagPostulate_ :: WarningName SafeFlagPragma_ :: WarningName SafeFlagTerminating_ :: WarningName SafeFlagWithoutKFlagPrimEraseEquality_ :: WarningName TerminationIssue_ :: WarningName UnreachableClauses_ :: WarningName UnsolvedConstraints_ :: WarningName UnsolvedInteractionMetas_ :: WarningName UnsolvedMetaVariables_ :: WarningName UselessHiding_ :: WarningName UselessInline_ :: WarningName UselessPatternDeclarationForRecord_ :: WarningName UselessPublic_ :: WarningName UserWarning_ :: WarningName WithoutKFlagPrimEraseEquality_ :: WarningName WrongInstanceDeclaration_ :: WarningName CoInfectiveImport_ :: WarningName InfectiveImport_ :: WarningName DuplicateFieldsWarning_ :: WarningName TooManyFieldsWarning_ :: WarningName warningName2String :: WarningName -> String -- | The flag corresponding to a warning is precisely the name of the -- constructor minus the trailing underscore. string2WarningName :: String -> Maybe WarningName -- | warningUsage generated using warningNameDescription usageWarning :: String instance GHC.Generics.Generic Agda.Interaction.Options.Warnings.WarningName instance GHC.Enum.Bounded Agda.Interaction.Options.Warnings.WarningName instance GHC.Enum.Enum Agda.Interaction.Options.Warnings.WarningName instance GHC.Read.Read Agda.Interaction.Options.Warnings.WarningName instance GHC.Show.Show Agda.Interaction.Options.Warnings.WarningName instance GHC.Classes.Ord Agda.Interaction.Options.Warnings.WarningName instance GHC.Classes.Eq Agda.Interaction.Options.Warnings.WarningName instance GHC.Generics.Generic Agda.Interaction.Options.Warnings.WarningMode instance GHC.Show.Show Agda.Interaction.Options.Warnings.WarningMode instance GHC.Classes.Eq Agda.Interaction.Options.Warnings.WarningMode instance Control.DeepSeq.NFData Agda.Interaction.Options.Warnings.WarningMode instance Control.DeepSeq.NFData Agda.Interaction.Options.Warnings.WarningName module Agda.Interaction.Options.Help -- | Interface to the help function data Help -- | General usage information GeneralHelp :: Help -- | Specialised usage information about TOPIC HelpFor :: HelpTopic -> Help -- | Usage information generation helpTopicUsage :: HelpTopic -> String -- | Conversion functions to strings string2HelpTopic :: String -> Maybe HelpTopic allHelpTopics :: [(String, HelpTopic)] instance GHC.Generics.Generic Agda.Interaction.Options.Help.HelpTopic instance GHC.Show.Show Agda.Interaction.Options.Help.HelpTopic instance GHC.Classes.Eq Agda.Interaction.Options.Help.HelpTopic instance GHC.Generics.Generic Agda.Interaction.Options.Help.Help instance GHC.Show.Show Agda.Interaction.Options.Help.Help instance GHC.Classes.Eq Agda.Interaction.Options.Help.Help instance Control.DeepSeq.NFData Agda.Interaction.Options.Help.Help instance Control.DeepSeq.NFData Agda.Interaction.Options.Help.HelpTopic -- | Basic data types for library management. module Agda.Interaction.Library.Base -- | A symbolic library name. type LibName = String data LibrariesFile LibrariesFile :: FilePath -> Bool -> LibrariesFile -- | E.g. ~.agdalibraries. [lfPath] :: LibrariesFile -> FilePath -- | The libraries file might not exist, but we may print its assumed -- location in error messages. [lfExists] :: LibrariesFile -> Bool -- | A symbolic executable name. type ExeName = Text data ExecutablesFile ExecutablesFile :: FilePath -> Bool -> ExecutablesFile -- | E.g. ~.agdaexecutables. [efPath] :: ExecutablesFile -> FilePath -- | The executables file might not exist, but we may print its assumed -- location in error messages. [efExists] :: ExecutablesFile -> Bool -- | The special name "." is used to indicated that the current -- directory should count as a project root. libNameForCurrentDir :: LibName -- | A file can either belong to a project located at a given root -- containing one or more .agda-lib files, or be part of the default -- project. data ProjectConfig ProjectConfig :: FilePath -> [FilePath] -> ProjectConfig [configRoot] :: ProjectConfig -> FilePath [configAgdaLibFiles] :: ProjectConfig -> [FilePath] DefaultProjectConfig :: ProjectConfig -- | Content of a .agda-lib file. data AgdaLibFile AgdaLibFile :: LibName -> FilePath -> [FilePath] -> [LibName] -> [String] -> AgdaLibFile -- | The symbolic name of the library. [_libName] :: AgdaLibFile -> LibName -- | Path to this .agda-lib file (not content of the file). [_libFile] :: AgdaLibFile -> FilePath -- | Roots where to look for the modules of the library. [_libIncludes] :: AgdaLibFile -> [FilePath] -- | Dependencies. [_libDepends] :: AgdaLibFile -> [LibName] -- | Default pragma options for all files in the library. [_libPragmas] :: AgdaLibFile -> [String] emptyLibFile :: AgdaLibFile -- | Lenses for AgdaLibFile libName :: Lens' LibName AgdaLibFile libFile :: Lens' FilePath AgdaLibFile libIncludes :: Lens' [FilePath] AgdaLibFile libDepends :: Lens' [LibName] AgdaLibFile libPragmas :: Lens' [String] AgdaLibFile type LineNumber = Int -- | Information about which .agda-lib file we are reading and -- from where in the libraries file it came from. data LibPositionInfo LibPositionInfo :: Maybe FilePath -> LineNumber -> FilePath -> LibPositionInfo -- | Name of libraries file. [libFilePos] :: LibPositionInfo -> Maybe FilePath -- | Line number in libraries file. [lineNumPos] :: LibPositionInfo -> LineNumber -- | Library file. [filePos] :: LibPositionInfo -> FilePath data LibWarning LibWarning :: Maybe LibPositionInfo -> LibWarning' -> LibWarning -- | Library Warnings. data LibWarning' UnknownField :: String -> LibWarning' libraryWarningName :: LibWarning -> WarningName data LibError LibError :: Maybe LibPositionInfo -> LibError' -> LibError -- | Collected errors while processing library files. data LibError' -- | The user specified replacement for the default libraries file -- does not exist. LibrariesFileNotFound :: FilePath -> LibError' -- | Raised when a library name could not successfully be resolved to an -- .agda-lib file. LibNotFound :: LibrariesFile -> LibName -> LibError' -- | Raised when a library name is defined in several .agda-lib -- files. AmbiguousLib :: LibName -> [AgdaLibFile] -> LibError' -- | The .agda-lib file could not be parsed. LibParseError :: LibParseError -> LibError' -- | An I/O Error occurred when reading a file. ReadError :: IOException -> String -> LibError' -- | The executables file contains duplicate entries. DuplicateExecutable :: FilePath -> Text -> List2 FilePath -> LibError' -- | Exceptions thrown by the .agda-lib parser. data LibParseError -- | An invalid library name, e.g., containing spaces. BadLibraryName :: String -> LibParseError -- | I/O error while reading file. ReadFailure :: FilePath -> IOException -> LibParseError -- | Missing these mandatory fields. MissingFields :: List1 String -> LibParseError -- | These fields occur each more than once. DuplicateFields :: List1 String -> LibParseError -- | At the given line number, a field name is missing before the -- :. MissingFieldName :: LineNumber -> LibParseError -- | At the given line number, an invalid field name is encountered before -- the :. (E.g., containing spaces.) BadFieldName :: LineNumber -> String -> LibParseError -- | At the given line number, the given field is not followed by -- :. MissingColonForField :: LineNumber -> String -> LibParseError -- | At the given line number, indented text (content) is not preceded by a -- field. ContentWithoutField :: LineNumber -> LibParseError -- | Collection of LibErrors and LibWarnings. type LibErrWarns = [Either LibError LibWarning] warnings :: MonadWriter LibErrWarns m => List1 LibWarning -> m () warnings' :: MonadWriter LibErrWarns m => List1 LibWarning' -> m () raiseErrors' :: MonadWriter LibErrWarns m => List1 LibError' -> m () raiseErrors :: MonadWriter LibErrWarns m => List1 LibError -> m () -- | Collects LibErrors and LibWarnings. type LibErrorIO = WriterT LibErrWarns (StateT LibState IO) -- | Throws Doc exceptions, still collects LibWarnings. type LibM = ExceptT Doc (WriterT [LibWarning] (StateT LibState IO)) -- | Cache locations of project configurations and parsed -- .agda-lib files. type LibState = (Map FilePath ProjectConfig, Map FilePath AgdaLibFile) getCachedProjectConfig :: (MonadState LibState m, MonadIO m) => FilePath -> m (Maybe ProjectConfig) storeCachedProjectConfig :: (MonadState LibState m, MonadIO m) => FilePath -> ProjectConfig -> m () getCachedAgdaLibFile :: (MonadState LibState m, MonadIO m) => FilePath -> m (Maybe AgdaLibFile) storeCachedAgdaLibFile :: (MonadState LibState m, MonadIO m) => FilePath -> AgdaLibFile -> m () -- | Pretty-print LibError. formatLibError :: [AgdaLibFile] -> LibError -> Doc -- | Does a parse error contain a line number? hasLineNumber :: LibParseError -> Maybe LineNumber -- | Compute a position position prefix. -- -- Depending on the error to be printed, it will -- -- formatLibPositionInfo :: LibPositionInfo -> LibParseError -> Doc prettyInstalledLibraries :: [AgdaLibFile] -> Doc instance GHC.Show.Show Agda.Interaction.Library.Base.LibrariesFile instance GHC.Generics.Generic Agda.Interaction.Library.Base.ExecutablesFile instance GHC.Show.Show Agda.Interaction.Library.Base.ExecutablesFile instance GHC.Generics.Generic Agda.Interaction.Library.Base.ProjectConfig instance GHC.Generics.Generic Agda.Interaction.Library.Base.AgdaLibFile instance GHC.Show.Show Agda.Interaction.Library.Base.AgdaLibFile instance GHC.Generics.Generic Agda.Interaction.Library.Base.LibPositionInfo instance GHC.Show.Show Agda.Interaction.Library.Base.LibPositionInfo instance GHC.Generics.Generic Agda.Interaction.Library.Base.LibWarning' instance GHC.Show.Show Agda.Interaction.Library.Base.LibWarning' instance GHC.Generics.Generic Agda.Interaction.Library.Base.LibWarning instance GHC.Show.Show Agda.Interaction.Library.Base.LibWarning instance Agda.Utils.Pretty.Pretty Agda.Interaction.Library.Base.LibError' instance Agda.Utils.Pretty.Pretty Agda.Interaction.Library.Base.LibParseError instance Agda.Utils.Pretty.Pretty Agda.Interaction.Library.Base.LibWarning instance Control.DeepSeq.NFData Agda.Interaction.Library.Base.LibWarning instance Agda.Utils.Pretty.Pretty Agda.Interaction.Library.Base.LibWarning' instance Control.DeepSeq.NFData Agda.Interaction.Library.Base.LibWarning' instance Control.DeepSeq.NFData Agda.Interaction.Library.Base.LibPositionInfo instance Control.DeepSeq.NFData Agda.Interaction.Library.Base.AgdaLibFile instance Control.DeepSeq.NFData Agda.Interaction.Library.Base.ProjectConfig instance Control.DeepSeq.NFData Agda.Interaction.Library.Base.ExecutablesFile -- | Parser for .agda-lib files. -- -- Example file: -- --
--   name: Main
--   depend:
--     standard-library
--   include: .
--     src more-src
--   
--   
--   
-- -- Should parse as: -- --
--   AgdaLib
--     { libName     = Main
--     , libFile     = path_to_this_file
--     , libIncludes = [ "." , "src" , "more-src" ]
--     , libDepends  = [ "standard-library" ]
--     }
--   
--   
module Agda.Interaction.Library.Parse -- | Parse .agda-lib file. -- -- Sets libFile name and turn mentioned include directories into -- absolute pathes (provided the given FilePath is absolute). parseLibFile :: FilePath -> IO (P AgdaLibFile) -- | Break a comma-separated string. Result strings are trimmed. splitCommas :: String -> [String] -- | Remove leading whitespace and line comment. trimLineComment :: String -> String runP :: P a -> (Either LibParseError a, [LibWarning']) instance GHC.Show.Show Agda.Interaction.Library.Parse.GenericLine -- | Directed graphs (can of course simulate undirected graphs). -- -- Represented as adjacency maps in direction from source to target. -- -- Each source node maps to an adjacency map of outgoing edges, which is -- a map from target nodes to edges. -- -- Listed time complexities are for the worst case (and possibly -- amortised), with n standing for the number of nodes in the -- graph and e standing for the number of edges. Comparisons, -- predicates etc. are assumed to take constant time (unless otherwise -- stated). module Agda.Utils.Graph.AdjacencyMap.Unidirectional -- | Graph n e is a type of directed graphs with nodes in -- n and edges in e. -- -- At most one edge is allowed between any two nodes. Multigraphs can be -- simulated by letting the edge type e be a collection type. -- -- The graphs are represented as adjacency maps (adjacency lists, but -- using finite maps instead of arrays and lists). This makes it possible -- to compute a node's outgoing edges in logarithmic time (O(log -- n)). However, computing the incoming edges may be more expensive. -- -- Note that neither the number of nodes nor the number of edges may -- exceed maxBound :: Int. newtype Graph n e Graph :: Map n (Map n e) -> Graph n e -- | Forward edges. [graph] :: Graph n e -> Map n (Map n e) -- | Internal invariant. invariant :: Ord n => Graph n e -> Bool -- | Edges. data Edge n e Edge :: n -> n -> e -> Edge n e -- | Outgoing node. [source] :: Edge n e -> n -- | Incoming node. [target] :: Edge n e -> n -- | Edge label (weight). [label] :: Edge n e -> e -- | If there is an edge from s to t, then lookup s t -- g is Just e, where e is the edge's -- label. O(log n). lookup :: Ord n => n -> n -> Graph n e -> Maybe e -- | The graph's edges. O(n + e). edges :: Graph n e -> [Edge n e] -- | neighbours u g consists of all nodes v for which -- there is an edge from u to v in g, along -- with the corresponding edge labels. O(log n + |neighbours u -- g|). neighbours :: Ord n => n -> Graph n e -> [(n, e)] -- | neighboursMap u g consists of all nodes v for which -- there is an edge from u to v in g, along -- with the corresponding edge labels. O(log n). neighboursMap :: Ord n => n -> Graph n e -> Map n e -- | edgesFrom g ns is a list containing all edges originating in -- the given nodes (i.e., all outgoing edges for the given nodes). If -- ns does not contain duplicates, then the resulting list does -- not contain duplicates. O(|ns| log |n| + -- |edgesFrom g ns|). edgesFrom :: Ord n => Graph n e -> [n] -> [Edge n e] -- | edgesTo g ns is a list containing all edges ending in the -- given nodes (i.e., all incoming edges for the given nodes). If -- ns does not contain duplicates, then the resulting list does -- not contain duplicates. O(|ns| n log n). edgesTo :: Ord n => Graph n e -> [n] -> [Edge n e] -- | All self-loops. O(n log n). diagonal :: Ord n => Graph n e -> [Edge n e] -- | All nodes. O(n). nodes :: Graph n e -> Set n -- | Nodes with outgoing edges. O(n). sourceNodes :: Graph n e -> Set n -- | Nodes with incoming edges. O(n + e log n). targetNodes :: Ord n => Graph n e -> Set n -- | Nodes without incoming or outgoing edges. O(n + e log n). isolatedNodes :: Ord n => Graph n e -> Set n -- | Various kinds of nodes. data Nodes n Nodes :: Set n -> Set n -> Set n -> Nodes n -- | Nodes with outgoing edges. [srcNodes] :: Nodes n -> Set n -- | Nodes with incoming edges. [tgtNodes] :: Nodes n -> Set n -- | All nodes, with or without edges. [allNodes] :: Nodes n -> Set n -- | Constructs a Nodes structure. O(n + e log n). computeNodes :: Ord n => Graph n e -> Nodes n -- | Checks whether the graph is discrete (containing no edges other than -- null edges). O(n + e). discrete :: Null e => Graph n e -> Bool -- | Returns True iff the graph is acyclic. acyclic :: Ord n => Graph n e -> Bool -- | Constructs a completely disconnected graph containing the given nodes. -- O(n log n). fromNodes :: Ord n => [n] -> Graph n e -- | Constructs a completely disconnected graph containing the given nodes. -- O(n). fromNodeSet :: Ord n => Set n -> Graph n e -- | fromEdges es is a graph containing the edges in es, -- with the caveat that later edges overwrite earlier edges. -- O(|es| log n). fromEdges :: Ord n => [Edge n e] -> Graph n e -- | fromEdgesWith f es is a graph containing the edges in -- es. Later edges are combined with earlier edges using the -- supplied function. O(|es| log n). fromEdgesWith :: Ord n => (e -> e -> e) -> [Edge n e] -> Graph n e -- | Empty graph (no nodes, no edges). O(1). empty :: Graph n e -- | A graph with two nodes and a single connecting edge. O(1). singleton :: Ord n => n -> n -> e -> Graph n e -- | Inserts an edge into the graph. O(log n). insert :: Ord n => n -> n -> e -> Graph n e -> Graph n e -- | insertWith f s t new inserts an edge from s to -- t into the graph. If there is already an edge from s -- to t with label old, then this edge gets replaced by -- an edge with label f new old, and otherwise the edge's label -- is new. O(log n). insertWith :: Ord n => (e -> e -> e) -> n -> n -> e -> Graph n e -> Graph n e -- | Inserts an edge into the graph. O(log n). insertEdge :: Ord n => Edge n e -> Graph n e -> Graph n e -- | A variant of insertWith. O(log n). insertEdgeWith :: Ord n => (e -> e -> e) -> Edge n e -> Graph n e -> Graph n e -- | Left-biased union. -- -- Time complexity: See unionWith. union :: Ord n => Graph n e -> Graph n e -> Graph n e -- | Union. The function is used to combine edge labels for edges that -- occur in both graphs (labels from the first graph are given as the -- first argument to the function). -- -- Time complexity: O(n₁ log (n₂n₁ + 1) + e₁ log e₂), where -- n₁/ is the number of nodes in the graph with the smallest number -- of nodes and n₂ is the number of nodes in the other graph, and -- e₁ is the number of edges in the graph with the smallest number -- of edges and e₂ is the number of edges in the other graph. -- -- Less complicated time complexity: O((n + e) log n (where -- n and e refer to the resulting graph). unionWith :: Ord n => (e -> e -> e) -> Graph n e -> Graph n e -> Graph n e -- | Union. O((n + e) log n (where n and e refer to -- the resulting graph). unions :: Ord n => [Graph n e] -> Graph n e -- | Union. The function is used to combine edge labels for edges that -- occur in several graphs. O((n + e) log n (where n and -- e refer to the resulting graph). unionsWith :: Ord n => (e -> e -> e) -> [Graph n e] -> Graph n e -- | A variant of fmap that provides extra information to the -- function argument. O(n + e). mapWithEdge :: (Edge n e -> e') -> Graph n e -> Graph n e' -- | Reverses an edge. O(1). transposeEdge :: Edge n e -> Edge n e -- | The opposite graph (with all edges reversed). O((n + e) log n). transpose :: Ord n => Graph n e -> Graph n e -- | Removes null edges. O(n + e). clean :: Null e => Graph n e -> Graph n e -- | removeNode n g removes the node n (and all -- corresponding edges) from g. O(n + e). removeNode :: Ord n => n -> Graph n e -> Graph n e -- | removeNodes ns g removes the nodes in ns (and all -- corresponding edges) from g. O((n + e) log -- |ns|). removeNodes :: Ord n => Set n -> Graph n e -> Graph n e -- | removeEdge s t g removes the edge going from s to -- t, if any. O(log n). removeEdge :: Ord n => n -> n -> Graph n e -> Graph n e -- | The graph filterNodes p g contains exactly those nodes from -- g that satisfy the predicate p. Edges to or from -- nodes that are removed are also removed. O(n + e). filterNodes :: Ord n => (n -> Bool) -> Graph n e -> Graph n e -- | Keep only the edges that satisfy the predicate. O(n + e). filterEdges :: (Edge n e -> Bool) -> Graph n e -> Graph n e -- | Removes the nodes that do not satisfy the predicate from the graph, -- but keeps the edges: if there is a path in the original graph between -- two nodes that are retained, then there is a path between these two -- nodes also in the resulting graph. -- -- Precondition: The graph must be acyclic. -- -- Worst-case time complexity: O(e n log n) (this has not been -- verified carefully). filterNodesKeepingEdges :: forall n e. (Ord n, SemiRing e) => (n -> Bool) -> Graph n e -> Graph n e -- | Renames the nodes. -- -- Precondition: The renaming function must be injective. -- -- Time complexity: O((n + e) log n). renameNodes :: Ord n2 => (n1 -> n2) -> Graph n1 e -> Graph n2 e -- | Renames the nodes. -- -- Precondition: The renaming function ren must be strictly -- increasing (if x < y then ren x < ren -- y). -- -- Time complexity: O(n + e). renameNodesMonotonic :: (Ord n1, Ord n2) => (n1 -> n2) -> Graph n1 e -> Graph n2 e -- | WithUniqueInt n consists of pairs of (unique) Ints and -- values of type n. -- -- Values of this type are compared by comparing the Ints. data WithUniqueInt n WithUniqueInt :: !Int -> !n -> WithUniqueInt n [uniqueInt] :: WithUniqueInt n -> !Int [otherValue] :: WithUniqueInt n -> !n -- | Combines each node label with a unique Int. -- -- Precondition: The number of nodes in the graph must not be larger than -- maxBound :: Int. -- -- Time complexity: O(n + e log n). addUniqueInts :: forall n e. Ord n => Graph n e -> Graph (WithUniqueInt n) e -- | Unzips the graph. O(n + e). unzip :: Graph n (e, e') -> (Graph n e, Graph n e') -- | composeWith times plus g g' finds all edges s --c_i--> -- t_i --d_i--> u and constructs the result graph from -- edge(s,u) = sum_i (c_i times d_i). -- -- Complexity: For each edge s --> t in g we look up -- all edges starting with t in g'. -- -- Precondition: The two graphs must have exactly the same nodes. composeWith :: Ord n => (c -> d -> e) -> (e -> e -> e) -> Graph n c -> Graph n d -> Graph n e -- | The graph's strongly connected components, in reverse topological -- order. -- -- The time complexity is likely O(n + e log n) (but this depends -- on the, at the time of writing undocumented, time complexity of -- stronglyConnComp). sccs' :: Ord n => Graph n e -> [SCC n] -- | The graph's strongly connected components, in reverse topological -- order. -- -- The time complexity is likely O(n + e log n) (but this depends -- on the, at the time of writing undocumented, time complexity of -- stronglyConnComp). sccs :: Ord n => Graph n e -> [[n]] -- | SCC DAGs. -- -- The maps map SCC indices to and from SCCs/nodes. data DAG n DAG :: Graph -> IntMap (SCC n) -> Map n Int -> DAG n [dagGraph] :: DAG n -> Graph [dagComponentMap] :: DAG n -> IntMap (SCC n) [dagNodeMap] :: DAG n -> Map n Int -- | DAG invariant. dagInvariant :: Ord n => DAG n -> Bool -- | The opposite DAG. oppositeDAG :: DAG n -> DAG n -- | The nodes reachable from the given SCC. reachable :: Ord n => DAG n -> SCC n -> [n] -- | Constructs a DAG containing the graph's strongly connected components. sccDAG' :: forall n e. Ord n => Graph n e -> [SCC n] -> DAG n -- | Constructs a DAG containing the graph's strongly connected components. sccDAG :: Ord n => Graph n e -> DAG n -- | reachableFrom g n is a map containing all nodes reachable -- from n in g. For each node a simple path to the node -- is given, along with its length (the number of edges). The paths are -- as short as possible (in terms of the number of edges). -- -- Precondition: n must be a node in g. The number of -- nodes in the graph must not be larger than maxBound :: -- Int. -- -- Amortised time complexity (assuming that comparisons take constant -- time): O(e log n), if the lists are not inspected. Inspection -- of a prefix of a list is linear in the length of the prefix. reachableFrom :: Ord n => Graph n e -> n -> Map n (Int, [Edge n e]) -- | reachableFromSet g ns is a set containing all nodes reachable -- from ns in g. -- -- Precondition: Every node in ns must be a node in g. -- The number of nodes in the graph must not be larger than -- maxBound :: Int. -- -- Amortised time complexity (assuming that comparisons take constant -- time): O((|ns| + e) log n). reachableFromSet :: Ord n => Graph n e -> Set n -> Set n -- | walkSatisfying every some g from to determines if there is a -- walk from from to to in g, in which every -- edge satisfies the predicate every, and some edge satisfies -- the predicate some. If there are several such walks, then a -- shortest one (in terms of the number of edges) is returned. -- -- Precondition: from and to must be nodes in -- g. The number of nodes in the graph must not be larger than -- maxBound :: Int. -- -- Amortised time complexity (assuming that comparisons and the -- predicates take constant time to compute): O(n + e log n). walkSatisfying :: Ord n => (Edge n e -> Bool) -> (Edge n e -> Bool) -> Graph n e -> n -> n -> Maybe [Edge n e] -- | Constructs a graph g' with the same nodes as the original -- graph g. In g' there is an edge from n1 to -- n2 if and only if there is a (possibly empty) simple path -- from n1 to n2 in g. In that case the edge -- is labelled with all of the longest (in terms of numbers of edges) -- simple paths from n1 to n2 in g, as well as -- the lengths of these paths. -- -- Precondition: The graph must be acyclic. The number of nodes in the -- graph must not be larger than maxBound :: Int. -- -- Worst-case time complexity (if the paths are not inspected): O(e n -- log n) (this has not been verified carefully). -- -- The algorithm is based on one found on Wikipedia. longestPaths :: forall n e. Ord n => Graph n e -> Graph n (Int, [[Edge n e]]) -- | Computes the transitive closure of the graph. -- -- Uses the Gauss-Jordan-Floyd-Warshall-McNaughton-Yamada algorithm (as -- described by Russell O'Connor in "A Very General Method of Computing -- Shortest Paths" http://r6.ca/blog/20110808T035622Z.html), -- implemented using Graph, and with some shortcuts: -- -- -- -- The graph's strongly connected components (in reverse topological -- order) are returned along with the transitive closure. gaussJordanFloydWarshallMcNaughtonYamada :: forall n e. (Ord n, Eq e, StarSemiRing e) => Graph n e -> (Graph n e, [SCC n]) -- | Computes the transitive closure of the graph. -- -- Uses the Gauss-Jordan-Floyd-Warshall-McNaughton-Yamada algorithm (as -- described by Russell O'Connor in "A Very General Method of Computing -- Shortest Paths" http://r6.ca/blog/20110808T035622Z.html), -- implemented using matrices. -- -- The resulting graph does not contain any zero edges. -- -- This algorithm should be seen as a reference implementation. In -- practice gaussJordanFloydWarshallMcNaughtonYamada is likely to -- be more efficient. gaussJordanFloydWarshallMcNaughtonYamadaReference :: forall n e. (Ord n, Eq e, StarSemiRing e) => Graph n e -> Graph n e -- | The transitive closure. Using -- gaussJordanFloydWarshallMcNaughtonYamada. NOTE: DO NOT USE () -- AS EDGE LABEL SINCE THIS MEANS EVERY EDGE IS CONSIDERED A ZERO EDGE -- AND NO NEW EDGES WILL BE ADDED! Use 'Maybe ()' instead. transitiveClosure :: (Ord n, Eq e, StarSemiRing e) => Graph n e -> Graph n e -- | The transitive reduction of the graph: a graph with the same -- reachability relation as the graph, but with as few edges as possible. -- -- Precondition: The graph must be acyclic. The number of nodes in the -- graph must not be larger than maxBound :: Int. -- -- Worst-case time complexity: O(e n log n) (this has not been -- verified carefully). -- -- The algorithm is based on one found on Wikipedia. transitiveReduction :: Ord n => Graph n e -> Graph n () -- | Transitive closure ported from Agda.Termination.CallGraph. -- -- Relatively efficient, see Issue 1560. complete :: (Eq e, Null e, SemiRing e, Ord n) => Graph n e -> Graph n e -- | Version of complete that produces a list of intermediate -- results paired to the left with a difference that lead to the new -- intermediat result. -- -- The last element in the list is the transitive closure, paired with -- the empty graph. -- --
--   complete g = snd $ last $ completeIter g
--   
completeIter :: (Eq e, Null e, SemiRing e, Ord n) => Graph n e -> [(Graph n e, Graph n e)] instance (GHC.Classes.Eq n, GHC.Classes.Eq e) => GHC.Classes.Eq (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n e) instance (GHC.Show.Show n, GHC.Show.Show e) => GHC.Show.Show (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Edge n e) instance GHC.Base.Functor (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Edge n) instance (GHC.Classes.Ord n, GHC.Classes.Ord e) => GHC.Classes.Ord (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Edge n e) instance (GHC.Classes.Eq n, GHC.Classes.Eq e) => GHC.Classes.Eq (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Edge n e) instance GHC.Base.Functor Agda.Utils.Graph.AdjacencyMap.Unidirectional.WithUniqueInt instance GHC.Show.Show n => GHC.Show.Show (Agda.Utils.Graph.AdjacencyMap.Unidirectional.WithUniqueInt n) instance GHC.Classes.Eq (Agda.Utils.Graph.AdjacencyMap.Unidirectional.WithUniqueInt n) instance GHC.Classes.Ord (Agda.Utils.Graph.AdjacencyMap.Unidirectional.WithUniqueInt n) instance Agda.Utils.Pretty.Pretty n => Agda.Utils.Pretty.Pretty (Agda.Utils.Graph.AdjacencyMap.Unidirectional.WithUniqueInt n) instance (Agda.Utils.Pretty.Pretty n, Agda.Utils.Pretty.Pretty e) => Agda.Utils.Pretty.Pretty (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Edge n e) instance GHC.Base.Functor (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n) instance (GHC.Classes.Ord n, Agda.Utils.Pretty.Pretty n, Agda.Utils.Pretty.Pretty e) => Agda.Utils.Pretty.Pretty (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n e) instance (GHC.Classes.Ord n, GHC.Show.Show n, GHC.Show.Show e) => GHC.Show.Show (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n e) module Agda.Utils.Graph.TopSort -- | topoligical sort with smallest-numbered available vertex first | -- input: nodes, edges | output is Nothing if the graph is not a DAG -- Note: should be stable to preserve order of generalizable variables. -- Algorithm due to Richard Eisenberg, and works by walking over the list -- left-to-right and moving each node the minimum distance left to -- guarantee topological ordering. topSort :: Ord n => Set n -> [(n, n)] -> Maybe [n] -- | Occurrences. module Agda.TypeChecking.Positivity.Occurrence -- | Subterm occurrences for positivity checking. The constructors are -- listed in increasing information they provide: Mixed <= JustPos -- <= StrictPos <= GuardPos <= Unused Mixed <= -- JustNeg <= Unused. data Occurrence -- | Arbitrary occurrence (positive and negative). Mixed :: Occurrence -- | Negative occurrence. JustNeg :: Occurrence -- | Positive occurrence, but not strictly positive. JustPos :: Occurrence -- | Strictly positive occurrence. StrictPos :: Occurrence -- | Guarded strictly positive occurrence (i.e., under ∞). For checking -- recursive records. GuardPos :: Occurrence Unused :: Occurrence -- | Description of an occurrence. data OccursWhere -- | The elements of the sequences, read from left to right, explain how to -- get to the occurrence. The second sequence includes the main -- information, and if the first sequence is non-empty, then it includes -- information about the context of the second sequence. OccursWhere :: Range -> Seq Where -> Seq Where -> OccursWhere -- | One part of the description of an occurrence. data Where LeftOfArrow :: Where -- | in the nth argument of a define constant DefArg :: QName -> Nat -> Where -- | in the principal argument of built-in ∞ UnderInf :: Where -- | as an argument to a bound variable VarArg :: Where -- | as an argument of a metavariable MetaArg :: Where -- | in the type of a constructor ConArgType :: QName -> Where -- | in a datatype index of a constructor IndArgType :: QName -> Where -- | in the nth clause of a defined function InClause :: Nat -> Where -- | matched against in a clause of a defined function Matched :: Where -- | is an index of an inductive family IsIndex :: Where -- | in the definition of a constant InDefOf :: QName -> Where -- | The map contains bindings of the form bound |-> ess, -- satisfying the following property: for every non-empty list -- w, foldr1 otimes w <= bound -- iff or [ all every w && any -- some w | (every, some) <- ess ]. boundToEverySome :: Map Occurrence [(Occurrence -> Bool, Occurrence -> Bool)] -- | productOfEdgesInBoundedWalk occ g u v bound returns a value -- distinct from Nothing iff there is a walk c (a list of -- edges) in g, from u to v, for which the -- product foldr1 otimes (map occ c) -- <= bound. In this case the returned value is -- Just (foldr1 otimes c) for one such walk -- c. -- -- Preconditions: u and v must belong to g, -- and bound must belong to the domain of -- boundToEverySome. productOfEdgesInBoundedWalk :: (SemiRing e, Ord n) => (e -> Occurrence) -> Graph n e -> n -> n -> Occurrence -> Maybe e instance GHC.Generics.Generic Agda.TypeChecking.Positivity.Occurrence.Where instance GHC.Classes.Ord Agda.TypeChecking.Positivity.Occurrence.Where instance GHC.Classes.Eq Agda.TypeChecking.Positivity.Occurrence.Where instance GHC.Show.Show Agda.TypeChecking.Positivity.Occurrence.Where instance GHC.Generics.Generic Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance GHC.Classes.Ord Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance GHC.Classes.Eq Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance GHC.Show.Show Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance GHC.Enum.Bounded Agda.TypeChecking.Positivity.Occurrence.Occurrence instance GHC.Enum.Enum Agda.TypeChecking.Positivity.Occurrence.Occurrence instance GHC.Classes.Ord Agda.TypeChecking.Positivity.Occurrence.Occurrence instance GHC.Classes.Eq Agda.TypeChecking.Positivity.Occurrence.Occurrence instance GHC.Show.Show Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Control.DeepSeq.NFData Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.Utils.SemiRing.SemiRing Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.Utils.SemiRing.StarSemiRing Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.Utils.Null.Null Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Control.DeepSeq.NFData Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance Agda.Utils.Size.Sized Agda.TypeChecking.Positivity.Occurrence.OccursWhere instance Control.DeepSeq.NFData Agda.TypeChecking.Positivity.Occurrence.Where instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Occurrence.Where -- | Position information for syntax. Crucial for giving good error -- messages. module Agda.Syntax.Position type Position = Position' SrcFile type PositionWithoutFile = Position' () -- | Represents a point in the input. -- -- If two positions have the same srcFile and posPos -- components, then the final two components should be the same as well, -- but since this can be hard to enforce the program should not rely too -- much on the last two components; they are mainly there to improve -- error messages for the user. -- -- Note the invariant which positions have to satisfy: -- positionInvariant. data Position' a Pn :: !a -> !Int32 -> !Int32 -> !Int32 -> Position' a -- | File. [srcFile] :: Position' a -> !a -- | Position, counting from 1. [posPos] :: Position' a -> !Int32 -- | Line number, counting from 1. [posLine] :: Position' a -> !Int32 -- | Column number, counting from 1. [posCol] :: Position' a -> !Int32 type SrcFile = Maybe RangeFile -- | File information used in the Position, Interval' and -- Range' types. data RangeFile RangeFile :: !AbsolutePath -> !Maybe TopLevelModuleName -> RangeFile -- | The file's path. [rangeFilePath] :: RangeFile -> !AbsolutePath -- | The file's top-level module name. -- -- This field is optional, but some things may break if the field is not -- instantiated with an actual top-level module name. For instance, the -- Eq and Ord instances only make use of this field. -- -- The field uses Maybe rather than Maybe because it should -- be possible to instantiate it with something that is not yet defined -- (see parseSource). -- -- This TopLevelModuleName should not contain a range. [rangeFileName] :: RangeFile -> !Maybe TopLevelModuleName -- | A smart constructor for RangeFile. mkRangeFile :: AbsolutePath -> Maybe TopLevelModuleName -> RangeFile positionInvariant :: Position' a -> Bool -- | The first position in a file: position 1, line 1, column 1. startPos :: Maybe RangeFile -> Position -- | Advance the position by one character. A newline character -- ('n') moves the position to the first character in the next -- line. Any other character moves the position to the next column. movePos :: Position' a -> Char -> Position' a -- | Advance the position by a string. -- --
--   movePosByString = foldl' movePos
--   
movePosByString :: Foldable t => Position' a -> t Char -> Position' a -- | Backup the position by one character. -- -- Precondition: The character must not be 'n'. backupPos :: Position' a -> Position' a -- | The first position in a file: position 1, line 1, column 1. startPos' :: a -> Position' a type Interval = Interval' SrcFile type IntervalWithoutFile = Interval' () -- | An interval. The iEnd position is not included in the -- interval. -- -- Note the invariant which intervals have to satisfy: -- intervalInvariant. data Interval' a Interval :: !Position' a -> Interval' a [iStart, iEnd] :: Interval' a -> !Position' a intervalInvariant :: Ord a => Interval' a -> Bool -- | Converts a file name and two positions to an interval. posToInterval :: a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a -- | Gets the srcFile component of the interval. Because of the -- invariant, they are both the same. getIntervalFile :: Interval' a -> a -- | The length of an interval. iLength :: Interval' a -> Int32 -- | Finds the least interval which covers the arguments. -- -- Precondition: The intervals must point to the same file. fuseIntervals :: Ord a => Interval' a -> Interval' a -> Interval' a -- | Sets the srcFile components of the interval. setIntervalFile :: a -> Interval' b -> Interval' a type Range = Range' SrcFile -- | A range is a file name, plus a sequence of intervals, assumed to point -- to the given file. The intervals should be consecutive and separated. -- -- Note the invariant which ranges have to satisfy: -- rangeInvariant. data Range' a NoRange :: Range' a Range :: !a -> Seq IntervalWithoutFile -> Range' a -- | Range invariant. rangeInvariant :: Ord a => Range' a -> Bool -- | Are the intervals consecutive and separated, do they all point to the -- same file, and do they satisfy the interval invariant? consecutiveAndSeparated :: Ord a => [Interval' a] -> Bool -- | Turns a file name plus a list of intervals into a range. -- -- Precondition: consecutiveAndSeparated. intervalsToRange :: a -> [IntervalWithoutFile] -> Range' a -- | Converts a file name and an interval to a range. intervalToRange :: a -> IntervalWithoutFile -> Range' a -- | The intervals that make up the range. The intervals are consecutive -- and separated (consecutiveAndSeparated). rangeIntervals :: Range' a -> [IntervalWithoutFile] -- | The file the range is pointing to. rangeFile :: Range -> SrcFile -- | The range's top-level module name, if any. -- -- If there is no range, then Nothing is returned. If there is a -- range without a module name, then Just Nothing -- is returned. rangeModule' :: Range -> Maybe (Maybe TopLevelModuleName) -- | The range's top-level module name, if any. rangeModule :: Range -> Maybe TopLevelModuleName -- | Conflate a range to its right margin. rightMargin :: Range -> Range -- | Ranges between two unknown positions noRange :: Range' a -- | Converts two positions to a range. -- -- Precondition: The positions have to point to the same file. posToRange :: Position' a -> Position' a -> Range' a -- | Converts a file name and two positions to a range. posToRange' :: a -> PositionWithoutFile -> PositionWithoutFile -> Range' a -- | The initial position in the range, if any. rStart :: Range' a -> Maybe (Position' a) -- | The initial position in the range, if any. rStart' :: Range' a -> Maybe PositionWithoutFile -- | The position after the final position in the range, if any. rEnd :: Range' a -> Maybe (Position' a) -- | The position after the final position in the range, if any. rEnd' :: Range' a -> Maybe PositionWithoutFile -- | Converts a range to an interval, if possible. Note that the -- information about the source file is lost. rangeToInterval :: Range' a -> Maybe IntervalWithoutFile -- | Converts a range to an interval, if possible. rangeToIntervalWithFile :: Range' a -> Maybe (Interval' a) -- | Returns the shortest continuous range containing the given one. continuous :: Range' a -> Range' a -- | Removes gaps between intervals on the same line. continuousPerLine :: Ord a => Range' a -> Range' a -- | Wrapper to indicate that range should be printed. newtype PrintRange a PrintRange :: a -> PrintRange a -- | Things that have a range are instances of this class. class HasRange a getRange :: HasRange a => a -> Range getRange :: (HasRange a, Foldable t, HasRange b, t b ~ a) => a -> Range -- | If it is also possible to set the range, this is the class. -- -- Instances should satisfy getRange (setRange r x) == -- r. class HasRange a => SetRange a setRange :: SetRange a => Range -> a -> a setRange :: (SetRange a, Functor f, SetRange b, f b ~ a) => Range -> a -> a -- | Killing the range of an object sets all range information to -- noRange. class KillRange a killRange :: KillRange a => KillRangeT a killRange :: (KillRange a, Functor f, KillRange b, f b ~ a) => KillRangeT a type KillRangeT a = a -> a -- | Remove ranges in keys and values of a map. killRangeMap :: (KillRange k, KillRange v) => KillRangeT (Map k v) killRange1 :: KillRange a => (a -> b) -> a -> b killRange2 :: (KillRange a, KillRange b) => (a -> b -> c) -> a -> b -> c killRange3 :: (KillRange a, KillRange b, KillRange c) => (a -> b -> c -> d) -> a -> b -> c -> d killRange4 :: (KillRange a, KillRange b, KillRange c, KillRange d) => (a -> b -> c -> d -> e) -> a -> b -> c -> d -> e killRange5 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e) => (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f killRange6 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f) => (a -> b -> c -> d -> e -> f -> g) -> a -> b -> c -> d -> e -> f -> g killRange7 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g) => (a -> b -> c -> d -> e -> f -> g -> h) -> a -> b -> c -> d -> e -> f -> g -> h killRange8 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h) => (a -> b -> c -> d -> e -> f -> g -> h -> i) -> a -> b -> c -> d -> e -> f -> g -> h -> i killRange9 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j killRange10 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k killRange11 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l killRange12 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m killRange13 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n killRange14 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m, KillRange n) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o killRange15 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m, KillRange n, KillRange o) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p killRange16 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m, KillRange n, KillRange o, KillRange p) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q killRange17 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m, KillRange n, KillRange o, KillRange p, KillRange q) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r killRange18 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m, KillRange n, KillRange o, KillRange p, KillRange q, KillRange r) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s killRange19 :: (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e, KillRange f, KillRange g, KillRange h, KillRange i, KillRange j, KillRange k, KillRange l, KillRange m, KillRange n, KillRange o, KillRange p, KillRange q, KillRange r, KillRange s) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -- | x `withRangeOf` y sets the range of x to the range -- of y. withRangeOf :: (SetRange t, HasRange u) => t -> u -> t -- | Precondition: The ranges must point to the same file (or be empty). fuseRange :: (HasRange u, HasRange t) => u -> t -> Range -- | fuseRanges r r' unions the ranges r and r'. -- -- Meaning it finds the least range r0 that covers r -- and r'. -- -- Precondition: The ranges must point to the same file (or be empty). fuseRanges :: Ord a => Range' a -> Range' a -> Range' a -- | beginningOf r is an empty range (a single, empty interval) -- positioned at the beginning of r. If r does not have -- a beginning, then noRange is returned. beginningOf :: Range -> Range -- | beginningOfFile r is an empty range (a single, empty -- interval) at the beginning of r's starting position's file. -- If there is no such position, then an empty range is returned. beginningOfFile :: Range -> Range -- | Interleaves two streams of ranged elements -- -- It will report the conflicts as a list of conflicting pairs. In case -- of conflict, the element with the earliest start position is placed -- first. In case of a tie, the element with the earliest ending position -- is placed first. If both tie, the element from the first list is -- placed first. interleaveRanges :: HasRange a => [a] -> [a] -> ([a], [(a, a)]) instance GHC.Generics.Generic (Agda.Syntax.Position.Position' a) instance Data.Traversable.Traversable Agda.Syntax.Position.Position' instance Data.Foldable.Foldable Agda.Syntax.Position.Position' instance GHC.Base.Functor Agda.Syntax.Position.Position' instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Position' a) instance GHC.Generics.Generic Agda.Syntax.Position.RangeFile instance GHC.Show.Show Agda.Syntax.Position.RangeFile instance GHC.Generics.Generic (Agda.Syntax.Position.Interval' a) instance Data.Traversable.Traversable Agda.Syntax.Position.Interval' instance Data.Foldable.Foldable Agda.Syntax.Position.Interval' instance GHC.Base.Functor Agda.Syntax.Position.Interval' instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Position.Interval' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Position.Interval' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Interval' a) instance GHC.Generics.Generic (Agda.Syntax.Position.Range' a) instance Data.Traversable.Traversable Agda.Syntax.Position.Range' instance Data.Foldable.Foldable Agda.Syntax.Position.Range' instance GHC.Base.Functor Agda.Syntax.Position.Range' instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Position.Range' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Position.Range' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Range' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Position.PrintRange a) instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange (Agda.Syntax.Position.PrintRange a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Position.PrintRange a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Position.PrintRange a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Position.PrintRange a) instance (Agda.Utils.Pretty.Pretty a, Agda.Syntax.Position.HasRange a) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.PrintRange a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Position.Range instance Agda.Syntax.Position.KillRange Data.Void.Void instance Agda.Syntax.Position.KillRange () instance Agda.Syntax.Position.KillRange GHC.Types.Bool instance Agda.Syntax.Position.KillRange GHC.Types.Int instance Agda.Syntax.Position.KillRange GHC.Num.Integer.Integer instance Agda.Syntax.Position.KillRange Agda.Utils.Permutation.Permutation instance Agda.Syntax.Position.KillRange GHC.Base.String instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange [a] instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Data.Map.Internal.Map k a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Utils.Permutation.Drop a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Utils.List1.List1 a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Utils.List2.List2 a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (GHC.Maybe.Maybe a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Data.Strict.Maybe.Maybe a) instance (GHC.Classes.Ord a, Agda.Syntax.Position.KillRange a) => Agda.Syntax.Position.KillRange (Data.Set.Internal.Set a) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b) => Agda.Syntax.Position.KillRange (a, b) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b, Agda.Syntax.Position.KillRange c) => Agda.Syntax.Position.KillRange (a, b, c) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b, Agda.Syntax.Position.KillRange c, Agda.Syntax.Position.KillRange d) => Agda.Syntax.Position.KillRange (a, b, c, d) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b) => Agda.Syntax.Position.KillRange (Data.Either.Either a b) instance Agda.Syntax.Position.SetRange Agda.Syntax.Position.Range instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange [a] instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange (GHC.Maybe.Maybe a) instance Agda.Syntax.Position.HasRange Agda.Syntax.Position.Interval instance Agda.Syntax.Position.HasRange Agda.Syntax.Position.Range instance Agda.Syntax.Position.HasRange () instance Agda.Syntax.Position.HasRange GHC.Types.Bool instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange [a] instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Utils.List1.List1 a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Utils.List2.List2 a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (GHC.Maybe.Maybe a) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (a, b) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b, Agda.Syntax.Position.HasRange c) => Agda.Syntax.Position.HasRange (a, b, c) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b, Agda.Syntax.Position.HasRange c, Agda.Syntax.Position.HasRange d) => Agda.Syntax.Position.HasRange (a, b, c, d) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b, Agda.Syntax.Position.HasRange c, Agda.Syntax.Position.HasRange d, Agda.Syntax.Position.HasRange e) => Agda.Syntax.Position.HasRange (a, b, c, d, e) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b, Agda.Syntax.Position.HasRange c, Agda.Syntax.Position.HasRange d, Agda.Syntax.Position.HasRange e, Agda.Syntax.Position.HasRange f) => Agda.Syntax.Position.HasRange (a, b, c, d, e, f) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b, Agda.Syntax.Position.HasRange c, Agda.Syntax.Position.HasRange d, Agda.Syntax.Position.HasRange e, Agda.Syntax.Position.HasRange f, Agda.Syntax.Position.HasRange g) => Agda.Syntax.Position.HasRange (a, b, c, d, e, f, g) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (Data.Either.Either a b) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Position.Range' a) instance Agda.Utils.Null.Null (Agda.Syntax.Position.Range' a) instance GHC.Classes.Eq a => GHC.Base.Semigroup (Agda.Syntax.Position.Range' a) instance GHC.Classes.Eq a => GHC.Base.Monoid (Agda.Syntax.Position.Range' a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.Range' (Data.Strict.Maybe.Maybe a)) instance Control.DeepSeq.NFData Agda.Syntax.Position.IntervalWithoutFile instance Agda.Utils.Pretty.Pretty Agda.Syntax.Position.IntervalWithoutFile instance Control.DeepSeq.NFData Agda.Syntax.Position.Interval instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.Interval' (Data.Strict.Maybe.Maybe a)) instance Control.DeepSeq.NFData Agda.Syntax.Position.PositionWithoutFile instance Agda.Utils.Pretty.Pretty Agda.Syntax.Position.PositionWithoutFile instance Control.DeepSeq.NFData Agda.Syntax.Position.Position instance GHC.Classes.Eq Agda.Syntax.Position.RangeFile instance GHC.Classes.Ord Agda.Syntax.Position.RangeFile instance Control.DeepSeq.NFData Agda.Syntax.Position.RangeFile instance Agda.Utils.Pretty.Pretty Agda.Syntax.Position.RangeFile instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Position.Position' a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Position.Position' a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.Position' (Data.Strict.Maybe.Maybe a)) module Agda.Syntax.TopLevelModuleName -- | A top-level module name has one or more name parts. type TopLevelModuleNameParts = List1 Text -- | Raw top-level module names (with linear-time comparisons). data RawTopLevelModuleName RawTopLevelModuleName :: Range -> TopLevelModuleNameParts -> RawTopLevelModuleName [rawModuleNameRange] :: RawTopLevelModuleName -> Range [rawModuleNameParts] :: RawTopLevelModuleName -> TopLevelModuleNameParts -- | Turns a raw top-level module name into a string. rawTopLevelModuleNameToString :: RawTopLevelModuleName -> String -- | Hashes a raw top-level module name. hashRawTopLevelModuleName :: RawTopLevelModuleName -> ModuleNameHash -- | Turns a qualified name into a RawTopLevelModuleName. The -- qualified name is assumed to represent a top-level module name. rawTopLevelModuleNameForQName :: QName -> RawTopLevelModuleName -- | Computes the RawTopLevelModuleName corresponding to the given -- module name, which is assumed to represent a top-level module name. -- -- Precondition: The module name must be well-formed. rawTopLevelModuleNameForModuleName :: ModuleName -> RawTopLevelModuleName -- | Computes the top-level module name. -- -- Precondition: The Declaration has to be well-formed. This means -- that there are only allowed declarations before the first module -- declaration, typically import declarations. See -- spanAllowedBeforeModule. rawTopLevelModuleNameForModule :: Module -> RawTopLevelModuleName -- | Top-level module names (with constant-time comparisons). data TopLevelModuleName TopLevelModuleName :: Range -> {-# UNPACK #-} !ModuleNameHash -> TopLevelModuleNameParts -> TopLevelModuleName [moduleNameRange] :: TopLevelModuleName -> Range [moduleNameId] :: TopLevelModuleName -> {-# UNPACK #-} !ModuleNameHash [moduleNameParts] :: TopLevelModuleName -> TopLevelModuleNameParts -- | A lens focusing on the moduleNameParts. lensTopLevelModuleNameParts :: Lens' TopLevelModuleNameParts TopLevelModuleName -- | Converts a top-level module name to a raw top-level module name. rawTopLevelModuleName :: TopLevelModuleName -> RawTopLevelModuleName -- | Converts a raw top-level module name and a hash to a top-level module -- name. -- -- This function does not ensure that there are no hash collisions, that -- is taken care of by topLevelModuleName. unsafeTopLevelModuleName :: RawTopLevelModuleName -> ModuleNameHash -> TopLevelModuleName -- | A corresponding QName. The range of each Name part is -- the whole range of the TopLevelModuleName. topLevelModuleNameToQName :: TopLevelModuleName -> QName -- | Turns a top-level module name into a file name with the given suffix. moduleNameToFileName :: TopLevelModuleName -> String -> FilePath -- | Finds the current project's "root" directory, given a project file and -- the corresponding top-level module name. -- -- Example: If the module "A.B.C" is located in the file -- "fooABC.agda", then the root is "foo". -- -- Precondition: The module name must be well-formed. projectRoot :: AbsolutePath -> TopLevelModuleName -> AbsolutePath instance GHC.Generics.Generic Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance GHC.Show.Show Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance GHC.Generics.Generic Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance GHC.Show.Show Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.Utils.BiMap.HasTag Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance GHC.Classes.Eq Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance GHC.Classes.Ord Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Data.Hashable.Class.Hashable Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.Utils.Size.Sized Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.Utils.Pretty.Pretty Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.Syntax.Position.HasRange Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.Syntax.Position.SetRange Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.Syntax.Position.KillRange Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Control.DeepSeq.NFData Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance GHC.Classes.Eq Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance GHC.Classes.Ord Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Agda.Utils.Size.Sized Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Agda.Utils.Pretty.Pretty Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Agda.Syntax.Position.HasRange Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Agda.Syntax.Position.SetRange Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Agda.Syntax.Position.KillRange Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Agda.Syntax.Concrete.Name.IsNoName Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName instance Control.DeepSeq.NFData Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName -- | The concrete syntax is a raw representation of the program text -- without any desugaring at all. This is what the parser produces. The -- idea is that if we figure out how to keep the concrete syntax around, -- it can be printed exactly as the user wrote it. module Agda.Syntax.Concrete -- | Concrete expressions. Should represent exactly what the user wrote. data Expr -- | ex: x Ident :: QName -> Expr -- | ex: 1 or "foo" Lit :: Range -> Literal -> Expr -- | ex: ? or {! ... !} QuestionMark :: Range -> Maybe Nat -> Expr -- | ex: _ or _A_5 Underscore :: Range -> Maybe String -> Expr -- | before parsing operators RawApp :: Range -> List2 Expr -> Expr -- | ex: e e, e {e}, or e {x = e} App :: Range -> Expr -> NamedArg Expr -> Expr -- | ex: e + e The QName is possibly ambiguous, but it must -- correspond to one of the names in the set. OpApp :: Range -> QName -> Set Name -> OpAppArgs -> Expr -- | ex: e | e1 | .. | en WithApp :: Range -> Expr -> [Expr] -> Expr -- | ex: {e} or {x=e} HiddenArg :: Range -> Named_ Expr -> Expr -- | ex: {{e}} or {{x=e}} InstanceArg :: Range -> Named_ Expr -> Expr -- | ex: \x {y} -> e or \(x:A){y:B} -> e Lam :: Range -> List1 LamBinding -> Expr -> Expr -- | ex: \ () AbsurdLam :: Range -> Hiding -> Expr -- | ex: \ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en } ExtendedLam :: Range -> Erased -> List1 LamClause -> Expr -- | ex: e -> e or .e -> e (NYI: {e} -> -- e) Fun :: Range -> Arg Expr -> Expr -> Expr -- | ex: (xs:e) -> e or {xs:e} -> e Pi :: Telescope1 -> Expr -> Expr -- | ex: record {x = a; y = b}, or record { x = a; M1; M2 -- } Rec :: Range -> RecordAssignments -> Expr -- | ex: record e {x = a; y = b} RecUpdate :: Range -> Expr -> [FieldAssignment] -> Expr -- | ex: let Ds in e, missing body when parsing do-notation let Let :: Range -> List1 Declaration -> Maybe Expr -> Expr -- | ex: (e) Paren :: Range -> Expr -> Expr -- | ex: (| e1 | e2 | .. | en |) or (|) IdiomBrackets :: Range -> [Expr] -> Expr -- | ex: do x <- m1; m2 DoBlock :: Range -> List1 DoStmt -> Expr -- | ex: () or {}, only in patterns Absurd :: Range -> Expr -- | ex: x@p, only in patterns As :: Range -> Name -> Expr -> Expr -- | ex: .p, only in patterns Dot :: Range -> Expr -> Expr -- | ex: ..A, used for parsing ..A -> B DoubleDot :: Range -> Expr -> Expr -- | ex: quote, should be applied to a name Quote :: Range -> Expr -- | ex: quoteTerm, should be applied to a term QuoteTerm :: Range -> Expr -- | ex: @(tactic t), used to declare tactic arguments Tactic :: Range -> Expr -> Expr -- | ex: unquote, should be applied to a term of type -- Term Unquote :: Range -> Expr -- | to print irrelevant things DontCare :: Expr -> Expr -- | ex: a = b, used internally in the parser Equal :: Range -> Expr -> Expr -> Expr -- | ..., used internally to parse patterns. Ellipsis :: Range -> Expr Generalized :: Expr -> Expr data OpApp e -- | An abstraction inside a special syntax declaration (see Issue 358 why -- we introduce this). SyntaxBindingLambda :: Range -> List1 LamBinding -> e -> OpApp e Ordinary :: e -> OpApp e fromOrdinary :: e -> OpApp e -> e type OpAppArgs = OpAppArgs' Expr type OpAppArgs' e = [NamedArg (MaybePlaceholder (OpApp e))] -- | The Expr is not an application. data AppView AppView :: Expr -> [NamedArg Expr] -> AppView appView :: Expr -> AppView unAppView :: AppView -> Expr rawApp :: List1 Expr -> Expr rawAppP :: List1 Pattern -> Pattern isSingleIdentifierP :: Pattern -> Maybe Name removeParenP :: Pattern -> Pattern -- | Turn an expression into a pattern. Fails if the expression is not a -- valid pattern. isPattern :: Expr -> Maybe Pattern isAbsurdP :: Pattern -> Maybe (Range, Hiding) isBinderP :: Pattern -> Maybe Binder -- | Turn an expression into a pattern, turning non-pattern subexpressions -- into WildP. exprToPatternWithHoles :: Expr -> Pattern returnExpr :: Expr -> Maybe Expr -- | A Binder x@p, the pattern is optional data Binder' a Binder :: Maybe Pattern -> a -> Binder' a [binderPattern] :: Binder' a -> Maybe Pattern [binderName] :: Binder' a -> a type Binder = Binder' BoundName mkBinder_ :: Name -> Binder mkBinder :: a -> Binder' a -- | A lambda binding is either domain free or typed. type LamBinding = LamBinding' TypedBinding data LamBinding' a -- | . x or {x} or .x or .{x} or -- {.x} or x@p or (p) DomainFree :: NamedArg Binder -> LamBinding' a -- | . (xs : e) or {xs : e} DomainFull :: a -> LamBinding' a -- | Drop type annotations and lets from bindings. dropTypeAndModality :: LamBinding -> [LamBinding] -- | A typed binding. type TypedBinding = TypedBinding' Expr data TypedBinding' e -- | Binding (x1@p1 ... xn@pn : A). TBind :: Range -> List1 (NamedArg Binder) -> e -> TypedBinding' e -- | Let binding (let Ds) or (open M args). TLet :: Range -> List1 Declaration -> TypedBinding' e type RecordAssignment = Either FieldAssignment ModuleAssignment type RecordAssignments = [RecordAssignment] type FieldAssignment = FieldAssignment' Expr data FieldAssignment' a FieldAssignment :: Name -> a -> FieldAssignment' a [_nameFieldA] :: FieldAssignment' a -> Name [_exprFieldA] :: FieldAssignment' a -> a nameFieldA :: Lens' Name (FieldAssignment' a) exprFieldA :: Lens' a (FieldAssignment' a) data ModuleAssignment ModuleAssignment :: QName -> [Expr] -> ImportDirective -> ModuleAssignment [_qnameModA] :: ModuleAssignment -> QName [_exprModA] :: ModuleAssignment -> [Expr] [_importDirModA] :: ModuleAssignment -> ImportDirective data BoundName BName :: Name -> Fixity' -> TacticAttribute -> Bool -> BoundName [boundName] :: BoundName -> Name [bnameFixity] :: BoundName -> Fixity' [bnameTactic] :: BoundName -> TacticAttribute [bnameIsFinite] :: BoundName -> Bool mkBoundName_ :: Name -> BoundName mkBoundName :: Name -> Fixity' -> BoundName type TacticAttribute = Maybe Expr type Telescope = [TypedBinding] -- | A telescope is a sequence of typed bindings. Bound variables are in -- scope in later types. type Telescope1 = List1 TypedBinding -- | We can try to get a Telescope from a [LamBinding]. -- If we have a type annotation already, we're happy. Otherwise we -- manufacture a binder with an underscore for the type. lamBindingsToTelescope :: Range -> [LamBinding] -> Telescope -- | Smart constructor for Pi: check whether the -- Telescope is empty makePi :: Telescope -> Expr -> Expr -- | Smart constructor for Lam: check for non-zero bindings. mkLam :: Range -> [LamBinding] -> Expr -> Expr -- | Smart constructor for Let: check for non-zero let bindings. mkLet :: Range -> [Declaration] -> Expr -> Expr -- | Smart constructor for TLet: check for non-zero let bindings. mkTLet :: Range -> [Declaration] -> Maybe (TypedBinding' e) -- | Isolated record directives parsed as Declarations data RecordDirective -- | Range of keyword [co]inductive. Induction :: Ranged Induction -> RecordDirective Constructor :: Name -> IsInstance -> RecordDirective -- | Range of [no-]eta-equality keyword. Eta :: Ranged HasEta0 -> RecordDirective -- | If declaration pattern is present, give its range. PatternOrCopattern :: Range -> RecordDirective -- | Extract a record directive isRecordDirective :: Declaration -> Maybe RecordDirective type RecordDirectives = RecordDirectives' (Name, IsInstance) -- | The representation type of a declaration. The comments indicate which -- type in the intended family the constructor targets. data Declaration -- | Axioms and functions can be irrelevant. (Hiding should be NotHidden) TypeSig :: ArgInfo -> TacticAttribute -> Name -> Expr -> Declaration FieldSig :: IsInstance -> TacticAttribute -> Name -> Arg Expr -> Declaration -- | Variables to be generalized, can be hidden and/or irrelevant. Generalize :: Range -> [TypeSignature] -> Declaration Field :: Range -> [FieldSignature] -> Declaration FunClause :: LHS -> RHS -> WhereClause -> Bool -> Declaration -- | lone data signature in mutual block DataSig :: Range -> Name -> [LamBinding] -> Expr -> Declaration Data :: Range -> Name -> [LamBinding] -> Expr -> [TypeSignatureOrInstanceBlock] -> Declaration DataDef :: Range -> Name -> [LamBinding] -> [TypeSignatureOrInstanceBlock] -> Declaration -- | lone record signature in mutual block RecordSig :: Range -> Name -> [LamBinding] -> Expr -> Declaration RecordDef :: Range -> Name -> RecordDirectives -> [LamBinding] -> [Declaration] -> Declaration Record :: Range -> Name -> RecordDirectives -> [LamBinding] -> Expr -> [Declaration] -> Declaration -- | Should not survive beyond the parser RecordDirective :: RecordDirective -> Declaration Infix :: Fixity -> List1 Name -> Declaration -- | notation declaration for a name Syntax :: Name -> Notation -> Declaration PatternSyn :: Range -> Name -> [Arg Name] -> Pattern -> Declaration Mutual :: Range -> [Declaration] -> Declaration InterleavedMutual :: Range -> [Declaration] -> Declaration Abstract :: Range -> [Declaration] -> Declaration -- | In Agda.Syntax.Concrete.Definitions we generate private blocks -- temporarily, which should be treated different that user-declared -- private blocks. Thus the Origin. Private :: Range -> Origin -> [Declaration] -> Declaration -- | The Range' here (exceptionally) only refers to the range of the -- instance keyword. The range of the whole block InstanceB -- r ds is fuseRange r ds. InstanceB :: Range -> [Declaration] -> Declaration LoneConstructor :: Range -> [Declaration] -> Declaration Macro :: Range -> [Declaration] -> Declaration Postulate :: Range -> [TypeSignatureOrInstanceBlock] -> Declaration Primitive :: Range -> [TypeSignature] -> Declaration Open :: Range -> QName -> ImportDirective -> Declaration Import :: Range -> QName -> Maybe AsName -> !OpenShortHand -> ImportDirective -> Declaration ModuleMacro :: Range -> Name -> ModuleApplication -> !OpenShortHand -> ImportDirective -> Declaration Module :: Range -> QName -> Telescope -> [Declaration] -> Declaration -- |
--   unquoteDecl xs = e
--   
UnquoteDecl :: Range -> [Name] -> Expr -> Declaration -- |
--   unquoteDef xs = e
--   
UnquoteDef :: Range -> [Name] -> Expr -> Declaration -- |
--   unquoteDecl data d constructor xs = e
--   
UnquoteData :: Range -> Name -> [Name] -> Expr -> Declaration Pragma :: Pragma -> Declaration data ModuleApplication -- |
--   tel. M args
--   
SectionApp :: Range -> Telescope -> Expr -> ModuleApplication -- |
--   M {{...}}
--   
RecordModuleInstance :: Range -> QName -> ModuleApplication -- | Just type signatures. type TypeSignature = Declaration -- | Just type signatures or instance blocks. type TypeSignatureOrInstanceBlock = Declaration -- | The things you are allowed to say when you shuffle names between name -- spaces (i.e. in import, namespace, or open -- declarations). type ImportDirective = ImportDirective' Name Name type Using = Using' Name Name -- | An imported name can be a module or a defined name. type ImportedName = ImportedName' Name Name type Renaming = Renaming' Name Name type RenamingDirective = RenamingDirective' Name Name type HidingDirective = HidingDirective' Name Name -- | The content of the as-clause of the import statement. data AsName' a AsName :: a -> Range -> AsName' a -- | The "as" name. [asName] :: AsName' a -> a -- | The range of the "as" keyword. Retained for highlighting purposes. [asRange] :: AsName' a -> Range -- | From the parser, we get an expression for the as-Name, -- which we have to parse into a Name. type AsName = AsName' (Either Expr Name) data OpenShortHand DoOpen :: OpenShortHand DontOpen :: OpenShortHand type RewriteEqn = RewriteEqn' () Name Pattern Expr type WithExpr = Named Name (Arg Expr) -- | Left hand sides can be written in infix style. For example: -- --
--   n + suc m = suc (n + m)
--   (f ∘ g) x = f (g x)
--   
-- -- We use fixity information to see which name is actually defined. data LHS -- | Original pattern (including with-patterns), rewrite equations and -- with-expressions. LHS :: Pattern -> [RewriteEqn] -> [WithExpr] -> LHS -- | e.g. f ps | wps [lhsOriginalPattern] :: LHS -> Pattern -- | (rewrite e | with p <- e in eq) (many) [lhsRewriteEqn] :: LHS -> [RewriteEqn] -- | with e1 in eq | {e2} | ... (many) [lhsWithExpr] :: LHS -> [WithExpr] -- | Concrete patterns. No literals in patterns at the moment. data Pattern -- | c or x IdentP :: QName -> Pattern -- |
--   quote
--   
QuoteP :: Range -> Pattern -- | p p' or p {x = p'} AppP :: Pattern -> NamedArg Pattern -> Pattern -- | p1..pn before parsing operators RawAppP :: Range -> List2 Pattern -> Pattern -- | eg: p => p' for operator _=>_ The QName -- is possibly ambiguous, but it must correspond to one of the names in -- the set. OpAppP :: Range -> QName -> Set Name -> [NamedArg Pattern] -> Pattern -- | {p} or {x = p} HiddenP :: Range -> Named_ Pattern -> Pattern -- | {{p}} or {{x = p}} InstanceP :: Range -> Named_ Pattern -> Pattern -- |
--   (p)
--   
ParenP :: Range -> Pattern -> Pattern -- |
--   _
--   
WildP :: Range -> Pattern -- |
--   ()
--   
AbsurdP :: Range -> Pattern -- | x@p unused AsP :: Range -> Name -> Pattern -> Pattern -- |
--   .e
--   
DotP :: Range -> Expr -> Pattern -- | 0, 1, etc. LitP :: Range -> Literal -> Pattern -- |
--   record {x = p; y = q}
--   
RecP :: Range -> [FieldAssignment' Pattern] -> Pattern -- | i = i1 i.e. cubical face lattice generator EqualP :: Range -> [(Expr, Expr)] -> Pattern -- | ..., only as left-most pattern. Second arg is -- Nothing before expansion, and Just p after expanding -- ellipsis to p. EllipsisP :: Range -> Maybe Pattern -> Pattern -- | | p, for with-patterns. WithP :: Range -> Pattern -> Pattern -- | Processed (operator-parsed) intermediate form of the core f -- ps of LHS. Corresponds to lhsOriginalPattern. data LHSCore LHSHead :: QName -> [NamedArg Pattern] -> LHSCore -- |
--   f
--   
[lhsDefName] :: LHSCore -> QName -- |
--   ps
--   
[lhsPats] :: LHSCore -> [NamedArg Pattern] LHSProj :: QName -> [NamedArg Pattern] -> NamedArg LHSCore -> [NamedArg Pattern] -> LHSCore -- | Record projection. [lhsDestructor] :: LHSCore -> QName -- | Patterns for record indices (currently none). [lhsPatsLeft] :: LHSCore -> [NamedArg Pattern] -- | Main argument. [lhsFocus] :: LHSCore -> NamedArg LHSCore -- |
--   ps
--   
[lhsPats] :: LHSCore -> [NamedArg Pattern] LHSWith :: LHSCore -> [Pattern] -> [NamedArg Pattern] -> LHSCore [lhsHead] :: LHSCore -> LHSCore -- | Non-empty; at least one (| p). [lhsWithPatterns] :: LHSCore -> [Pattern] -- |
--   ps
--   
[lhsPats] :: LHSCore -> [NamedArg Pattern] LHSEllipsis :: Range -> LHSCore -> LHSCore [lhsEllipsisRange] :: LHSCore -> Range -- | Pattern that was expanded from an ellipsis .... [lhsEllipsisPat] :: LHSCore -> LHSCore -- | Observe the hiding status of an expression observeHiding :: Expr -> WithHiding Expr -- | Observe the relevance status of an expression observeRelevance :: Expr -> (Relevance, Expr) -- | Observe various modifiers applied to an expression observeModifiers :: Expr -> Arg Expr data LamClause LamClause :: [Pattern] -> RHS -> Bool -> LamClause -- | Possibly empty sequence. [lamLHS] :: LamClause -> [Pattern] [lamRHS] :: LamClause -> RHS [lamCatchAll] :: LamClause -> Bool type RHS = RHS' Expr data RHS' e -- | No right hand side because of absurd match. AbsurdRHS :: RHS' e RHS :: e -> RHS' e -- | where block following a clause. type WhereClause = WhereClause' [Declaration] data WhereClause' decls -- | No where clauses. NoWhere :: WhereClause' decls -- | Ordinary where. Range' of the where keyword. -- List of declarations can be empty. AnyWhere :: Range -> decls -> WhereClause' decls -- | Named where: module M where ds. Range' of the keywords -- module and where. The Access flag applies to -- the Name (not the module contents!) and is propagated from the -- parent function. List of declarations can be empty. SomeWhere :: Range -> Name -> Access -> decls -> WhereClause' decls -- | An expression followed by a where clause. Currently only used to give -- better a better error message in interaction. data ExprWhere ExprWhere :: Expr -> WhereClause -> ExprWhere data DoStmt -- |
--   p ← e where cs
--   
DoBind :: Range -> Pattern -> Expr -> [LamClause] -> DoStmt DoThen :: Expr -> DoStmt DoLet :: Range -> List1 Declaration -> DoStmt data Pragma OptionsPragma :: Range -> [String] -> Pragma BuiltinPragma :: Range -> RString -> QName -> Pragma -- | Second Range is for REWRITE keyword. RewritePragma :: Range -> Range -> [QName] -> Pragma -- | first string is backend name ForeignPragma :: Range -> RString -> String -> Pragma -- | first string is backend name CompilePragma :: Range -> RString -> QName -> String -> Pragma StaticPragma :: Range -> QName -> Pragma -- | INLINE or NOINLINE InlinePragma :: Range -> Bool -> QName -> Pragma -- | Throws an internal error in the scope checker. The Strings are -- words to be displayed with the error. ImpossiblePragma :: Range -> [String] -> Pragma -- | For coinductive records, use pragma instead of regular -- eta-equality definition (as it is might make Agda loop). EtaPragma :: Range -> QName -> Pragma -- | Applies to the named function WarningOnUsage :: Range -> QName -> Text -> Pragma -- | Applies to the current module WarningOnImport :: Range -> Text -> Pragma -- | Mark a definition as injective for the pattern matching unifier. InjectivePragma :: Range -> QName -> Pragma -- | Display lhs as rhs (modifies the printer). DisplayPragma :: Range -> Pattern -> Expr -> Pragma -- | Applies to the following function clause. CatchallPragma :: Range -> Pragma -- | Applies to the following function (and all that are mutually recursive -- with it) or to the functions in the following mutual block. TerminationCheckPragma :: Range -> TerminationCheck Name -> Pragma -- | Applies to the following function (and all that are mutually recursive -- with it) or to the functions in the following mutual block. NoCoverageCheckPragma :: Range -> Pragma -- | Applies to the following data/record type or mutual block. NoPositivityCheckPragma :: Range -> Pragma PolarityPragma :: Range -> Name -> [Occurrence] -> Pragma -- | Applies to the following data/record type. NoUniverseCheckPragma :: Range -> Pragma -- | Applies to the stated function NotProjectionLikePragma :: Range -> QName -> Pragma -- | Modules: Top-level pragmas plus other top-level declarations. data Module Mod :: [Pragma] -> [Declaration] -> Module [modPragmas] :: Module -> [Pragma] [modDecls] :: Module -> [Declaration] -- | Decorating something with Fixity'. data ThingWithFixity x ThingWithFixity :: x -> Fixity' -> ThingWithFixity x type HoleContent = HoleContent' () Name Pattern Expr -- | Extended content of an interaction hole. data HoleContent' qn nm p e -- |
--   e
--   
HoleContentExpr :: e -> HoleContent' qn nm p e -- |
--   (rewrite | invert) e0 | ... | en
--   
HoleContentRewrite :: [RewriteEqn' qn nm p e] -> HoleContent' qn nm p e -- | Splits off allowed (= import) declarations before the first -- non-allowed declaration. After successful parsing, the first -- non-allowed declaration should be a module declaration. spanAllowedBeforeModule :: [Declaration] -> ([Declaration], [Declaration]) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Concrete.FieldAssignment' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Concrete.FieldAssignment' a) instance Data.Traversable.Traversable Agda.Syntax.Concrete.FieldAssignment' instance Data.Foldable.Foldable Agda.Syntax.Concrete.FieldAssignment' instance GHC.Base.Functor Agda.Syntax.Concrete.FieldAssignment' instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Concrete.RHS' e) instance Data.Traversable.Traversable Agda.Syntax.Concrete.RHS' instance Data.Foldable.Foldable Agda.Syntax.Concrete.RHS' instance GHC.Base.Functor Agda.Syntax.Concrete.RHS' instance Data.Traversable.Traversable Agda.Syntax.Concrete.WhereClause' instance Data.Foldable.Foldable Agda.Syntax.Concrete.WhereClause' instance GHC.Base.Functor Agda.Syntax.Concrete.WhereClause' instance GHC.Classes.Eq decls => GHC.Classes.Eq (Agda.Syntax.Concrete.WhereClause' decls) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Concrete.AsName' a) instance Data.Traversable.Traversable Agda.Syntax.Concrete.AsName' instance Data.Foldable.Foldable Agda.Syntax.Concrete.AsName' instance GHC.Base.Functor Agda.Syntax.Concrete.AsName' instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Concrete.AsName' a) instance GHC.Show.Show Agda.Syntax.Concrete.RecordDirective instance GHC.Classes.Eq Agda.Syntax.Concrete.RecordDirective instance GHC.Generics.Generic Agda.Syntax.Concrete.OpenShortHand instance GHC.Show.Show Agda.Syntax.Concrete.OpenShortHand instance GHC.Classes.Eq Agda.Syntax.Concrete.OpenShortHand instance GHC.Classes.Eq Agda.Syntax.Concrete.ModuleAssignment instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Concrete.OpApp e) instance Data.Traversable.Traversable Agda.Syntax.Concrete.OpApp instance Data.Foldable.Foldable Agda.Syntax.Concrete.OpApp instance GHC.Base.Functor Agda.Syntax.Concrete.OpApp instance GHC.Classes.Eq Agda.Syntax.Concrete.DoStmt instance GHC.Classes.Eq Agda.Syntax.Concrete.LamClause instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Concrete.LamBinding' a) instance Data.Traversable.Traversable Agda.Syntax.Concrete.LamBinding' instance Data.Foldable.Foldable Agda.Syntax.Concrete.LamBinding' instance GHC.Base.Functor Agda.Syntax.Concrete.LamBinding' instance GHC.Classes.Eq Agda.Syntax.Concrete.LHS instance Data.Traversable.Traversable Agda.Syntax.Concrete.Binder' instance Data.Foldable.Foldable Agda.Syntax.Concrete.Binder' instance GHC.Base.Functor Agda.Syntax.Concrete.Binder' instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Concrete.Binder' a) instance GHC.Classes.Eq Agda.Syntax.Concrete.BoundName instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Concrete.TypedBinding' e) instance Data.Traversable.Traversable Agda.Syntax.Concrete.TypedBinding' instance Data.Foldable.Foldable Agda.Syntax.Concrete.TypedBinding' instance GHC.Base.Functor Agda.Syntax.Concrete.TypedBinding' instance GHC.Classes.Eq Agda.Syntax.Concrete.ModuleApplication instance GHC.Classes.Eq Agda.Syntax.Concrete.Declaration instance GHC.Classes.Eq Agda.Syntax.Concrete.Expr instance GHC.Classes.Eq Agda.Syntax.Concrete.Pattern instance GHC.Classes.Eq Agda.Syntax.Concrete.Pragma instance GHC.Classes.Eq Agda.Syntax.Concrete.LHSCore instance Data.Traversable.Traversable (Agda.Syntax.Concrete.HoleContent' qn nm p) instance Data.Foldable.Foldable (Agda.Syntax.Concrete.HoleContent' qn nm p) instance GHC.Base.Functor (Agda.Syntax.Concrete.HoleContent' qn nm p) instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.LHSCore instance Agda.Syntax.Common.LensHiding Agda.Syntax.Concrete.LamBinding instance Agda.Syntax.Common.LensHiding Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Position.HasRange e => Agda.Syntax.Position.HasRange (Agda.Syntax.Concrete.OpApp e) instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Expr instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Binder instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.LamBinding instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.BoundName instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.WhereClause instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.ModuleApplication instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.ModuleAssignment instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Declaration instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.LHS instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.RHS instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.LamClause instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.DoStmt instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Pragma instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.AsName instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Pattern instance Agda.Syntax.Position.SetRange Agda.Syntax.Concrete.Pattern instance Agda.Syntax.Position.SetRange Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.ModuleAssignment instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.AsName instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Binder instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.BoundName instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Declaration instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Expr instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.LamBinding instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.LHS instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.LamClause instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.DoStmt instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.ModuleApplication instance Agda.Syntax.Position.KillRange e => Agda.Syntax.Position.KillRange (Agda.Syntax.Concrete.OpApp e) instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Pattern instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Pragma instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.RHS instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.WhereClause instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Expr instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Pattern instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Declaration instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Pragma instance Control.DeepSeq.NFData Agda.Syntax.Concrete.AsName instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.TypedBinding' a) instance Control.DeepSeq.NFData Agda.Syntax.Concrete.ModuleApplication instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.OpApp a) instance Control.DeepSeq.NFData Agda.Syntax.Concrete.LHS instance Control.DeepSeq.NFData Agda.Syntax.Concrete.ModuleAssignment instance Control.DeepSeq.NFData Agda.Syntax.Concrete.LamClause instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.LamBinding' a) instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Binder instance Control.DeepSeq.NFData Agda.Syntax.Concrete.BoundName instance Control.DeepSeq.NFData Agda.Syntax.Concrete.DoStmt instance Control.DeepSeq.NFData Agda.Syntax.Concrete.OpenShortHand instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.RecordDirective instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.RecordDirective instance Control.DeepSeq.NFData Agda.Syntax.Concrete.RecordDirective instance Agda.Utils.Null.Null (Agda.Syntax.Concrete.WhereClause' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.WhereClause' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.RHS' a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Concrete.FieldAssignment' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Concrete.FieldAssignment' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.FieldAssignment' a) module Agda.Syntax.Literal type RLiteral = Ranged Literal data Literal LitNat :: !Integer -> Literal LitWord64 :: !Word64 -> Literal LitFloat :: !Double -> Literal LitString :: !Text -> Literal LitChar :: !Char -> Literal LitQName :: !QName -> Literal LitMeta :: !TopLevelModuleName -> !MetaId -> Literal showText :: Text -> ShowS showChar' :: Char -> ShowS instance GHC.Show.Show Agda.Syntax.Literal.Literal instance Agda.Utils.Pretty.Pretty Agda.Syntax.Literal.Literal instance GHC.Classes.Eq Agda.Syntax.Literal.Literal instance GHC.Classes.Ord Agda.Syntax.Literal.Literal instance Agda.Syntax.Position.KillRange Agda.Syntax.Literal.Literal instance Control.DeepSeq.NFData Agda.Syntax.Literal.Literal -- | Some common syntactic entities are defined in this module. module Agda.Syntax.Common type Nat = Int type Arity = Nat -- | Used to specify whether something should be delayed. data Delayed Delayed :: Delayed NotDelayed :: Delayed data FileType AgdaFileType :: FileType MdFileType :: FileType RstFileType :: FileType TexFileType :: FileType OrgFileType :: FileType -- | Variants of Cubical Agda. data Cubical CErased :: Cubical CFull :: Cubical -- | Agda variants. -- -- Only some variants are tracked. data Language WithoutK :: Language WithK :: Language Cubical :: Cubical -> Language data RecordDirectives' a RecordDirectives :: Maybe (Ranged Induction) -> Maybe HasEta0 -> Maybe Range -> Maybe a -> RecordDirectives' a [recInductive] :: RecordDirectives' a -> Maybe (Ranged Induction) [recHasEta] :: RecordDirectives' a -> Maybe HasEta0 [recPattern] :: RecordDirectives' a -> Maybe Range [recConstructor] :: RecordDirectives' a -> Maybe a emptyRecordDirectives :: RecordDirectives' a -- | Does a record come with eta-equality? data HasEta' a YesEta :: HasEta' a NoEta :: a -> HasEta' a -- | Pattern and copattern matching is allowed in the presence of eta. -- -- In the absence of eta, we have to choose whether we want to allow -- matching on the constructor or copattern matching with the -- projections. Having both leads to breakage of subject reduction (issue -- #4560). type HasEta = HasEta' PatternOrCopattern type HasEta0 = HasEta' () -- | For a record without eta, which type of matching do we allow? data PatternOrCopattern -- | Can match on the record constructor. PatternMatching :: PatternOrCopattern -- | Can copattern match using the projections. (Default.) CopatternMatching :: PatternOrCopattern -- | Can we pattern match on the record constructor? class PatternMatchingAllowed a patternMatchingAllowed :: PatternMatchingAllowed a => a -> Bool -- | Can we construct a record by copattern matching? class CopatternMatchingAllowed a copatternMatchingAllowed :: CopatternMatchingAllowed a => a -> Bool -- |
--   Inductive < Coinductive
--   
data Induction Inductive :: Induction CoInductive :: Induction data Overlappable YesOverlap :: Overlappable NoOverlap :: Overlappable data Hiding Hidden :: Hiding Instance :: Overlappable -> Hiding NotHidden :: Hiding -- | Decorating something with Hiding information. data WithHiding a WithHiding :: !Hiding -> a -> WithHiding a [whHiding] :: WithHiding a -> !Hiding [whThing] :: WithHiding a -> a -- | A lens to access the Hiding attribute in data structures. -- Minimal implementation: getHiding and mapHiding or -- LensArgInfo. class LensHiding a getHiding :: LensHiding a => a -> Hiding setHiding :: LensHiding a => Hiding -> a -> a mapHiding :: LensHiding a => (Hiding -> Hiding) -> a -> a getHiding :: (LensHiding a, LensArgInfo a) => a -> Hiding mapHiding :: (LensHiding a, LensArgInfo a) => (Hiding -> Hiding) -> a -> a -- | Monoidal composition of Hiding information in some data. mergeHiding :: LensHiding a => WithHiding a -> a -- | NotHidden arguments are visible. visible :: LensHiding a => a -> Bool -- | Instance and Hidden arguments are notVisible. notVisible :: LensHiding a => a -> Bool -- | Hidden arguments are hidden. hidden :: LensHiding a => a -> Bool hide :: LensHiding a => a -> a hideOrKeepInstance :: LensHiding a => a -> a makeInstance :: LensHiding a => a -> a makeInstance' :: LensHiding a => Overlappable -> a -> a isOverlappable :: LensHiding a => a -> Bool isInstance :: LensHiding a => a -> Bool -- | Ignores Overlappable. sameHiding :: (LensHiding a, LensHiding b) => a -> b -> Bool -- | Type wrapper to indicate additive monoid/semigroup context. newtype UnderAddition t UnderAddition :: t -> UnderAddition t -- | Type wrapper to indicate composition or multiplicative -- monoid/semigroup context. newtype UnderComposition t UnderComposition :: t -> UnderComposition t -- | We have a tuple of modalities, which might not be fully orthogonal. -- For instance, irrelevant stuff is also run-time irrelevant. data Modality Modality :: Relevance -> Quantity -> Cohesion -> Modality -- | Legacy irrelevance. See Pfenning, LiCS 2001; -- AbelVezzosiWinterhalter, ICFP 2017. [modRelevance] :: Modality -> Relevance -- | Cardinality / runtime erasure. See Conor McBride, I got plenty o' -- nutting, Wadlerfest 2016. See Bob Atkey, Syntax and Semantics of -- Quantitative Type Theory, LiCS 2018. [modQuantity] :: Modality -> Quantity -- | Cohesion/what was in Agda-flat. see "Brouwer's fixed-point theorem in -- real-cohesive homotopy type theory" (arXiv:1509.07584) Currently only -- the comonad is implemented. [modCohesion] :: Modality -> Cohesion -- | m moreUsableModality m' means that an m can -- be used where ever an m' is required. moreUsableModality :: Modality -> Modality -> Bool usableModality :: LensModality a => a -> Bool -- | Multiplicative monoid (standard monoid). composeModality :: Modality -> Modality -> Modality -- | Compose with modality flag from the left. This function is e.g. used -- to update the modality information on pattern variables a -- after a match against something of modality q. applyModality :: LensModality a => Modality -> a -> a -- | inverseComposeModality r x returns the least modality -- y such that forall x, y we have x -- `moreUsableModality` (r `composeModality` y) iff (r -- `inverseComposeModality` x) `moreUsableModality` y (Galois -- connection). inverseComposeModality :: Modality -> Modality -> Modality -- | Left division by a Modality. Used e.g. to modify context when -- going into a m argument. -- -- Note that this function does not change quantities. inverseApplyModalityButNotQuantity :: LensModality a => Modality -> a -> a -- | Modality forms a pointwise additive monoid. addModality :: Modality -> Modality -> Modality -- | Identity under addition zeroModality :: Modality -- | Identity under composition unitModality :: Modality -- | Absorptive element under addition. topModality :: Modality -- | The default Modality Beware that this is neither the additive unit nor -- the unit under composition, because the default quantity is ω. defaultModality :: Modality -- | Equality ignoring origin. sameModality :: (LensModality a, LensModality b) => a -> b -> Bool lModRelevance :: Lens' Relevance Modality lModQuantity :: Lens' Quantity Modality lModCohesion :: Lens' Cohesion Modality class LensModality a getModality :: LensModality a => a -> Modality setModality :: LensModality a => Modality -> a -> a mapModality :: LensModality a => (Modality -> Modality) -> a -> a getModality :: (LensModality a, LensArgInfo a) => a -> Modality mapModality :: (LensModality a, LensArgInfo a) => (Modality -> Modality) -> a -> a getRelevanceMod :: LensModality a => LensGet Relevance a setRelevanceMod :: LensModality a => LensSet Relevance a mapRelevanceMod :: LensModality a => LensMap Relevance a getQuantityMod :: LensModality a => LensGet Quantity a setQuantityMod :: LensModality a => LensSet Quantity a mapQuantityMod :: LensModality a => LensMap Quantity a getCohesionMod :: LensModality a => LensGet Cohesion a setCohesionMod :: LensModality a => LensSet Cohesion a mapCohesionMod :: LensModality a => LensMap Cohesion a -- | Origin of Quantity0. data Q0Origin -- | User wrote nothing. Q0Inferred :: Q0Origin -- | User wrote "@0". Q0 :: Range -> Q0Origin -- | User wrote "@erased". Q0Erased :: Range -> Q0Origin -- | Origin of Quantity1. data Q1Origin -- | User wrote nothing. Q1Inferred :: Q1Origin -- | User wrote "@1". Q1 :: Range -> Q1Origin -- | User wrote "@linear". Q1Linear :: Range -> Q1Origin -- | Origin of Quantityω. data QωOrigin -- | User wrote nothing. QωInferred :: QωOrigin -- | User wrote "@ω". Qω :: Range -> QωOrigin -- | User wrote "@plenty". QωPlenty :: Range -> QωOrigin -- | Quantity for linearity. -- -- A quantity is a set of natural numbers, indicating possible semantic -- uses of a variable. A singleton set {n} requires that the -- corresponding variable is used exactly n times. data Quantity -- | Zero uses {0}, erased at runtime. Quantity0 :: Q0Origin -> Quantity -- | Linear use {1} (could be updated destructively). Mostly TODO -- (needs postponable constraints between quantities to compute uses). Quantity1 :: Q1Origin -> Quantity -- | Unrestricted use . Quantityω :: QωOrigin -> Quantity -- | Equality ignoring origin. sameQuantity :: Quantity -> Quantity -> Bool -- | Quantity forms an additive monoid with zero Quantity0. addQuantity :: Quantity -> Quantity -> Quantity -- | Identity element under addition zeroQuantity :: Quantity -- | Absorptive element! This differs from Relevance and Cohesion whose -- default is the multiplicative unit. defaultQuantity :: Quantity -- | Identity element under composition unitQuantity :: Quantity -- | Absorptive element is ω. topQuantity :: Quantity -- | m moreUsableQuantity m' means that an m can -- be used where ever an m' is required. moreQuantity :: Quantity -> Quantity -> Bool -- | Composition of quantities (multiplication). -- -- Quantity0 is dominant. Quantity1 is neutral. -- -- Right-biased for origin. composeQuantity :: Quantity -> Quantity -> Quantity -- | Compose with quantity flag from the left. This function is e.g. used -- to update the quantity information on pattern variables a -- after a match against something of quantity q. applyQuantity :: LensQuantity a => Quantity -> a -> a -- | inverseComposeQuantity r x returns the least quantity -- y such that forall x, y we have x -- `moreQuantity` (r `composeQuantity` y) iff (r -- `inverseComposeQuantity` x) `moreQuantity` y (Galois connection). inverseComposeQuantity :: Quantity -> Quantity -> Quantity -- | Left division by a Quantity. Used e.g. to modify context when -- going into a q argument. inverseApplyQuantity :: LensQuantity a => Quantity -> a -> a -- | Check for Quantity0. hasQuantity0 :: LensQuantity a => a -> Bool -- | Check for Quantity1. hasQuantity1 :: LensQuantity a => a -> Bool -- | Check for Quantityω. hasQuantityω :: LensQuantity a => a -> Bool -- | Did the user supply a quantity annotation? noUserQuantity :: LensQuantity a => a -> Bool -- | A thing of quantity 0 is unusable, all others are usable. usableQuantity :: LensQuantity a => a -> Bool class LensQuantity a getQuantity :: LensQuantity a => a -> Quantity setQuantity :: LensQuantity a => Quantity -> a -> a mapQuantity :: LensQuantity a => (Quantity -> Quantity) -> a -> a getQuantity :: (LensQuantity a, LensModality a) => a -> Quantity mapQuantity :: (LensQuantity a, LensModality a) => (Quantity -> Quantity) -> a -> a -- | A special case of Quantity: erased or not. data Erased Erased :: Q0Origin -> Erased NotErased :: QωOrigin -> Erased -- | The default value of type Erased: not erased. defaultErased :: Erased -- | Erased can be embedded into Quantity. asQuantity :: Erased -> Quantity -- | Quantity can be projected onto Erased. erasedFromQuantity :: Quantity -> Maybe Erased -- | Equality ignoring origin. sameErased :: Erased -> Erased -> Bool -- | Is the value "erased"? isErased :: Erased -> Bool -- | Composition of values of type Erased. -- -- Erased is dominant. NotErased is neutral. -- -- Right-biased for the origin. composeErased :: Erased -> Erased -> Erased -- | A function argument can be relevant or irrelevant. See -- Agda.TypeChecking.Irrelevance. data Relevance -- | The argument is (possibly) relevant at compile-time. Relevant :: Relevance -- | The argument may never flow into evaluation position. Therefore, it is -- irrelevant at run-time. It is treated relevantly during equality -- checking. NonStrict :: Relevance -- | The argument is irrelevant at compile- and runtime. Irrelevant :: Relevance allRelevances :: [Relevance] -- | A lens to access the Relevance attribute in data structures. -- Minimal implementation: getRelevance and -- mapRelevance or LensModality. class LensRelevance a getRelevance :: LensRelevance a => a -> Relevance setRelevance :: LensRelevance a => Relevance -> a -> a mapRelevance :: LensRelevance a => (Relevance -> Relevance) -> a -> a getRelevance :: (LensRelevance a, LensModality a) => a -> Relevance mapRelevance :: (LensRelevance a, LensModality a) => (Relevance -> Relevance) -> a -> a isRelevant :: LensRelevance a => a -> Bool isIrrelevant :: LensRelevance a => a -> Bool isNonStrict :: LensRelevance a => a -> Bool -- | Information ordering. Relevant `moreRelevant` NonStrict -- `moreRelevant` Irrelevant moreRelevant :: Relevance -> Relevance -> Bool -- | Equality ignoring origin. sameRelevance :: Relevance -> Relevance -> Bool -- | usableRelevance rel == False iff we cannot use a variable of -- rel. usableRelevance :: LensRelevance a => a -> Bool -- | Relevance composition. Irrelevant is dominant, -- Relevant is neutral. Composition coincides with max. composeRelevance :: Relevance -> Relevance -> Relevance -- | Compose with relevance flag from the left. This function is e.g. used -- to update the relevance information on pattern variables a -- after a match against something rel. applyRelevance :: LensRelevance a => Relevance -> a -> a -- | inverseComposeRelevance r x returns the most irrelevant -- y such that forall x, y we have x -- `moreRelevant` (r `composeRelevance` y) iff (r -- `inverseComposeRelevance` x) `moreRelevant` y (Galois -- connection). inverseComposeRelevance :: Relevance -> Relevance -> Relevance -- | Left division by a Relevance. Used e.g. to modify context when -- going into a rel argument. inverseApplyRelevance :: LensRelevance a => Relevance -> a -> a -- | Combine inferred Relevance. The unit is Irrelevant. addRelevance :: Relevance -> Relevance -> Relevance -- | Relevance forms a monoid under addition, and even a semiring. zeroRelevance :: Relevance -- | Identity element under composition unitRelevance :: Relevance -- | Absorptive element under addition. topRelevance :: Relevance -- | Default Relevance is the identity element under composition defaultRelevance :: Relevance -- | Irrelevant function arguments may appear non-strictly in the codomain -- type. irrToNonStrict :: Relevance -> Relevance -- | Applied when working on types (unless --experimental-irrelevance). nonStrictToRel :: Relevance -> Relevance nonStrictToIrr :: Relevance -> Relevance -- | We have a tuple of annotations, which might not be fully orthogonal. data Annotation Annotation :: Lock -> Annotation -- | Fitch-style dependent right adjoints. See Modal Dependent Type Theory -- and Dependent Right Adjoints, arXiv:1804.05236. [annLock] :: Annotation -> Lock defaultAnnotation :: Annotation class LensAnnotation a getAnnotation :: LensAnnotation a => a -> Annotation setAnnotation :: LensAnnotation a => Annotation -> a -> a mapAnnotation :: LensAnnotation a => (Annotation -> Annotation) -> a -> a getAnnotation :: (LensAnnotation a, LensArgInfo a) => a -> Annotation setAnnotation :: (LensAnnotation a, LensArgInfo a) => Annotation -> a -> a data Lock IsNotLock :: Lock -- | In the future there might be different kinds of them. For now we -- assume lock weakening. IsLock :: Lock defaultLock :: Lock class LensLock a getLock :: LensLock a => a -> Lock setLock :: LensLock a => Lock -> a -> a mapLock :: LensLock a => (Lock -> Lock) -> a -> a -- | Cohesion modalities see "Brouwer's fixed-point theorem in -- real-cohesive homotopy type theory" (arXiv:1509.07584) types are now -- given an additional topological layer which the modalities interact -- with. data Cohesion -- | same points, discrete topology, idempotent comonad, box-like. Flat :: Cohesion -- | identity modality. | Sharp -- ^ same points, codiscrete topology, -- idempotent monad, diamond-like. Continuous :: Cohesion -- | single point space, artificially added for Flat left-composition. Squash :: Cohesion allCohesions :: [Cohesion] -- | A lens to access the Cohesion attribute in data structures. -- Minimal implementation: getCohesion and mapCohesion -- or LensModality. class LensCohesion a getCohesion :: LensCohesion a => a -> Cohesion setCohesion :: LensCohesion a => Cohesion -> a -> a mapCohesion :: LensCohesion a => (Cohesion -> Cohesion) -> a -> a getCohesion :: (LensCohesion a, LensModality a) => a -> Cohesion mapCohesion :: (LensCohesion a, LensModality a) => (Cohesion -> Cohesion) -> a -> a -- | Information ordering. Flat `moreCohesion` Continuous -- `moreCohesion` Sharp `moreCohesion` Squash moreCohesion :: Cohesion -> Cohesion -> Bool -- | Equality ignoring origin. sameCohesion :: Cohesion -> Cohesion -> Bool -- | usableCohesion rel == False iff we cannot use a variable of -- rel. usableCohesion :: LensCohesion a => a -> Bool -- | Cohesion composition. Squash is dominant, -- Continuous is neutral. composeCohesion :: Cohesion -> Cohesion -> Cohesion -- | Compose with cohesion flag from the left. This function is e.g. used -- to update the cohesion information on pattern variables a -- after a match against something of cohesion rel. applyCohesion :: LensCohesion a => Cohesion -> a -> a -- | inverseComposeCohesion r x returns the least y such -- that forall x, y we have x `moreCohesion` (r -- `composeCohesion` y) iff (r `inverseComposeCohesion` x) -- `moreCohesion` y (Galois connection). The above law fails for -- r = Squash. inverseComposeCohesion :: Cohesion -> Cohesion -> Cohesion -- | Left division by a Cohesion. Used e.g. to modify context when -- going into a rel argument. inverseApplyCohesion :: LensCohesion a => Cohesion -> a -> a -- | Combine inferred Cohesion. The unit is Squash. addCohesion :: Cohesion -> Cohesion -> Cohesion -- | Cohesion forms a monoid under addition, and even a semiring. zeroCohesion :: Cohesion -- | Identity under composition unitCohesion :: Cohesion -- | Absorptive element under addition. topCohesion :: Cohesion -- | Default Cohesion is the identity element under composition defaultCohesion :: Cohesion -- | Origin of arguments. data Origin -- | From the source file / user input. (Preserve!) UserWritten :: Origin -- | E.g. inserted hidden arguments. Inserted :: Origin -- | Produced by the reflection machinery. Reflected :: Origin -- | Produced by an interactive case split. CaseSplit :: Origin -- | Named application produced to represent a substitution. E.g. "?0 (x = -- n)" instead of "?0 n" Substitution :: Origin -- | Decorating something with Origin information. data WithOrigin a WithOrigin :: !Origin -> a -> WithOrigin a [woOrigin] :: WithOrigin a -> !Origin [woThing] :: WithOrigin a -> a -- | A lens to access the Origin attribute in data structures. -- Minimal implementation: getOrigin and mapOrigin or -- LensArgInfo. class LensOrigin a getOrigin :: LensOrigin a => a -> Origin setOrigin :: LensOrigin a => Origin -> a -> a mapOrigin :: LensOrigin a => (Origin -> Origin) -> a -> a getOrigin :: (LensOrigin a, LensArgInfo a) => a -> Origin mapOrigin :: (LensOrigin a, LensArgInfo a) => (Origin -> Origin) -> a -> a data FreeVariables UnknownFVs :: FreeVariables KnownFVs :: IntSet -> FreeVariables unknownFreeVariables :: FreeVariables noFreeVariables :: FreeVariables oneFreeVariable :: Int -> FreeVariables freeVariablesFromList :: [Int] -> FreeVariables -- | A lens to access the FreeVariables attribute in data -- structures. Minimal implementation: getFreeVariables and -- mapFreeVariables or LensArgInfo. class LensFreeVariables a getFreeVariables :: LensFreeVariables a => a -> FreeVariables setFreeVariables :: LensFreeVariables a => FreeVariables -> a -> a mapFreeVariables :: LensFreeVariables a => (FreeVariables -> FreeVariables) -> a -> a getFreeVariables :: (LensFreeVariables a, LensArgInfo a) => a -> FreeVariables mapFreeVariables :: (LensFreeVariables a, LensArgInfo a) => (FreeVariables -> FreeVariables) -> a -> a hasNoFreeVariables :: LensFreeVariables a => a -> Bool -- | A function argument can be hidden and/or irrelevant. data ArgInfo ArgInfo :: Hiding -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo [argInfoHiding] :: ArgInfo -> Hiding [argInfoModality] :: ArgInfo -> Modality [argInfoOrigin] :: ArgInfo -> Origin [argInfoFreeVariables] :: ArgInfo -> FreeVariables -- | Sometimes we want a different kind of binder/pi-type, without it -- supporting any of the Modality interface. [argInfoAnnotation] :: ArgInfo -> Annotation class LensArgInfo a getArgInfo :: LensArgInfo a => a -> ArgInfo setArgInfo :: LensArgInfo a => ArgInfo -> a -> a mapArgInfo :: LensArgInfo a => (ArgInfo -> ArgInfo) -> a -> a defaultArgInfo :: ArgInfo getHidingArgInfo :: LensArgInfo a => LensGet Hiding a setHidingArgInfo :: LensArgInfo a => LensSet Hiding a mapHidingArgInfo :: LensArgInfo a => LensMap Hiding a getModalityArgInfo :: LensArgInfo a => LensGet Modality a setModalityArgInfo :: LensArgInfo a => LensSet Modality a mapModalityArgInfo :: LensArgInfo a => LensMap Modality a getOriginArgInfo :: LensArgInfo a => LensGet Origin a setOriginArgInfo :: LensArgInfo a => LensSet Origin a mapOriginArgInfo :: LensArgInfo a => LensMap Origin a getFreeVariablesArgInfo :: LensArgInfo a => LensGet FreeVariables a setFreeVariablesArgInfo :: LensArgInfo a => LensSet FreeVariables a mapFreeVariablesArgInfo :: LensArgInfo a => LensMap FreeVariables a isInsertedHidden :: (LensHiding a, LensOrigin a) => a -> Bool data Arg e Arg :: ArgInfo -> e -> Arg e [argInfo] :: Arg e -> ArgInfo [unArg] :: Arg e -> e defaultArg :: a -> Arg a -- | xs `withArgsFrom` args translates xs into a list of -- Args, using the elements in args to fill in the -- non-unArg fields. -- -- Precondition: The two lists should have equal length. withArgsFrom :: [a] -> [Arg b] -> [Arg a] withNamedArgsFrom :: [a] -> [NamedArg b] -> [NamedArg a] class Eq a => Underscore a underscore :: Underscore a => a isUnderscore :: Underscore a => a -> Bool -- | Something potentially carrying a name. data Named name a Named :: Maybe name -> a -> Named name a [nameOf] :: Named name a -> Maybe name [namedThing] :: Named name a -> a -- | Standard naming. type Named_ = Named NamedName -- | Standard argument names. type NamedName = WithOrigin (Ranged ArgName) -- | Equality of argument names of things modulo Range' and -- Origin. sameName :: NamedName -> NamedName -> Bool unnamed :: a -> Named name a isUnnamed :: Named name a -> Maybe a named :: name -> a -> Named name a userNamed :: Ranged ArgName -> a -> Named_ a -- | Accessor/editor for the nameOf component. class LensNamed a where { -- | The type of the name type NameOf a; } lensNamed :: LensNamed a => Lens' (Maybe (NameOf a)) a lensNamed :: (LensNamed a, Decoration f, LensNamed b, NameOf b ~ NameOf a, f b ~ a) => Lens' (Maybe (NameOf a)) a getNameOf :: LensNamed a => a -> Maybe (NameOf a) setNameOf :: LensNamed a => Maybe (NameOf a) -> a -> a mapNameOf :: LensNamed a => (Maybe (NameOf a) -> Maybe (NameOf a)) -> a -> a bareNameOf :: (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName bareNameWithDefault :: (LensNamed a, NameOf a ~ NamedName) => ArgName -> a -> ArgName -- | Equality of argument names of things modulo Range' and -- Origin. namedSame :: (LensNamed a, LensNamed b, NameOf a ~ NamedName, NameOf b ~ NamedName) => a -> b -> Bool -- | Does an argument arg fit the shape dom of the next -- expected argument? -- -- The hiding has to match, and if the argument has a name, it should -- match the name of the domain. -- -- Nothing should be __IMPOSSIBLE__, so use as @ -- fromMaybe IMPOSSIBLE $ fittingNamedArg arg dom @ fittingNamedArg :: (LensNamed arg, NameOf arg ~ NamedName, LensHiding arg, LensNamed dom, NameOf dom ~ NamedName, LensHiding dom) => arg -> dom -> Maybe Bool -- | Only Hidden arguments can have names. type NamedArg a = Arg (Named_ a) -- | Get the content of a NamedArg. namedArg :: NamedArg a -> a defaultNamedArg :: a -> NamedArg a unnamedArg :: ArgInfo -> a -> NamedArg a -- | The functor instance for NamedArg would be ambiguous, so we -- give it another name here. updateNamedArg :: (a -> b) -> NamedArg a -> NamedArg b updateNamedArgA :: Applicative f => (a -> f b) -> NamedArg a -> f (NamedArg b) -- |
--   setNamedArg a b = updateNamedArg (const b) a
--   
setNamedArg :: NamedArg a -> b -> NamedArg b -- | Names in binders and arguments. type ArgName = String argNameToString :: ArgName -> String stringToArgName :: String -> ArgName appendArgNames :: ArgName -> ArgName -> ArgName -- | Thing with range info. data Ranged a Ranged :: Range -> a -> Ranged a [rangeOf] :: Ranged a -> Range [rangedThing] :: Ranged a -> a -- | Thing with no range info. unranged :: a -> Ranged a -- | A RawName is some sort of string. type RawName = String rawNameToString :: RawName -> String stringToRawName :: String -> RawName -- | String with range info. type RString = Ranged RawName -- | Where does the ConP or Con come from? data ConOrigin -- | Inserted by system or expanded from an implicit pattern. ConOSystem :: ConOrigin -- | User wrote a constructor (pattern). ConOCon :: ConOrigin -- | User wrote a record (pattern). ConORec :: ConOrigin -- | Generated by interactive case splitting. ConOSplit :: ConOrigin -- | Prefer user-written over system-inserted. bestConInfo :: ConOrigin -> ConOrigin -> ConOrigin -- | Where does a projection come from? data ProjOrigin -- | User wrote a prefix projection. ProjPrefix :: ProjOrigin -- | User wrote a postfix projection. ProjPostfix :: ProjOrigin -- | Projection was generated by the system. ProjSystem :: ProjOrigin -- | Functions can be defined in both infix and prefix style. See -- LHS. data IsInfix InfixDef :: IsInfix PrefixDef :: IsInfix -- | Access modifier. data Access -- | Store the Origin of the private block that lead to this -- qualifier. This is needed for more faithful printing of declarations. PrivateAccess :: Origin -> Access PublicAccess :: Access -- | Abstract or concrete. data IsAbstract AbstractDef :: IsAbstract ConcreteDef :: IsAbstract class LensIsAbstract a lensIsAbstract :: LensIsAbstract a => Lens' IsAbstract a -- | Is any element of a collection an AbstractDef. class AnyIsAbstract a anyIsAbstract :: AnyIsAbstract a => a -> IsAbstract anyIsAbstract :: (AnyIsAbstract a, Foldable t, AnyIsAbstract b, t b ~ a) => a -> IsAbstract -- | Is this definition eligible for instance search? data IsInstance -- | Range of the instance keyword. InstanceDef :: Range -> IsInstance NotInstanceDef :: IsInstance -- | Is this a macro definition? data IsMacro MacroDef :: IsMacro NotMacroDef :: IsMacro newtype ModuleNameHash ModuleNameHash :: Word64 -> ModuleNameHash [moduleNameHash] :: ModuleNameHash -> Word64 noModuleNameHash :: ModuleNameHash -- | The unique identifier of a name. Second argument is the top-level -- module identifier. data NameId NameId :: {-# UNPACK #-} !Word64 -> {-# UNPACK #-} !ModuleNameHash -> NameId -- | Meta-variable identifiers use the same structure as NameIds. data MetaId MetaId :: {-# UNPACK #-} !Word64 -> {-# UNPACK #-} !ModuleNameHash -> MetaId [metaId] :: MetaId -> {-# UNPACK #-} !Word64 [metaModule] :: MetaId -> {-# UNPACK #-} !ModuleNameHash newtype Constr a Constr :: a -> Constr a -- | A "problem" consists of a set of constraints and the same constraint -- can be part of multiple problems. newtype ProblemId ProblemId :: Nat -> ProblemId -- | The position of a name part or underscore in a name. data PositionInName -- | The following underscore is at the beginning of the name: -- _foo. Beginning :: PositionInName -- | The following underscore is in the middle of the name: -- foo_bar. Middle :: PositionInName -- | The following underscore is at the end of the name: foo_. End :: PositionInName -- | Placeholders are used to represent the underscores in a section. data MaybePlaceholder e Placeholder :: !PositionInName -> MaybePlaceholder e -- | The second argument is used only (but not always) for name parts other -- than underscores. NoPlaceholder :: !Maybe PositionInName -> e -> MaybePlaceholder e -- | An abbreviation: noPlaceholder = NoPlaceholder -- Nothing. noPlaceholder :: e -> MaybePlaceholder e newtype InteractionId InteractionId :: Nat -> InteractionId [interactionId] :: InteractionId -> Nat -- | Precedence levels for operators. type PrecedenceLevel = Double data FixityLevel -- | No fixity declared. Unrelated :: FixityLevel -- | Fixity level declared as the number. Related :: !PrecedenceLevel -> FixityLevel -- | Associativity. data Associativity NonAssoc :: Associativity LeftAssoc :: Associativity RightAssoc :: Associativity -- | Fixity of operators. data Fixity Fixity :: Range -> !FixityLevel -> !Associativity -> Fixity -- | Range of the whole fixity declaration. [fixityRange] :: Fixity -> Range [fixityLevel] :: Fixity -> !FixityLevel [fixityAssoc] :: Fixity -> !Associativity noFixity :: Fixity defaultFixity :: Fixity -- | The notation is handled as the fixity in the renamer. Hence, they are -- grouped together in this type. data Fixity' Fixity' :: !Fixity -> Notation -> Range -> Fixity' [theFixity] :: Fixity' -> !Fixity [theNotation] :: Fixity' -> Notation -- | Range of the name in the fixity declaration (used for correct -- highlighting, see issue #2140). [theNameRange] :: Fixity' -> Range noFixity' :: Fixity' _fixityAssoc :: Lens' Associativity Fixity _fixityLevel :: Lens' FixityLevel Fixity class LensFixity a lensFixity :: LensFixity a => Lens' Fixity a class LensFixity' a lensFixity' :: LensFixity' a => Lens' Fixity' a -- | The things you are allowed to say when you shuffle names between name -- spaces (i.e. in import, namespace, or open -- declarations). data ImportDirective' n m ImportDirective :: Range -> Using' n m -> HidingDirective' n m -> RenamingDirective' n m -> Maybe Range -> ImportDirective' n m [importDirRange] :: ImportDirective' n m -> Range [using] :: ImportDirective' n m -> Using' n m [hiding] :: ImportDirective' n m -> HidingDirective' n m [impRenaming] :: ImportDirective' n m -> RenamingDirective' n m -- | Only for open. Exports the opened names from the current -- module. [publicOpen] :: ImportDirective' n m -> Maybe Range type HidingDirective' n m = [ImportedName' n m] type RenamingDirective' n m = [Renaming' n m] -- | Default is directive is private (use everything, but do not -- export). defaultImportDir :: ImportDirective' n m -- | isDefaultImportDir implies null, but not the other -- way round. isDefaultImportDir :: ImportDirective' n m -> Bool -- | The using clause of import directive. data Using' n m -- | No using clause given. UseEverything :: Using' n m -- | using the specified names. Using :: [ImportedName' n m] -> Using' n m mapUsing :: ([ImportedName' n1 m1] -> [ImportedName' n2 m2]) -> Using' n1 m1 -> Using' n2 m2 -- | An imported name can be a module or a defined name. data ImportedName' n m -- | Imported module name of type m. ImportedModule :: m -> ImportedName' n m -- | Imported name of type n. ImportedName :: n -> ImportedName' n m fromImportedName :: ImportedName' a a -> a setImportedName :: ImportedName' a a -> a -> ImportedName' a a -- | Like partitionEithers. partitionImportedNames :: [ImportedName' n m] -> ([n], [m]) data Renaming' n m Renaming :: ImportedName' n m -> ImportedName' n m -> Maybe Fixity -> Range -> Renaming' n m -- | Rename from this name. [renFrom] :: Renaming' n m -> ImportedName' n m -- | To this one. Must be same kind as renFrom. [renTo] :: Renaming' n m -> ImportedName' n m -- | New fixity of renTo (optional). [renFixity] :: Renaming' n m -> Maybe Fixity -- | The range of the "to" keyword. Retained for highlighting purposes. [renToRange] :: Renaming' n m -> Range -- | Termination check? (Default = TerminationCheck). data TerminationCheck m -- | Run the termination checker. TerminationCheck :: TerminationCheck m -- | Skip termination checking (unsafe). NoTerminationCheck :: TerminationCheck m -- | Treat as non-terminating. NonTerminating :: TerminationCheck m -- | Treat as terminating (unsafe). Same effect as -- NoTerminationCheck. Terminating :: TerminationCheck m -- | Skip termination checking but use measure instead. TerminationMeasure :: Range -> m -> TerminationCheck m -- | Positivity check? (Default = True). data PositivityCheck YesPositivityCheck :: PositivityCheck NoPositivityCheck :: PositivityCheck -- | Universe check? (Default is yes). data UniverseCheck YesUniverseCheck :: UniverseCheck NoUniverseCheck :: UniverseCheck -- | Coverage check? (Default is yes). data CoverageCheck YesCoverageCheck :: CoverageCheck NoCoverageCheck :: CoverageCheck -- | RewriteEqn' qn p e represents the rewrite and -- irrefutable with clauses of the LHS. qn stands for -- the QName of the auxiliary function generated to implement the feature -- nm is the type of names for pattern variables p is -- the type of patterns e is the type of expressions data RewriteEqn' qn nm p e -- |
--   rewrite e
--   
Rewrite :: List1 (qn, e) -> RewriteEqn' qn nm p e -- |
--   with p <- e in eq
--   
Invert :: qn -> List1 (Named nm (p, e)) -> RewriteEqn' qn nm p e data ExpandedEllipsis ExpandedEllipsis :: Range -> Int -> ExpandedEllipsis [ellipsisRange] :: ExpandedEllipsis -> Range [ellipsisWithArgs] :: ExpandedEllipsis -> Int NoEllipsis :: ExpandedEllipsis -- | Notation as provided by the syntax declaration. type Notation = [NotationPart] noNotation :: Notation -- | Positions of variables in syntax declarations. data BoundVariablePosition BoundVariablePosition :: !Int -> !Int -> BoundVariablePosition -- | The position (in the left-hand side of the syntax declaration) of the -- hole in which the variable is bound, counting from zero (and excluding -- parts that are not holes). For instance, for syntax Σ A (λ x → B) -- = B , A , x the number for x is 1, -- corresponding to B (0 would correspond to -- A). [holeNumber] :: BoundVariablePosition -> !Int -- | The position in the list of variables for this particular variable, -- counting from zero, and including wildcards. For instance, for -- syntax F (λ x _ y → A) = y ! A ! x the number for x -- is 0, the number for _ is 1, and the number -- for y is 2. [varNumber] :: BoundVariablePosition -> !Int -- | Notation parts. data NotationPart -- | An identifier part. For instance, for _+_ the only identifier -- part is +. IdPart :: RString -> NotationPart -- | A hole: a place where argument expressions can be written. For -- instance, for _+_ the two underscores are holes, and for -- syntax Σ A (λ x → B) = B , A , x the variables A and -- B are holes. The number is the position of the hole, counting -- from zero. For instance, the number for A is 0, and -- the number for B is 1. HolePart :: Range -> NamedArg (Ranged Int) -> NotationPart -- | A bound variable. -- -- The first range is the range of the variable in the right-hand side of -- the syntax declaration, and the second range is the range of the -- variable in the left-hand side. VarPart :: Range -> Ranged BoundVariablePosition -> NotationPart -- | A wildcard (an underscore in binding position). WildPart :: Ranged BoundVariablePosition -> NotationPart instance GHC.Generics.Generic Agda.Syntax.Common.Delayed instance GHC.Classes.Ord Agda.Syntax.Common.Delayed instance GHC.Classes.Eq Agda.Syntax.Common.Delayed instance GHC.Show.Show Agda.Syntax.Common.Delayed instance GHC.Generics.Generic Agda.Syntax.Common.FileType instance GHC.Show.Show Agda.Syntax.Common.FileType instance GHC.Classes.Ord Agda.Syntax.Common.FileType instance GHC.Classes.Eq Agda.Syntax.Common.FileType instance GHC.Generics.Generic Agda.Syntax.Common.Cubical instance GHC.Show.Show Agda.Syntax.Common.Cubical instance GHC.Classes.Eq Agda.Syntax.Common.Cubical instance GHC.Generics.Generic Agda.Syntax.Common.Language instance GHC.Show.Show Agda.Syntax.Common.Language instance GHC.Classes.Eq Agda.Syntax.Common.Language instance Data.Traversable.Traversable Agda.Syntax.Common.HasEta' instance Data.Foldable.Foldable Agda.Syntax.Common.HasEta' instance GHC.Base.Functor Agda.Syntax.Common.HasEta' instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Common.HasEta' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Common.HasEta' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Common.HasEta' a) instance GHC.Enum.Bounded Agda.Syntax.Common.PatternOrCopattern instance GHC.Enum.Enum Agda.Syntax.Common.PatternOrCopattern instance GHC.Classes.Ord Agda.Syntax.Common.PatternOrCopattern instance GHC.Classes.Eq Agda.Syntax.Common.PatternOrCopattern instance GHC.Show.Show Agda.Syntax.Common.PatternOrCopattern instance GHC.Show.Show Agda.Syntax.Common.Induction instance GHC.Classes.Ord Agda.Syntax.Common.Induction instance GHC.Classes.Eq Agda.Syntax.Common.Induction instance GHC.Classes.Ord Agda.Syntax.Common.Overlappable instance GHC.Classes.Eq Agda.Syntax.Common.Overlappable instance GHC.Show.Show Agda.Syntax.Common.Overlappable instance GHC.Classes.Ord Agda.Syntax.Common.Hiding instance GHC.Classes.Eq Agda.Syntax.Common.Hiding instance GHC.Show.Show Agda.Syntax.Common.Hiding instance Data.Traversable.Traversable Agda.Syntax.Common.WithHiding instance Data.Foldable.Foldable Agda.Syntax.Common.WithHiding instance GHC.Base.Functor Agda.Syntax.Common.WithHiding instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Common.WithHiding a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Common.WithHiding a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Common.WithHiding a) instance Agda.Utils.PartialOrd.PartialOrd t => Agda.Utils.PartialOrd.PartialOrd (Agda.Syntax.Common.UnderAddition t) instance GHC.Classes.Ord t => GHC.Classes.Ord (Agda.Syntax.Common.UnderAddition t) instance GHC.Classes.Eq t => GHC.Classes.Eq (Agda.Syntax.Common.UnderAddition t) instance GHC.Base.Functor Agda.Syntax.Common.UnderAddition instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Common.UnderAddition t) instance Agda.Utils.PartialOrd.PartialOrd t => Agda.Utils.PartialOrd.PartialOrd (Agda.Syntax.Common.UnderComposition t) instance GHC.Classes.Ord t => GHC.Classes.Ord (Agda.Syntax.Common.UnderComposition t) instance GHC.Classes.Eq t => GHC.Classes.Eq (Agda.Syntax.Common.UnderComposition t) instance GHC.Base.Functor Agda.Syntax.Common.UnderComposition instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Common.UnderComposition t) instance GHC.Classes.Ord Agda.Syntax.Common.Q0Origin instance GHC.Classes.Eq Agda.Syntax.Common.Q0Origin instance GHC.Generics.Generic Agda.Syntax.Common.Q0Origin instance GHC.Show.Show Agda.Syntax.Common.Q0Origin instance GHC.Classes.Ord Agda.Syntax.Common.Q1Origin instance GHC.Classes.Eq Agda.Syntax.Common.Q1Origin instance GHC.Generics.Generic Agda.Syntax.Common.Q1Origin instance GHC.Show.Show Agda.Syntax.Common.Q1Origin instance GHC.Classes.Ord Agda.Syntax.Common.QωOrigin instance GHC.Classes.Eq Agda.Syntax.Common.QωOrigin instance GHC.Generics.Generic Agda.Syntax.Common.QωOrigin instance GHC.Show.Show Agda.Syntax.Common.QωOrigin instance GHC.Classes.Ord Agda.Syntax.Common.Quantity instance GHC.Classes.Eq Agda.Syntax.Common.Quantity instance GHC.Generics.Generic Agda.Syntax.Common.Quantity instance GHC.Show.Show Agda.Syntax.Common.Quantity instance GHC.Generics.Generic Agda.Syntax.Common.Erased instance GHC.Classes.Eq Agda.Syntax.Common.Erased instance GHC.Show.Show Agda.Syntax.Common.Erased instance GHC.Generics.Generic Agda.Syntax.Common.Relevance instance GHC.Enum.Bounded Agda.Syntax.Common.Relevance instance GHC.Enum.Enum Agda.Syntax.Common.Relevance instance GHC.Classes.Eq Agda.Syntax.Common.Relevance instance GHC.Show.Show Agda.Syntax.Common.Relevance instance GHC.Classes.Ord Agda.Syntax.Common.Lock instance GHC.Enum.Bounded Agda.Syntax.Common.Lock instance GHC.Enum.Enum Agda.Syntax.Common.Lock instance GHC.Classes.Eq Agda.Syntax.Common.Lock instance GHC.Generics.Generic Agda.Syntax.Common.Lock instance GHC.Show.Show Agda.Syntax.Common.Lock instance GHC.Generics.Generic Agda.Syntax.Common.Annotation instance GHC.Show.Show Agda.Syntax.Common.Annotation instance GHC.Classes.Ord Agda.Syntax.Common.Annotation instance GHC.Classes.Eq Agda.Syntax.Common.Annotation instance GHC.Generics.Generic Agda.Syntax.Common.Cohesion instance GHC.Enum.Bounded Agda.Syntax.Common.Cohesion instance GHC.Enum.Enum Agda.Syntax.Common.Cohesion instance GHC.Classes.Eq Agda.Syntax.Common.Cohesion instance GHC.Show.Show Agda.Syntax.Common.Cohesion instance GHC.Generics.Generic Agda.Syntax.Common.Modality instance GHC.Show.Show Agda.Syntax.Common.Modality instance GHC.Classes.Ord Agda.Syntax.Common.Modality instance GHC.Classes.Eq Agda.Syntax.Common.Modality instance GHC.Classes.Ord Agda.Syntax.Common.Origin instance GHC.Classes.Eq Agda.Syntax.Common.Origin instance GHC.Show.Show Agda.Syntax.Common.Origin instance Data.Traversable.Traversable Agda.Syntax.Common.WithOrigin instance Data.Foldable.Foldable Agda.Syntax.Common.WithOrigin instance GHC.Base.Functor Agda.Syntax.Common.WithOrigin instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Common.WithOrigin a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Common.WithOrigin a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Common.WithOrigin a) instance GHC.Show.Show Agda.Syntax.Common.FreeVariables instance GHC.Classes.Ord Agda.Syntax.Common.FreeVariables instance GHC.Classes.Eq Agda.Syntax.Common.FreeVariables instance GHC.Show.Show Agda.Syntax.Common.ArgInfo instance GHC.Classes.Ord Agda.Syntax.Common.ArgInfo instance GHC.Classes.Eq Agda.Syntax.Common.ArgInfo instance Data.Traversable.Traversable Agda.Syntax.Common.Arg instance Data.Foldable.Foldable Agda.Syntax.Common.Arg instance GHC.Base.Functor Agda.Syntax.Common.Arg instance GHC.Show.Show e => GHC.Show.Show (Agda.Syntax.Common.Arg e) instance GHC.Classes.Ord e => GHC.Classes.Ord (Agda.Syntax.Common.Arg e) instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Common.Arg e) instance Data.Traversable.Traversable (Agda.Syntax.Common.Named name) instance Data.Foldable.Foldable (Agda.Syntax.Common.Named name) instance GHC.Base.Functor (Agda.Syntax.Common.Named name) instance (GHC.Show.Show name, GHC.Show.Show a) => GHC.Show.Show (Agda.Syntax.Common.Named name a) instance (GHC.Classes.Ord name, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Common.Named name a) instance (GHC.Classes.Eq name, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Common.Named name a) instance Data.Traversable.Traversable Agda.Syntax.Common.Ranged instance Data.Foldable.Foldable Agda.Syntax.Common.Ranged instance GHC.Base.Functor Agda.Syntax.Common.Ranged instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Common.Ranged a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Common.RecordDirectives' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Common.RecordDirectives' a) instance GHC.Base.Functor Agda.Syntax.Common.RecordDirectives' instance GHC.Generics.Generic Agda.Syntax.Common.ConOrigin instance GHC.Enum.Bounded Agda.Syntax.Common.ConOrigin instance GHC.Enum.Enum Agda.Syntax.Common.ConOrigin instance GHC.Classes.Ord Agda.Syntax.Common.ConOrigin instance GHC.Classes.Eq Agda.Syntax.Common.ConOrigin instance GHC.Show.Show Agda.Syntax.Common.ConOrigin instance GHC.Generics.Generic Agda.Syntax.Common.ProjOrigin instance GHC.Enum.Bounded Agda.Syntax.Common.ProjOrigin instance GHC.Enum.Enum Agda.Syntax.Common.ProjOrigin instance GHC.Classes.Ord Agda.Syntax.Common.ProjOrigin instance GHC.Classes.Eq Agda.Syntax.Common.ProjOrigin instance GHC.Show.Show Agda.Syntax.Common.ProjOrigin instance GHC.Classes.Ord Agda.Syntax.Common.IsInfix instance GHC.Classes.Eq Agda.Syntax.Common.IsInfix instance GHC.Show.Show Agda.Syntax.Common.IsInfix instance GHC.Classes.Ord Agda.Syntax.Common.Access instance GHC.Classes.Eq Agda.Syntax.Common.Access instance GHC.Show.Show Agda.Syntax.Common.Access instance GHC.Generics.Generic Agda.Syntax.Common.IsAbstract instance GHC.Classes.Ord Agda.Syntax.Common.IsAbstract instance GHC.Classes.Eq Agda.Syntax.Common.IsAbstract instance GHC.Show.Show Agda.Syntax.Common.IsAbstract instance GHC.Classes.Ord Agda.Syntax.Common.IsInstance instance GHC.Classes.Eq Agda.Syntax.Common.IsInstance instance GHC.Show.Show Agda.Syntax.Common.IsInstance instance GHC.Generics.Generic Agda.Syntax.Common.IsMacro instance GHC.Classes.Ord Agda.Syntax.Common.IsMacro instance GHC.Classes.Eq Agda.Syntax.Common.IsMacro instance GHC.Show.Show Agda.Syntax.Common.IsMacro instance Data.Hashable.Class.Hashable Agda.Syntax.Common.ModuleNameHash instance GHC.Classes.Ord Agda.Syntax.Common.ModuleNameHash instance GHC.Classes.Eq Agda.Syntax.Common.ModuleNameHash instance GHC.Show.Show Agda.Syntax.Common.NameId instance GHC.Generics.Generic Agda.Syntax.Common.NameId instance GHC.Classes.Ord Agda.Syntax.Common.NameId instance GHC.Classes.Eq Agda.Syntax.Common.NameId instance GHC.Generics.Generic Agda.Syntax.Common.MetaId instance GHC.Classes.Ord Agda.Syntax.Common.MetaId instance GHC.Classes.Eq Agda.Syntax.Common.MetaId instance Control.DeepSeq.NFData Agda.Syntax.Common.ProblemId instance GHC.Num.Num Agda.Syntax.Common.ProblemId instance GHC.Real.Integral Agda.Syntax.Common.ProblemId instance GHC.Real.Real Agda.Syntax.Common.ProblemId instance GHC.Enum.Enum Agda.Syntax.Common.ProblemId instance GHC.Classes.Ord Agda.Syntax.Common.ProblemId instance GHC.Classes.Eq Agda.Syntax.Common.ProblemId instance GHC.Classes.Ord Agda.Syntax.Common.PositionInName instance GHC.Classes.Eq Agda.Syntax.Common.PositionInName instance GHC.Show.Show Agda.Syntax.Common.PositionInName instance GHC.Show.Show e => GHC.Show.Show (Agda.Syntax.Common.MaybePlaceholder e) instance Data.Traversable.Traversable Agda.Syntax.Common.MaybePlaceholder instance Data.Foldable.Foldable Agda.Syntax.Common.MaybePlaceholder instance GHC.Base.Functor Agda.Syntax.Common.MaybePlaceholder instance GHC.Classes.Ord e => GHC.Classes.Ord (Agda.Syntax.Common.MaybePlaceholder e) instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Common.MaybePlaceholder e) instance Control.DeepSeq.NFData Agda.Syntax.Common.InteractionId instance GHC.Enum.Enum Agda.Syntax.Common.InteractionId instance GHC.Real.Real Agda.Syntax.Common.InteractionId instance GHC.Real.Integral Agda.Syntax.Common.InteractionId instance GHC.Num.Num Agda.Syntax.Common.InteractionId instance GHC.Show.Show Agda.Syntax.Common.InteractionId instance GHC.Classes.Ord Agda.Syntax.Common.InteractionId instance GHC.Classes.Eq Agda.Syntax.Common.InteractionId instance GHC.Show.Show Agda.Syntax.Common.FixityLevel instance GHC.Classes.Ord Agda.Syntax.Common.FixityLevel instance GHC.Classes.Eq Agda.Syntax.Common.FixityLevel instance GHC.Show.Show Agda.Syntax.Common.Associativity instance GHC.Classes.Ord Agda.Syntax.Common.Associativity instance GHC.Classes.Eq Agda.Syntax.Common.Associativity instance GHC.Show.Show Agda.Syntax.Common.Fixity instance (GHC.Show.Show m, GHC.Show.Show n) => GHC.Show.Show (Agda.Syntax.Common.ImportedName' n m) instance (GHC.Classes.Ord m, GHC.Classes.Ord n) => GHC.Classes.Ord (Agda.Syntax.Common.ImportedName' n m) instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.ImportedName' n m) instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.Using' n m) instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.Renaming' n m) instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.ImportDirective' n m) instance GHC.Base.Functor Agda.Syntax.Common.TerminationCheck instance GHC.Classes.Eq m => GHC.Classes.Eq (Agda.Syntax.Common.TerminationCheck m) instance GHC.Show.Show m => GHC.Show.Show (Agda.Syntax.Common.TerminationCheck m) instance GHC.Generics.Generic Agda.Syntax.Common.PositivityCheck instance GHC.Enum.Enum Agda.Syntax.Common.PositivityCheck instance GHC.Enum.Bounded Agda.Syntax.Common.PositivityCheck instance GHC.Show.Show Agda.Syntax.Common.PositivityCheck instance GHC.Classes.Ord Agda.Syntax.Common.PositivityCheck instance GHC.Classes.Eq Agda.Syntax.Common.PositivityCheck instance GHC.Generics.Generic Agda.Syntax.Common.UniverseCheck instance GHC.Enum.Enum Agda.Syntax.Common.UniverseCheck instance GHC.Enum.Bounded Agda.Syntax.Common.UniverseCheck instance GHC.Show.Show Agda.Syntax.Common.UniverseCheck instance GHC.Classes.Ord Agda.Syntax.Common.UniverseCheck instance GHC.Classes.Eq Agda.Syntax.Common.UniverseCheck instance GHC.Generics.Generic Agda.Syntax.Common.CoverageCheck instance GHC.Enum.Enum Agda.Syntax.Common.CoverageCheck instance GHC.Enum.Bounded Agda.Syntax.Common.CoverageCheck instance GHC.Show.Show Agda.Syntax.Common.CoverageCheck instance GHC.Classes.Ord Agda.Syntax.Common.CoverageCheck instance GHC.Classes.Eq Agda.Syntax.Common.CoverageCheck instance Data.Traversable.Traversable (Agda.Syntax.Common.RewriteEqn' qn nm p) instance Data.Foldable.Foldable (Agda.Syntax.Common.RewriteEqn' qn nm p) instance GHC.Base.Functor (Agda.Syntax.Common.RewriteEqn' qn nm p) instance (GHC.Show.Show qn, GHC.Show.Show e, GHC.Show.Show nm, GHC.Show.Show p) => GHC.Show.Show (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance (GHC.Classes.Eq qn, GHC.Classes.Eq e, GHC.Classes.Eq nm, GHC.Classes.Eq p) => GHC.Classes.Eq (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance GHC.Classes.Eq Agda.Syntax.Common.ExpandedEllipsis instance GHC.Show.Show Agda.Syntax.Common.ExpandedEllipsis instance GHC.Show.Show Agda.Syntax.Common.BoundVariablePosition instance GHC.Classes.Ord Agda.Syntax.Common.BoundVariablePosition instance GHC.Classes.Eq Agda.Syntax.Common.BoundVariablePosition instance GHC.Show.Show Agda.Syntax.Common.NotationPart instance GHC.Show.Show Agda.Syntax.Common.Fixity' instance Agda.Syntax.Common.LensFixity' Agda.Syntax.Common.Fixity' instance GHC.Classes.Eq Agda.Syntax.Common.Fixity' instance Agda.Utils.Null.Null Agda.Syntax.Common.Fixity' instance Control.DeepSeq.NFData Agda.Syntax.Common.Fixity' instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Fixity' instance Agda.Syntax.Common.LensFixity Agda.Syntax.Common.Fixity' instance GHC.Classes.Eq Agda.Syntax.Common.NotationPart instance GHC.Classes.Ord Agda.Syntax.Common.NotationPart instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.NotationPart instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.NotationPart instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.NotationPart instance Control.DeepSeq.NFData Agda.Syntax.Common.NotationPart instance Control.DeepSeq.NFData Agda.Syntax.Common.BoundVariablePosition instance Agda.Utils.Null.Null Agda.Syntax.Common.ExpandedEllipsis instance GHC.Base.Semigroup Agda.Syntax.Common.ExpandedEllipsis instance GHC.Base.Monoid Agda.Syntax.Common.ExpandedEllipsis instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.ExpandedEllipsis instance Control.DeepSeq.NFData Agda.Syntax.Common.ExpandedEllipsis instance (Control.DeepSeq.NFData qn, Control.DeepSeq.NFData nm, Control.DeepSeq.NFData p, Control.DeepSeq.NFData e) => Control.DeepSeq.NFData (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance (Agda.Utils.Pretty.Pretty nm, Agda.Utils.Pretty.Pretty p, Agda.Utils.Pretty.Pretty e) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance (Agda.Syntax.Position.HasRange qn, Agda.Syntax.Position.HasRange nm, Agda.Syntax.Position.HasRange p, Agda.Syntax.Position.HasRange e) => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance (Agda.Syntax.Position.KillRange qn, Agda.Syntax.Position.KillRange nm, Agda.Syntax.Position.KillRange e, Agda.Syntax.Position.KillRange p) => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.CoverageCheck instance GHC.Base.Semigroup Agda.Syntax.Common.CoverageCheck instance GHC.Base.Monoid Agda.Syntax.Common.CoverageCheck instance Control.DeepSeq.NFData Agda.Syntax.Common.CoverageCheck instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.UniverseCheck instance Control.DeepSeq.NFData Agda.Syntax.Common.UniverseCheck instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.PositivityCheck instance GHC.Base.Semigroup Agda.Syntax.Common.PositivityCheck instance GHC.Base.Monoid Agda.Syntax.Common.PositivityCheck instance Control.DeepSeq.NFData Agda.Syntax.Common.PositivityCheck instance Agda.Syntax.Position.KillRange m => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.TerminationCheck m) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.TerminationCheck a) instance Agda.Utils.Null.Null (Agda.Syntax.Common.ImportDirective' n m) instance (Agda.Syntax.Position.HasRange n, Agda.Syntax.Position.HasRange m) => GHC.Base.Semigroup (Agda.Syntax.Common.ImportDirective' n m) instance (Agda.Syntax.Position.HasRange n, Agda.Syntax.Position.HasRange m) => GHC.Base.Monoid (Agda.Syntax.Common.ImportDirective' n m) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.ImportDirective' a b) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b) => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.ImportDirective' a b) instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Agda.Syntax.Common.ImportDirective' a b) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.Renaming' a b) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b) => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.Renaming' a b) instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Agda.Syntax.Common.Renaming' a b) instance GHC.Base.Semigroup (Agda.Syntax.Common.Using' n m) instance GHC.Base.Monoid (Agda.Syntax.Common.Using' n m) instance Agda.Utils.Null.Null (Agda.Syntax.Common.Using' n m) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.Using' a b) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b) => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.Using' a b) instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Agda.Syntax.Common.Using' a b) instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.ImportedName' a b) instance (Agda.Syntax.Position.KillRange a, Agda.Syntax.Position.KillRange b) => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.ImportedName' a b) instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Agda.Syntax.Common.ImportedName' a b) instance Agda.Syntax.Common.LensFixity Agda.Syntax.Common.Fixity instance GHC.Classes.Eq Agda.Syntax.Common.Fixity instance GHC.Classes.Ord Agda.Syntax.Common.Fixity instance Agda.Utils.Null.Null Agda.Syntax.Common.Fixity instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Fixity instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Fixity instance Control.DeepSeq.NFData Agda.Syntax.Common.Fixity instance Agda.Utils.Null.Null Agda.Syntax.Common.FixityLevel instance Control.DeepSeq.NFData Agda.Syntax.Common.FixityLevel instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.InteractionId instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.InteractionId instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.MaybePlaceholder a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.MaybePlaceholder a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.MaybePlaceholder a) instance GHC.Show.Show Agda.Syntax.Common.ProblemId instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.ProblemId instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.MetaId instance GHC.Enum.Enum Agda.Syntax.Common.MetaId instance GHC.Show.Show Agda.Syntax.Common.MetaId instance Control.DeepSeq.NFData Agda.Syntax.Common.MetaId instance Data.Hashable.Class.Hashable Agda.Syntax.Common.MetaId instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.NameId instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.NameId instance GHC.Enum.Enum Agda.Syntax.Common.NameId instance Control.DeepSeq.NFData Agda.Syntax.Common.NameId instance Data.Hashable.Class.Hashable Agda.Syntax.Common.NameId instance Agda.Utils.BiMap.HasTag Agda.Syntax.Common.ModuleNameHash instance GHC.Show.Show Agda.Syntax.Common.ModuleNameHash instance Control.DeepSeq.NFData Agda.Syntax.Common.ModuleNameHash instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.IsMacro instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.IsMacro instance Control.DeepSeq.NFData Agda.Syntax.Common.IsMacro instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.IsInstance instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.IsInstance instance Control.DeepSeq.NFData Agda.Syntax.Common.IsInstance instance Agda.Syntax.Common.AnyIsAbstract Agda.Syntax.Common.IsAbstract instance Agda.Syntax.Common.AnyIsAbstract a => Agda.Syntax.Common.AnyIsAbstract [a] instance Agda.Syntax.Common.AnyIsAbstract a => Agda.Syntax.Common.AnyIsAbstract (GHC.Maybe.Maybe a) instance Agda.Syntax.Common.LensIsAbstract Agda.Syntax.Common.IsAbstract instance GHC.Base.Semigroup Agda.Syntax.Common.IsAbstract instance GHC.Base.Monoid Agda.Syntax.Common.IsAbstract instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.IsAbstract instance Control.DeepSeq.NFData Agda.Syntax.Common.IsAbstract instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Access instance Control.DeepSeq.NFData Agda.Syntax.Common.Access instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Access instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Access instance Control.DeepSeq.NFData Agda.Syntax.Common.ProjOrigin instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.ProjOrigin instance Control.DeepSeq.NFData Agda.Syntax.Common.ConOrigin instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.ConOrigin instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.RecordDirectives' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.RecordDirectives' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.RecordDirectives' a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Ranged a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Common.Ranged a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Common.Ranged a) instance Agda.Syntax.Position.HasRange (Agda.Syntax.Common.Ranged a) instance Agda.Syntax.Position.KillRange (Agda.Syntax.Common.Ranged a) instance Agda.Utils.Functor.Decoration Agda.Syntax.Common.Ranged instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.Ranged a) instance Agda.Syntax.Common.LensNamed a => Agda.Syntax.Common.LensNamed (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Common.LensNamed (GHC.Maybe.Maybe a) instance Agda.Syntax.Common.LensNamed (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Common.LensHiding a => Agda.Syntax.Common.LensHiding (Agda.Syntax.Common.Named nm a) instance Agda.Utils.Functor.Decoration (Agda.Syntax.Common.Named name) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange (Agda.Syntax.Common.Named name a) instance (Agda.Syntax.Position.KillRange name, Agda.Syntax.Position.KillRange a) => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.Named name a) instance (Control.DeepSeq.NFData name, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Common.Underscore GHC.Base.String instance Agda.Syntax.Common.Underscore Data.ByteString.Internal.ByteString instance Agda.Syntax.Common.Underscore Text.PrettyPrint.HughesPJ.Doc instance Agda.Syntax.Common.LensAnnotation (Agda.Syntax.Common.Arg t) instance Agda.Syntax.Common.LensLock (Agda.Syntax.Common.Arg t) instance Agda.Utils.Functor.Decoration Agda.Syntax.Common.Arg instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.Arg a) instance Control.DeepSeq.NFData e => Control.DeepSeq.NFData (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensArgInfo (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Common.LensHiding (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensModality (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensOrigin (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensFreeVariables (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensRelevance (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensQuantity (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensCohesion (Agda.Syntax.Common.Arg e) instance Agda.Syntax.Common.LensHiding Agda.Syntax.Common.Hiding instance Agda.Syntax.Common.LensHiding (Agda.Syntax.Common.WithHiding a) instance Agda.Syntax.Common.LensHiding Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensQuantity Agda.Syntax.Common.Modality instance Agda.Syntax.Common.LensQuantity Agda.Syntax.Common.Quantity instance Agda.Syntax.Common.LensQuantity Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Common.Modality instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Common.Relevance instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensCohesion Agda.Syntax.Common.Modality instance Agda.Syntax.Common.LensCohesion Agda.Syntax.Common.Cohesion instance Agda.Syntax.Common.LensCohesion Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensModality Agda.Syntax.Common.Modality instance Agda.Syntax.Common.LensModality Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensAnnotation Agda.Syntax.Common.Annotation instance Agda.Syntax.Common.LensAnnotation Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensOrigin Agda.Syntax.Common.Origin instance Agda.Syntax.Common.LensOrigin (Agda.Syntax.Common.WithOrigin a) instance Agda.Syntax.Common.LensOrigin Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensFreeVariables Agda.Syntax.Common.FreeVariables instance Agda.Syntax.Common.LensFreeVariables Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensArgInfo Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Common.LensLock Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.ArgInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.ArgInfo instance Control.DeepSeq.NFData Agda.Syntax.Common.ArgInfo instance GHC.Base.Semigroup Agda.Syntax.Common.FreeVariables instance GHC.Base.Monoid Agda.Syntax.Common.FreeVariables instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.FreeVariables instance Control.DeepSeq.NFData Agda.Syntax.Common.FreeVariables instance Agda.Utils.Functor.Decoration Agda.Syntax.Common.WithOrigin instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.WithOrigin a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.WithOrigin a) instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange (Agda.Syntax.Common.WithOrigin a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.WithOrigin a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.WithOrigin a) instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Origin instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Origin instance Control.DeepSeq.NFData Agda.Syntax.Common.Origin instance Agda.Utils.PartialOrd.PartialOrd Agda.Syntax.Common.Modality instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Modality) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Modality) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Modality) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Modality) instance Agda.Utils.POMonoid.LeftClosedPOMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Modality) instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Modality) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Modality) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Modality) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Modality) instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Modality instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Modality instance Control.DeepSeq.NFData Agda.Syntax.Common.Modality instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Cohesion instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.Cohesion instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Cohesion instance Control.DeepSeq.NFData Agda.Syntax.Common.Cohesion instance GHC.Classes.Ord Agda.Syntax.Common.Cohesion instance Agda.Utils.PartialOrd.PartialOrd Agda.Syntax.Common.Cohesion instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Cohesion) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Cohesion) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Cohesion) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Cohesion) instance Agda.Utils.POMonoid.LeftClosedPOMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Cohesion) instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Cohesion) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Cohesion) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Cohesion) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Cohesion) instance Agda.Syntax.Common.LensLock Agda.Syntax.Common.Lock instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Annotation instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Annotation instance Control.DeepSeq.NFData Agda.Syntax.Common.Annotation instance Control.DeepSeq.NFData Agda.Syntax.Common.Lock instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Relevance instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.Relevance instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Relevance instance Control.DeepSeq.NFData Agda.Syntax.Common.Relevance instance GHC.Classes.Ord Agda.Syntax.Common.Relevance instance Agda.Utils.PartialOrd.PartialOrd Agda.Syntax.Common.Relevance instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Relevance) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Relevance) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Relevance) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Relevance) instance Agda.Utils.POMonoid.LeftClosedPOMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Relevance) instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Relevance) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Relevance) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Relevance) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Relevance) instance Control.DeepSeq.NFData Agda.Syntax.Common.Erased instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Erased instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Erased instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Erased) instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Quantity) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Quantity) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Quantity) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Quantity) instance Agda.Utils.POMonoid.LeftClosedPOMonoid (Agda.Syntax.Common.UnderComposition Agda.Syntax.Common.Quantity) instance GHC.Base.Semigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Quantity) instance GHC.Base.Monoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Quantity) instance Agda.Utils.POMonoid.POSemigroup (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Quantity) instance Agda.Utils.POMonoid.POMonoid (Agda.Syntax.Common.UnderAddition Agda.Syntax.Common.Quantity) instance Agda.Utils.PartialOrd.PartialOrd Agda.Syntax.Common.Quantity instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Quantity instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.Quantity instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Quantity instance Control.DeepSeq.NFData Agda.Syntax.Common.Quantity instance GHC.Base.Semigroup Agda.Syntax.Common.QωOrigin instance GHC.Base.Monoid Agda.Syntax.Common.QωOrigin instance Agda.Utils.Null.Null Agda.Syntax.Common.QωOrigin instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.QωOrigin instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.QωOrigin instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.QωOrigin instance Control.DeepSeq.NFData Agda.Syntax.Common.QωOrigin instance GHC.Base.Semigroup Agda.Syntax.Common.Q1Origin instance GHC.Base.Monoid Agda.Syntax.Common.Q1Origin instance Agda.Utils.Null.Null Agda.Syntax.Common.Q1Origin instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Q1Origin instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.Q1Origin instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Q1Origin instance Control.DeepSeq.NFData Agda.Syntax.Common.Q1Origin instance GHC.Base.Semigroup Agda.Syntax.Common.Q0Origin instance GHC.Base.Monoid Agda.Syntax.Common.Q0Origin instance Agda.Utils.Null.Null Agda.Syntax.Common.Q0Origin instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Q0Origin instance Agda.Syntax.Position.SetRange Agda.Syntax.Common.Q0Origin instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Q0Origin instance Control.DeepSeq.NFData Agda.Syntax.Common.Q0Origin instance GHC.Base.Applicative Agda.Syntax.Common.UnderComposition instance GHC.Base.Applicative Agda.Syntax.Common.UnderAddition instance Agda.Utils.Functor.Decoration Agda.Syntax.Common.WithHiding instance GHC.Base.Applicative Agda.Syntax.Common.WithHiding instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.WithHiding a) instance Agda.Syntax.Position.SetRange a => Agda.Syntax.Position.SetRange (Agda.Syntax.Common.WithHiding a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.WithHiding a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.WithHiding a) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Hiding instance GHC.Base.Semigroup Agda.Syntax.Common.Hiding instance GHC.Base.Monoid Agda.Syntax.Common.Hiding instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Hiding instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Hiding instance Control.DeepSeq.NFData Agda.Syntax.Common.Hiding instance GHC.Base.Semigroup Agda.Syntax.Common.Overlappable instance GHC.Base.Monoid Agda.Syntax.Common.Overlappable instance Control.DeepSeq.NFData Agda.Syntax.Common.Overlappable instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Induction instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.Induction instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Induction instance Control.DeepSeq.NFData Agda.Syntax.Common.Induction instance Agda.Syntax.Common.PatternMatchingAllowed Agda.Syntax.Common.Induction instance Agda.Syntax.Common.CopatternMatchingAllowed Agda.Syntax.Common.PatternOrCopattern instance Agda.Syntax.Common.CopatternMatchingAllowed Agda.Syntax.Common.HasEta instance Agda.Syntax.Common.PatternMatchingAllowed Agda.Syntax.Common.PatternOrCopattern instance Agda.Syntax.Common.PatternMatchingAllowed Agda.Syntax.Common.HasEta instance Control.DeepSeq.NFData Agda.Syntax.Common.PatternOrCopattern instance Agda.Syntax.Position.HasRange Agda.Syntax.Common.PatternOrCopattern instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.PatternOrCopattern instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.HasEta' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.HasEta' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Common.HasEta' a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Language instance Control.DeepSeq.NFData Agda.Syntax.Common.Language instance Control.DeepSeq.NFData Agda.Syntax.Common.Cubical instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.FileType instance Control.DeepSeq.NFData Agda.Syntax.Common.FileType instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Delayed instance Control.DeepSeq.NFData Agda.Syntax.Common.Delayed -- | Abstract names carry unique identifiers and stuff. module Agda.Syntax.Abstract.Name -- | Make a Name from some kind of string. class MkName a -- | The Range' sets the definition site of the name, not the -- use site. mkName :: MkName a => Range -> NameId -> a -> Name mkName_ :: MkName a => NameId -> a -> Name -- | Check whether we are a projection pattern. class IsProjP a isProjP :: IsProjP a => a -> Maybe (ProjOrigin, AmbiguousQName) -- | A name suffix data Suffix NoSuffix :: Suffix Suffix :: !Integer -> Suffix -- | Ambiguous qualified names. Used for overloaded constructors. -- -- Invariant: All the names in the list must have the same concrete, -- unqualified name. (This implies that they all have the same -- Range'). newtype AmbiguousQName AmbQ :: List1 QName -> AmbiguousQName [unAmbQ] :: AmbiguousQName -> List1 QName -- | A module name is just a qualified name. -- -- The SetRange instance for module names sets all individual -- ranges to the given one. newtype ModuleName MName :: [Name] -> ModuleName [mnameToList] :: ModuleName -> [Name] -- | Something preceeded by a qualified name. data QNamed a QNamed :: QName -> a -> QNamed a [qname] :: QNamed a -> QName [qnamed] :: QNamed a -> a -- | Qualified names are non-empty lists of names. Equality on qualified -- names are just equality on the last name, i.e. the module part is just -- for show. -- -- The SetRange instance for qualified names sets all individual -- ranges (including those of the module prefix) to the given one. data QName QName :: ModuleName -> Name -> QName [qnameModule] :: QName -> ModuleName [qnameName] :: QName -> Name -- | A name is a unique identifier and a suggestion for a concrete name. -- The concrete name contains the source location (if any) of the name. -- The source location of the binding site is also recorded. data Name Name :: !NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name [nameId] :: Name -> !NameId -- | The concrete name used for this instance [nameConcrete] :: Name -> Name -- | The concrete name in the original definition (needed by primShowQName, -- see #4735) [nameCanonical] :: Name -> Name [nameBindingSite] :: Name -> Range [nameFixity] :: Name -> Fixity' -- | Is this the name of the invisible record variable self? -- Should not be printed or displayed in the context, see issue #3584. [nameIsRecordName] :: Name -> Bool -- | Useful for debugging scoping problems uglyShowName :: Name -> String -- | A singleton "ambiguous" name. unambiguous :: QName -> AmbiguousQName -- | Get the first of the ambiguous names. headAmbQ :: AmbiguousQName -> QName -- | Is a name ambiguous. isAmbiguous :: AmbiguousQName -> Bool -- | Get the name if unambiguous. getUnambiguous :: AmbiguousQName -> Maybe QName -- | A module is anonymous if the qualification path ends in an underscore. isAnonymousModuleName :: ModuleName -> Bool -- | Sets the ranges of the individual names in the module name to match -- those of the corresponding concrete names. If the concrete names are -- fewer than the number of module name name parts, then the initial name -- parts get the range noRange. -- -- C.D.E `withRangesOf` [A, B] returns C.D.E but with -- ranges set as follows: -- -- -- -- Precondition: The number of module name name parts has to be at least -- as large as the length of the list. withRangesOf :: ModuleName -> List1 Name -> ModuleName -- | Like withRangesOf, but uses the name parts (qualifier + name) -- of the qualified name as the list of concrete names. withRangesOfQ :: ModuleName -> QName -> ModuleName mnameFromList :: [Name] -> ModuleName mnameFromList1 :: List1 Name -> ModuleName mnameToList1 :: ModuleName -> List1 Name noModuleName :: ModuleName commonParentModule :: ModuleName -> ModuleName -> ModuleName makeName :: NameId -> Name -> Range -> Fixity' -> Bool -> Name qnameToList0 :: QName -> [Name] qnameToList :: QName -> List1 Name qnameFromList :: List1 Name -> QName qnameToMName :: QName -> ModuleName mnameToQName :: ModuleName -> QName showQNameId :: QName -> String -- | Turn a qualified name into a concrete name. This should only be used -- as a fallback when looking up the right concrete name in the scope -- fails. qnameToConcrete :: QName -> QName mnameToConcrete :: ModuleName -> QName qualifyM :: ModuleName -> ModuleName -> ModuleName qualifyQ :: ModuleName -> QName -> QName qualify :: ModuleName -> Name -> QName -- | Convert a Name to a QName (add no module name). qualify_ :: Name -> QName -- | Is the name an operator? isOperator :: QName -> Bool -- | Is the first module a weak parent of the second? isLeParentModuleOf :: ModuleName -> ModuleName -> Bool -- | Is the first module a proper parent of the second? isLtParentModuleOf :: ModuleName -> ModuleName -> Bool -- | Is the first module a weak child of the second? isLeChildModuleOf :: ModuleName -> ModuleName -> Bool -- | Is the first module a proper child of the second? isLtChildModuleOf :: ModuleName -> ModuleName -> Bool isInModule :: QName -> ModuleName -> Bool -- | Get the next version of the concrete name. For instance, nextName -- "x" = "x₁". The name must not be a NoName. nextName :: FreshNameMode -> Name -> Name sameRoot :: Name -> Name -> Bool lensQNameName :: Lens' Name QName nameToArgName :: Name -> ArgName namedArgName :: NamedArg Name -> ArgName -- | Check whether a name is the empty name "_". class IsNoName a isNoName :: IsNoName a => a -> Bool isNoName :: (IsNoName a, Foldable t, IsNoName b, t b ~ a) => a -> Bool -- | Method by which to generate fresh unshadowed names. data FreshNameMode -- | Append an integer Unicode subscript: x, x₁, x₂, … UnicodeSubscript :: FreshNameMode -- | Append an integer ASCII counter: x, x1, x2, … AsciiCounter :: FreshNameMode instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.ModuleName instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.ModuleName instance Data.Traversable.Traversable Agda.Syntax.Abstract.Name.QNamed instance Data.Foldable.Foldable Agda.Syntax.Abstract.Name.QNamed instance GHC.Base.Functor Agda.Syntax.Abstract.Name.QNamed instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Name.AmbiguousQName instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.AmbiguousQName instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.AmbiguousQName instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.Suffix instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.Suffix instance GHC.Show.Show Agda.Syntax.Abstract.Name.Suffix instance GHC.Show.Show Agda.Syntax.Abstract.Name.Name instance GHC.Show.Show Agda.Syntax.Abstract.Name.ModuleName instance GHC.Show.Show Agda.Syntax.Abstract.Name.QName instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Abstract.Name.QNamed a) instance GHC.Show.Show Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.Syntax.Abstract.Name.MkName GHC.Base.String instance Agda.Syntax.Abstract.Name.IsProjP a => Agda.Syntax.Abstract.Name.IsProjP (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Abstract.Name.IsProjP a => Agda.Syntax.Abstract.Name.IsProjP (Agda.Syntax.Common.Named n a) instance Agda.Syntax.Abstract.Name.IsProjP Data.Void.Void instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Name.Suffix instance Agda.Syntax.Concrete.Name.NumHoles Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Abstract.Name.QNamed a) instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.QName instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.QName instance Data.Hashable.Class.Hashable Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Concrete.Name.NumHoles Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Common.LensFixity' Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Common.LensFixity Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Concrete.Name.LensInScope Agda.Syntax.Abstract.Name.QName instance Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Position.SetRange Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Name.QName instance Agda.Utils.Size.Sized Agda.Syntax.Abstract.Name.QName instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Name.QName instance Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Position.SetRange Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Name.ModuleName instance Agda.Utils.Size.Sized Agda.Syntax.Abstract.Name.ModuleName instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Name.ModuleName instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.Name instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.Name instance Data.Hashable.Class.Hashable Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Concrete.Name.IsNoName Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Concrete.Name.NumHoles Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Common.LensFixity' Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Common.LensFixity Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Concrete.Name.LensInScope Agda.Syntax.Abstract.Name.Name instance Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Position.SetRange Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Name.Name instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Name.Name -- | Names in the concrete syntax are just strings (or lists of strings for -- qualified names). module Agda.Syntax.Concrete.Name -- | A name is a non-empty list of alternating Ids and Holes. -- A normal name is represented by a singleton list, and operators are -- represented by a list with Holes where the arguments should go. -- For instance: [Hole,Id "+",Hole] is infix addition. -- -- Equality and ordering on Names are defined to ignore range so -- same names in different locations are equal. data Name -- | A (mixfix) identifier. Name :: Range -> NameInScope -> NameParts -> Name [nameRange] :: Name -> Range [nameInScope] :: Name -> NameInScope [nameNameParts] :: Name -> NameParts -- | _. NoName :: Range -> NameId -> Name [nameRange] :: Name -> Range [nameId] :: Name -> NameId type NameParts = List1 NamePart -- | An open mixfix identifier is either prefix, infix, or suffix. That is -- to say: at least one of its extremities is a Hole isOpenMixfix :: Name -> Bool -- | Mixfix identifiers are composed of words and holes, e.g. _+_ -- or if_then_else_ or [_/_]. data NamePart -- | _ part. Hole :: NamePart -- | Identifier part. Id :: RawName -> NamePart -- | QName is a list of namespaces and the name of the constant. -- For the moment assumes namespaces are just Names and not -- explicitly applied modules. Also assumes namespaces are generative by -- just using derived equality. We will have to define an equality -- instance to non-generative namespaces (as well as having some sort of -- lookup table for namespace names). data QName -- | A.rest. Qual :: Name -> QName -> QName -- | x. QName :: Name -> QName -- | Create an ordinary InScope name. simpleName :: RawName -> Name -- | Create a binary operator name in scope. simpleBinaryOperator :: RawName -> Name -- | Create an ordinary InScope name containing a single -- Hole. simpleHole :: Name -- | Don't use on 'NoName{}'. lensNameParts :: Lens' NameParts Name nameToRawName :: Name -> RawName nameParts :: Name -> NameParts nameStringParts :: Name -> [RawName] -- | Parse a string to parts of a concrete name. -- -- Note: stringNameParts "_" == [Id "_"] == nameParts NoName{} stringNameParts :: String -> NameParts -- | Number of holes in a Name (i.e., arity of a mixfix-operator). class NumHoles a numHoles :: NumHoles a => a -> Int -- | Is the name an operator? Needs at least 2 NameParts. isOperator :: Name -> Bool isHole :: NamePart -> Bool isPrefix :: Name -> Bool isPostfix :: Name -> Bool isInfix :: Name -> Bool isNonfix :: Name -> Bool data NameInScope InScope :: NameInScope NotInScope :: NameInScope class LensInScope a lensInScope :: LensInScope a => Lens' NameInScope a isInScope :: LensInScope a => a -> NameInScope mapInScope :: LensInScope a => (NameInScope -> NameInScope) -> a -> a setInScope :: LensInScope a => a -> a setNotInScope :: LensInScope a => a -> a -- | Method by which to generate fresh unshadowed names. data FreshNameMode -- | Append an integer Unicode subscript: x, x₁, x₂, … UnicodeSubscript :: FreshNameMode -- | Append an integer ASCII counter: x, x1, x2, … AsciiCounter :: FreshNameMode nextRawName :: FreshNameMode -> RawName -> RawName -- | Get the next version of the concrete name. For instance, nextName -- "x" = "x₁". The name must not be a NoName. nextName :: FreshNameMode -> Name -> Name -- | Zoom on the last non-hole in a name. lastIdPart :: Lens' RawName NameParts -- | Get the first version of the concrete name that does not satisfy the -- given predicate. firstNonTakenName :: FreshNameMode -> (Name -> Bool) -> Name -> Name -- | Lens for accessing and modifying the suffix of a name. The suffix of a -- NoName is always Nothing, and should not be changed. nameSuffix :: Lens' (Maybe Suffix) Name -- | Split a name into a base name plus a suffix. nameSuffixView :: Name -> (Maybe Suffix, Name) -- | Replaces the suffix of a name. Unless the suffix is Nothing, -- the name should not be NoName. setNameSuffix :: Maybe Suffix -> Name -> Name -- | Get a raw version of the name with all suffixes removed. For instance, -- nameRoot "x₁₂₃" = "x". nameRoot :: Name -> RawName sameRoot :: Name -> Name -> Bool -- | Lens for the unqualified part of a QName lensQNameName :: Lens' Name QName -- |
--   qualify A.B x == A.B.x
--   
qualify :: QName -> Name -> QName -- |
--   unqualify A.B.x == x
--   
-- -- The range is preserved. unqualify :: QName -> Name -- |
--   qnameParts A.B.x = [A, B, x]
--   
qnameParts :: QName -> List1 Name -- | Is the name (un)qualified? isQualified :: QName -> Bool isUnqualified :: QName -> Maybe Name -- |
--   noName_ = noName noRange
--   
noName_ :: Name noName :: Range -> Name -- | Check whether a name is the empty name "_". class IsNoName a isNoName :: IsNoName a => a -> Bool isNoName :: (IsNoName a, Foldable t, IsNoName b, t b ~ a) => a -> Bool instance GHC.Generics.Generic Agda.Syntax.Concrete.Name.NamePart instance GHC.Show.Show Agda.Syntax.Concrete.Name.NameInScope instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.NameInScope instance GHC.Classes.Ord Agda.Syntax.Concrete.Name.QName instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.QName instance GHC.Show.Show Agda.Syntax.Concrete.Name.Name instance GHC.Show.Show Agda.Syntax.Concrete.Name.NamePart instance GHC.Show.Show Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Concrete.Name.IsNoName GHC.Base.String instance Agda.Syntax.Concrete.Name.IsNoName Data.ByteString.Internal.ByteString instance Agda.Syntax.Concrete.Name.IsNoName Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Concrete.Name.IsNoName Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Concrete.Name.IsNoName a => Agda.Syntax.Concrete.Name.IsNoName (Agda.Syntax.Common.Ranged a) instance Agda.Syntax.Concrete.Name.IsNoName a => Agda.Syntax.Concrete.Name.IsNoName (Agda.Syntax.Common.WithOrigin a) instance Agda.Syntax.Concrete.Name.LensInScope Agda.Syntax.Concrete.Name.NameInScope instance Agda.Syntax.Concrete.Name.LensInScope Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Concrete.Name.LensInScope Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Common.Underscore Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Concrete.Name.NumHoles Agda.Syntax.Concrete.Name.QName instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Position.SetRange Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Name.QName instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Common.Underscore Agda.Syntax.Concrete.Name.Name instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.Name instance GHC.Classes.Ord Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Concrete.Name.NumHoles Agda.Syntax.Concrete.Name.Name instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Position.SetRange Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Name.Name instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Name.Name instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Name.NameInScope instance Agda.Syntax.Concrete.Name.NumHoles Agda.Syntax.Concrete.Name.NameParts instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.NamePart instance GHC.Classes.Ord Agda.Syntax.Concrete.Name.NamePart instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Name.NamePart instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Name.NamePart -- | Definitions for fixity, precedence levels, and declared syntax. module Agda.Syntax.Fixity -- | Decorating something with Fixity'. data ThingWithFixity x ThingWithFixity :: x -> Fixity' -> ThingWithFixity x -- | Do we prefer parens around arguments like λ x → x or not? See -- lamBrackets. data ParenPreference PreferParen :: ParenPreference PreferParenless :: ParenPreference preferParen :: ParenPreference -> Bool preferParenless :: ParenPreference -> Bool -- | Precedence is associated with a context. data Precedence TopCtx :: Precedence FunctionSpaceDomainCtx :: Precedence LeftOperandCtx :: Fixity -> Precedence RightOperandCtx :: Fixity -> ParenPreference -> Precedence FunctionCtx :: Precedence ArgumentCtx :: ParenPreference -> Precedence InsideOperandCtx :: Precedence WithFunCtx :: Precedence WithArgCtx :: Precedence DotPatternCtx :: Precedence -- | When printing we keep track of a stack of precedences in order to be -- able to decide whether it's safe to leave out parens around lambdas. -- An empty stack is equivalent to TopCtx. Invariant: `notElem -- TopCtx`. type PrecedenceStack = [Precedence] pushPrecedence :: Precedence -> PrecedenceStack -> PrecedenceStack headPrecedence :: PrecedenceStack -> Precedence -- | Argument context preferring parens. argumentCtx_ :: Precedence -- | Do we need to bracket an operator application of the given fixity in a -- context with the given precedence. opBrackets :: Fixity -> PrecedenceStack -> Bool -- | Do we need to bracket an operator application of the given fixity in a -- context with the given precedence. opBrackets' :: Bool -> Fixity -> PrecedenceStack -> Bool -- | Does a lambda-like thing (lambda, let or pi) need brackets in the -- given context? A peculiar thing with lambdas is that they don't need -- brackets in certain right operand contexts. To decide we need to look -- at the stack of precedences and not just the current precedence. -- Example: m₁ >>= (λ x → x) >>= m₂ (for -- _>>=_ left associative). lamBrackets :: PrecedenceStack -> Bool -- | Does a function application need brackets? appBrackets :: PrecedenceStack -> Bool -- | Does a function application need brackets? appBrackets' :: Bool -> PrecedenceStack -> Bool -- | Does a with application need brackets? withAppBrackets :: PrecedenceStack -> Bool -- | Does a function space need brackets? piBrackets :: PrecedenceStack -> Bool roundFixBrackets :: PrecedenceStack -> Bool instance GHC.Show.Show x => GHC.Show.Show (Agda.Syntax.Fixity.ThingWithFixity x) instance Data.Traversable.Traversable Agda.Syntax.Fixity.ThingWithFixity instance Data.Foldable.Foldable Agda.Syntax.Fixity.ThingWithFixity instance GHC.Base.Functor Agda.Syntax.Fixity.ThingWithFixity instance GHC.Generics.Generic Agda.Syntax.Fixity.ParenPreference instance GHC.Show.Show Agda.Syntax.Fixity.ParenPreference instance GHC.Classes.Ord Agda.Syntax.Fixity.ParenPreference instance GHC.Classes.Eq Agda.Syntax.Fixity.ParenPreference instance GHC.Generics.Generic Agda.Syntax.Fixity.Precedence instance GHC.Classes.Eq Agda.Syntax.Fixity.Precedence instance GHC.Show.Show Agda.Syntax.Fixity.Precedence instance Control.DeepSeq.NFData Agda.Syntax.Fixity.Precedence instance Agda.Utils.Pretty.Pretty Agda.Syntax.Fixity.Precedence instance Control.DeepSeq.NFData Agda.Syntax.Fixity.ParenPreference instance Agda.Syntax.Common.LensFixity' (Agda.Syntax.Fixity.ThingWithFixity a) instance Agda.Syntax.Common.LensFixity (Agda.Syntax.Fixity.ThingWithFixity a) instance Agda.Syntax.Position.KillRange x => Agda.Syntax.Position.KillRange (Agda.Syntax.Fixity.ThingWithFixity x) -- | Preprocessors for literate code formats. module Agda.Syntax.Parser.Literate -- | List of valid extensions for literate Agda files, and their -- corresponding preprocessors. -- -- If you add new extensions, remember to update test/Utils.hs so that -- test cases ending in the new extensions are found. literateProcessors :: [(String, (Processor, FileType))] -- | Short list of extensions for literate Agda files. For display -- purposes. literateExtsShortList :: [String] literateSrcFile :: [Layer] -> SrcFile -- | Preprocessor for literate TeX. literateTeX :: Position -> String -> [Layer] -- | Preprocessor for reStructuredText. literateRsT :: Position -> String -> [Layer] -- | Preprocessor for Markdown. literateMd :: Position -> String -> [Layer] -- | Preprocessor for Org mode documents. literateOrg :: Position -> String -> [Layer] -- | Blanks the non-code parts of a given file, preserving positions of -- characters corresponding to code. This way, there is a direct -- correspondence between source positions and positions in the processed -- result. illiterate :: [Layer] -> String atomizeLayers :: Layers -> [(LayerRole, Char)] -- | Type of a literate preprocessor: Invariants: -- --
--   f : Processor
--   
-- --
--   f pos s /= []
--   
-- --
--   f pos s >>= layerContent == s
--   
type Processor = Position -> String -> [Layer] -- | A list of contiguous layers. type Layers = [Layer] -- | A sequence of characters in a file playing the same role. data Layer Layer :: LayerRole -> Interval -> String -> Layer [layerRole] :: Layer -> LayerRole [interval] :: Layer -> Interval [layerContent] :: Layer -> String -- | Role of a character in the file. data LayerRole Markup :: LayerRole Comment :: LayerRole Code :: LayerRole -- | Returns True if the role corresponds to Agda code. isCode :: LayerRole -> Bool -- | Returns True if the layer contains Agda code. isCodeLayer :: Layer -> Bool instance GHC.Classes.Eq Agda.Syntax.Parser.Literate.LayerRole instance GHC.Show.Show Agda.Syntax.Parser.Literate.LayerRole instance GHC.Show.Show Agda.Syntax.Parser.Literate.Layer instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Literate.Layer -- | The parser monad used by the operator parser module Agda.Syntax.Concrete.Operators.Parser.Monad -- | Memoisation keys. data MemoKey NodeK :: PrecedenceKey -> MemoKey PostLeftsK :: PrecedenceKey -> MemoKey PreRightsK :: PrecedenceKey -> MemoKey TopK :: MemoKey AppK :: MemoKey NonfixK :: MemoKey type PrecedenceKey = Either PrecedenceLevel PrecedenceLevel -- | The parser monad. type Parser tok a = Parser MemoKey tok (MaybePlaceholder tok) a -- | Runs the parser. parse :: forall tok a. Parser tok a -> [MaybePlaceholder tok] -> [a] -- | Parses a token satisfying the given predicate. The computed value is -- returned. sat' :: (MaybePlaceholder tok -> Maybe a) -> Parser tok a -- | Parses a token satisfying the given predicate. sat :: (MaybePlaceholder tok -> Bool) -> Parser tok (MaybePlaceholder tok) -- | Uses the given document as the printed representation of the given -- parser. The document's precedence is taken to be atomP. doc :: Doc -> Parser tok a -> Parser tok a -- | Memoises the given parser. -- -- Every memoised parser must be annotated with a unique key. -- (Parametrised parsers must use distinct keys for distinct inputs.) memoise :: MemoKey -> Parser tok tok -> Parser tok tok -- | Memoises the given parser, but only if printing, not if parsing. -- -- Every memoised parser must be annotated with a unique key. -- (Parametrised parsers must use distinct keys for distinct inputs.) memoiseIfPrinting :: MemoKey -> Parser tok tok -> Parser tok tok -- | Tries to print the parser, or returns empty, depending on the -- implementation. This function might not terminate. grammar :: Parser tok a -> Doc instance GHC.Generics.Generic Agda.Syntax.Concrete.Operators.Parser.Monad.MemoKey instance GHC.Show.Show Agda.Syntax.Concrete.Operators.Parser.Monad.MemoKey instance GHC.Classes.Eq Agda.Syntax.Concrete.Operators.Parser.Monad.MemoKey instance Data.Hashable.Class.Hashable Agda.Syntax.Concrete.Operators.Parser.Monad.MemoKey module Agda.Compiler.JS.Syntax data Exp Self :: Exp Local :: LocalId -> Exp Global :: GlobalId -> Exp Undefined :: Exp Null :: Exp String :: Text -> Exp Char :: Char -> Exp Integer :: Integer -> Exp Double :: Double -> Exp Lambda :: Nat -> Exp -> Exp Object :: Map MemberId Exp -> Exp Array :: [(Comment, Exp)] -> Exp Apply :: Exp -> [Exp] -> Exp Lookup :: Exp -> MemberId -> Exp If :: Exp -> Exp -> Exp -> Exp BinOp :: Exp -> String -> Exp -> Exp PreOp :: String -> Exp -> Exp Const :: String -> Exp -- | Arbitrary JS code. PlainJS :: String -> Exp newtype LocalId LocalId :: Nat -> LocalId newtype GlobalId GlobalId :: [String] -> GlobalId data MemberId MemberId :: String -> MemberId MemberIndex :: Int -> Comment -> MemberId newtype Comment Comment :: String -> Comment data Export Export :: JSQName -> Exp -> Export [expName] :: Export -> JSQName [defn] :: Export -> Exp type JSQName = List1 MemberId data Module Module :: GlobalId -> [GlobalId] -> [Export] -> Maybe Exp -> Module [modName] :: Module -> GlobalId [imports] :: Module -> [GlobalId] [exports] :: Module -> [Export] [callMain] :: Module -> Maybe Exp class Uses a uses :: Uses a => a -> Set JSQName uses :: (Uses a, a ~ t b, Foldable t, Uses b) => a -> Set JSQName class Globals a globals :: Globals a => a -> Set GlobalId globals :: (Globals a, a ~ t b, Foldable t, Globals b) => a -> Set GlobalId instance GHC.Show.Show Agda.Compiler.JS.Syntax.LocalId instance GHC.Classes.Ord Agda.Compiler.JS.Syntax.LocalId instance GHC.Classes.Eq Agda.Compiler.JS.Syntax.LocalId instance GHC.Show.Show Agda.Compiler.JS.Syntax.GlobalId instance GHC.Classes.Ord Agda.Compiler.JS.Syntax.GlobalId instance GHC.Classes.Eq Agda.Compiler.JS.Syntax.GlobalId instance GHC.Base.Monoid Agda.Compiler.JS.Syntax.Comment instance GHC.Base.Semigroup Agda.Compiler.JS.Syntax.Comment instance GHC.Show.Show Agda.Compiler.JS.Syntax.Comment instance GHC.Show.Show Agda.Compiler.JS.Syntax.MemberId instance GHC.Classes.Ord Agda.Compiler.JS.Syntax.MemberId instance GHC.Classes.Eq Agda.Compiler.JS.Syntax.MemberId instance GHC.Classes.Eq Agda.Compiler.JS.Syntax.Exp instance GHC.Show.Show Agda.Compiler.JS.Syntax.Exp instance GHC.Show.Show Agda.Compiler.JS.Syntax.Export instance GHC.Show.Show Agda.Compiler.JS.Syntax.Module instance Agda.Compiler.JS.Syntax.Globals a => Agda.Compiler.JS.Syntax.Globals [a] instance Agda.Compiler.JS.Syntax.Globals a => Agda.Compiler.JS.Syntax.Globals (GHC.Maybe.Maybe a) instance Agda.Compiler.JS.Syntax.Globals a => Agda.Compiler.JS.Syntax.Globals (Data.Map.Internal.Map k a) instance (Agda.Compiler.JS.Syntax.Globals a, Agda.Compiler.JS.Syntax.Globals b) => Agda.Compiler.JS.Syntax.Globals (a, b) instance (Agda.Compiler.JS.Syntax.Globals a, Agda.Compiler.JS.Syntax.Globals b, Agda.Compiler.JS.Syntax.Globals c) => Agda.Compiler.JS.Syntax.Globals (a, b, c) instance Agda.Compiler.JS.Syntax.Globals Agda.Compiler.JS.Syntax.Comment instance Agda.Compiler.JS.Syntax.Globals Agda.Compiler.JS.Syntax.Exp instance Agda.Compiler.JS.Syntax.Globals Agda.Compiler.JS.Syntax.Export instance Agda.Compiler.JS.Syntax.Globals Agda.Compiler.JS.Syntax.Module instance Agda.Compiler.JS.Syntax.Uses a => Agda.Compiler.JS.Syntax.Uses [a] instance Agda.Compiler.JS.Syntax.Uses a => Agda.Compiler.JS.Syntax.Uses (Data.Map.Internal.Map k a) instance (Agda.Compiler.JS.Syntax.Uses a, Agda.Compiler.JS.Syntax.Uses b) => Agda.Compiler.JS.Syntax.Uses (a, b) instance (Agda.Compiler.JS.Syntax.Uses a, Agda.Compiler.JS.Syntax.Uses b, Agda.Compiler.JS.Syntax.Uses c) => Agda.Compiler.JS.Syntax.Uses (a, b, c) instance Agda.Compiler.JS.Syntax.Uses Agda.Compiler.JS.Syntax.Comment instance Agda.Compiler.JS.Syntax.Uses Agda.Compiler.JS.Syntax.Exp instance Agda.Compiler.JS.Syntax.Uses Agda.Compiler.JS.Syntax.Export instance GHC.Classes.Eq Agda.Compiler.JS.Syntax.Comment instance GHC.Classes.Ord Agda.Compiler.JS.Syntax.Comment module Agda.Compiler.JS.Substitution map :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp shift :: Nat -> Exp -> Exp shiftFrom :: Nat -> Nat -> Exp -> Exp shifter :: Nat -> Nat -> LocalId -> Exp subst :: Nat -> [Exp] -> Exp -> Exp substituter :: Nat -> [Exp] -> Nat -> LocalId -> Exp map' :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp subst' :: Nat -> [Exp] -> Exp -> Exp apply :: Exp -> [Exp] -> Exp lookup :: Exp -> MemberId -> Exp self :: Exp -> Exp -> Exp fix :: Exp -> Exp curriedApply :: Exp -> [Exp] -> Exp curriedLambda :: Nat -> Exp -> Exp emp :: Exp union :: Exp -> Exp -> Exp vine :: [MemberId] -> Exp -> Exp object :: [([MemberId], Exp)] -> Exp module Agda.Compiler.JS.Pretty data Doc Doc :: String -> Doc Indent :: Int -> Doc -> Doc Group :: Doc -> Doc Beside :: Doc -> Doc -> Doc Above :: Doc -> Doc -> Doc Enclose :: Doc -> Doc -> Doc -> Doc Space :: Doc Empty :: Doc minifiedCodeLinesLength :: Int render :: Bool -> Doc -> String ($+$) :: Doc -> Doc -> Doc infixr 5 $+$ -- | Separate by blank line. ($++$) :: Doc -> Doc -> Doc infixr 5 $++$ -- | Separate by space that will be removed by minify. -- -- For non-removable space, use d <> " " <> d'. (<+>) :: Doc -> Doc -> Doc infixr 6 <+> text :: String -> Doc group :: Doc -> Doc indentBy :: Int -> Doc -> Doc enclose :: Doc -> Doc -> Doc -> Doc space :: Doc indent :: Doc -> Doc hcat :: [Doc] -> Doc vcat :: [Doc] -> Doc -- | Concatenate vertically, separated by blank lines. vsep :: [Doc] -> Doc punctuate :: Doc -> [Doc] -> Doc parens :: Doc -> Doc brackets :: Doc -> Doc braces :: Doc -> Doc -- | Apply parens to Doc if boolean is true. mparens :: Bool -> Doc -> Doc unescape :: Char -> String unescapes :: String -> Doc class Pretty a pretty :: Pretty a => (Nat, Bool) -> a -> Doc prettyShow :: Pretty a => Bool -> a -> String class Pretties a pretties :: Pretties a => (Nat, Bool) -> a -> [Doc] block :: (Nat, Bool) -> Exp -> Doc modname :: GlobalId -> Doc exports :: (Nat, Bool) -> Set JSQName -> [Export] -> Doc variableName :: String -> String -- | Check if a string is a valid JS identifier. The check ignores keywords -- as we prepend z_ to our identifiers. The check is conservative and may -- not admit all valid JS identifiers. isValidJSIdent :: String -> Bool instance Agda.Compiler.JS.Pretty.Pretty a => Agda.Compiler.JS.Pretty.Pretties [a] instance Agda.Compiler.JS.Pretty.Pretty a => Agda.Compiler.JS.Pretty.Pretties (Agda.Utils.List1.List1 a) instance (Agda.Compiler.JS.Pretty.Pretty a, Agda.Compiler.JS.Pretty.Pretty b) => Agda.Compiler.JS.Pretty.Pretties (Data.Map.Internal.Map a b) instance Agda.Compiler.JS.Pretty.Pretty Agda.Compiler.JS.Syntax.Exp instance Agda.Compiler.JS.Pretty.Pretty [(Agda.Compiler.JS.Syntax.GlobalId, Agda.Compiler.JS.Syntax.Export)] instance Agda.Compiler.JS.Pretty.Pretty a => Agda.Compiler.JS.Pretty.Pretty (GHC.Maybe.Maybe a) instance (Agda.Compiler.JS.Pretty.Pretty a, Agda.Compiler.JS.Pretty.Pretty b) => Agda.Compiler.JS.Pretty.Pretty (a, b) instance Agda.Compiler.JS.Pretty.Pretty Agda.Compiler.JS.Syntax.LocalId instance Agda.Compiler.JS.Pretty.Pretty Agda.Compiler.JS.Syntax.GlobalId instance Agda.Compiler.JS.Pretty.Pretty Agda.Compiler.JS.Syntax.MemberId instance Agda.Compiler.JS.Pretty.Pretty Agda.Compiler.JS.Syntax.Comment instance Agda.Compiler.JS.Pretty.Pretty Agda.Compiler.JS.Syntax.Module instance Data.String.IsString Agda.Compiler.JS.Pretty.Doc instance GHC.Base.Semigroup Agda.Compiler.JS.Pretty.Doc instance GHC.Base.Monoid Agda.Compiler.JS.Pretty.Doc module Agda.Auto.Syntax -- | Unique identifiers for variable occurrences in unification. type UId o = Metavar (Exp o) (RefInfo o) data HintMode HMNormal :: HintMode HMRecCall :: HintMode data EqReasoningConsts o EqReasoningConsts :: ConstRef o -> EqReasoningConsts o [eqrcId, eqrcBegin, eqrcStep, eqrcEnd, eqrcSym, eqrcCong] :: EqReasoningConsts o -> ConstRef o data EqReasoningState EqRSNone :: EqReasoningState EqRSChain :: EqReasoningState EqRSPrf1 :: EqReasoningState EqRSPrf2 :: EqReasoningState EqRSPrf3 :: EqReasoningState -- | The concrete instance of the blk parameter in Metavar. -- I.e., the information passed to the search control. data RefInfo o RIEnv :: [(ConstRef o, HintMode)] -> Nat -> Maybe (EqReasoningConsts o) -> RefInfo o [rieHints] :: RefInfo o -> [(ConstRef o, HintMode)] -- | Nat - deffreevars (to make cost of using module parameters correspond -- to that of hints). [rieDefFreeVars] :: RefInfo o -> Nat [rieEqReasoningConsts] :: RefInfo o -> Maybe (EqReasoningConsts o) RIMainInfo :: Nat -> HNExp o -> Bool -> RefInfo o -- | Size of typing context in which meta was created. [riMainCxtLength] :: RefInfo o -> Nat -- | Head normal form of type of meta. [riMainType] :: RefInfo o -> HNExp o -- | True if iota steps performed when normalising target type (used to put -- cost when traversing a definition by construction instantiation). [riMainIota] :: RefInfo o -> Bool RIUnifInfo :: [CAction o] -> HNExp o -> RefInfo o RICopyInfo :: ICExp o -> RefInfo o RIIotaStep :: Bool -> RefInfo o RIInferredTypeUnknown :: RefInfo o RINotConstructor :: RefInfo o RIUsedVars :: [UId o] -> [Elr o] -> RefInfo o RIPickSubsvar :: RefInfo o RIEqRState :: EqReasoningState -> RefInfo o RICheckElim :: Bool -> RefInfo o RICheckProjIndex :: [ConstRef o] -> RefInfo o type MyPB o = PB (RefInfo o) type MyMB a o = MB a (RefInfo o) type Nat = Int data MId Id :: String -> MId NoId :: MId -- | Abstraction with maybe a name. -- -- Different from Agda, where there is also info whether function is -- constant. data Abs a Abs :: MId -> a -> Abs a -- | Constant signatures. data ConstDef o ConstDef :: String -> o -> MExp o -> DeclCont o -> Nat -> ConstDef o -- | For debug printing. [cdname] :: ConstDef o -> String -- | Reference to the Agda constant. [cdorigin] :: ConstDef o -> o -- | Type of constant. [cdtype] :: ConstDef o -> MExp o -- | Constant definition. [cdcont] :: ConstDef o -> DeclCont o -- | Free vars of the module where the constant is defined.. [cddeffreevars] :: ConstDef o -> Nat -- | Constant definitions. data DeclCont o Def :: Nat -> [Clause o] -> Maybe Nat -> Maybe Nat -> DeclCont o Datatype :: [ConstRef o] -> [ConstRef o] -> DeclCont o Constructor :: Nat -> DeclCont o Postulate :: DeclCont o type Clause o = ([Pat o], MExp o) data Pat o PatConApp :: ConstRef o -> [Pat o] -> Pat o PatVar :: String -> Pat o -- | Dot pattern. PatExp :: Pat o -- | Projection pattern. PatProj :: ConstRef o -> Pat o type ConstRef o = IORef (ConstDef o) -- | Head of application (elimination). data Elr o Var :: Nat -> Elr o Const :: ConstRef o -> Elr o getVar :: Elr o -> Maybe Nat getConst :: Elr o -> Maybe (ConstRef o) data Sort Set :: Nat -> Sort UnknownSort :: Sort Type :: Sort -- | Agsy's internal syntax. data Exp o App :: Maybe (UId o) -> OKHandle (RefInfo o) -> Elr o -> MArgList o -> Exp o -- | Unique identifier of the head. [appUId] :: Exp o -> Maybe (UId o) -- | This application has been type-checked. [appOK] :: Exp o -> OKHandle (RefInfo o) -- | Head. [appHead] :: Exp o -> Elr o -- | Arguments. [appElims] :: Exp o -> MArgList o -- | Lambda with hiding information. Lam :: Hiding -> Abs (MExp o) -> Exp o -- | True if possibly dependent (var not known to not occur). -- False if non-dependent. Pi :: Maybe (UId o) -> Hiding -> Bool -> MExp o -> Abs (MExp o) -> Exp o Sort :: Sort -> Exp o -- | Absurd lambda with hiding information. AbsurdLambda :: Hiding -> Exp o dontCare :: Exp o -- | "Maybe expression": Expression or reference to meta variable. type MExp o = MM (Exp o) (RefInfo o) data ArgList o -- | No more eliminations. ALNil :: ArgList o -- | Application and tail. ALCons :: Hiding -> MExp o -> MArgList o -> ArgList o -- | proj pre args, projfcn idx, tail ALProj :: MArgList o -> MM (ConstRef o) (RefInfo o) -> Hiding -> MArgList o -> ArgList o -- | Constructor parameter (missing in Agda). Agsy has monomorphic -- constructors. Inserted to cover glitch of polymorphic constructor -- applications coming from Agda ALConPar :: MArgList o -> ArgList o type MArgList o = MM (ArgList o) (RefInfo o) data WithSeenUIds a o WithSeenUIds :: [Maybe (UId o)] -> a -> WithSeenUIds a o [seenUIds] :: WithSeenUIds a o -> [Maybe (UId o)] [rawValue] :: WithSeenUIds a o -> a type HNExp o = WithSeenUIds (HNExp' o) o data HNExp' o HNApp :: Elr o -> ICArgList o -> HNExp' o HNLam :: Hiding -> Abs (ICExp o) -> HNExp' o HNPi :: Hiding -> Bool -> ICExp o -> Abs (ICExp o) -> HNExp' o HNSort :: Sort -> HNExp' o -- | Head-normal form of ICArgList. First entry is exposed. -- -- Q: Why are there no projection eliminations? data HNArgList o HNALNil :: HNArgList o HNALCons :: Hiding -> ICExp o -> ICArgList o -> HNArgList o HNALConPar :: ICArgList o -> HNArgList o -- | Lazy concatenation of argument lists under explicit substitutions. data ICArgList o CALNil :: ICArgList o CALConcat :: Clos (MArgList o) o -> ICArgList o -> ICArgList o -- | An expression a in an explicit substitution [CAction -- a]. type ICExp o = Clos (MExp o) o data Clos a o Clos :: [CAction o] -> a -> Clos a o type CExp o = TrBr (ICExp o) o data TrBr a o TrBr :: [MExp o] -> a -> TrBr a o -- | Entry of an explicit substitution. -- -- An explicit substitution is a list of CActions. This is -- isomorphic to the usual presentation where Skip and -- Weak would be constructors of exp. substs. data CAction o -- | Instantation of variable. Sub :: ICExp o -> CAction o -- | For going under a binder, often called Lift. Skip :: CAction o -- | Shifting substitution (going to a larger context). Weak :: Nat -> CAction o type Ctx o = [(MId, CExp o)] type EE = IO detecteliminand :: [Clause o] -> Maybe Nat detectsemiflex :: ConstRef o -> [Clause o] -> IO Bool categorizedecl :: ConstRef o -> IO () class MetaliseOKH t metaliseOKH :: MetaliseOKH t => t -> IO t metaliseokh :: MExp o -> IO (MExp o) class ExpandMetas t expandMetas :: ExpandMetas t => t -> IO t addtrailingargs :: Clos (MArgList o) o -> ICArgList o -> ICArgList o closify :: MExp o -> CExp o sub :: MExp o -> CExp o -> CExp o subi :: MExp o -> ICExp o -> ICExp o weak :: Weakening t => Nat -> t -> t class Weakening t weak' :: Weakening t => Nat -> t -> t -- | Substituting for a variable. doclos :: [CAction o] -> Nat -> Either Nat (ICExp o) -- | FreeVars class and instances freeVars :: FreeVars t => t -> Set Nat class FreeVars t freeVarsOffset :: FreeVars t => Nat -> t -> Set Nat -- | Renaming Typeclass and instances rename :: Renaming t => (Nat -> Nat) -> t -> t class Renaming t renameOffset :: Renaming t => Nat -> (Nat -> Nat) -> t -> t instance GHC.Show.Show Agda.Auto.Syntax.EqReasoningState instance GHC.Classes.Eq Agda.Auto.Syntax.EqReasoningState instance GHC.Classes.Eq (Agda.Auto.Syntax.Elr o) instance (Agda.Auto.Syntax.Renaming a, Agda.Auto.Syntax.Renaming b) => Agda.Auto.Syntax.Renaming (a, b) instance Agda.Auto.Syntax.Renaming t => Agda.Auto.Syntax.Renaming (Agda.Auto.NarrowingSearch.MM t a) instance Agda.Auto.Syntax.Renaming t => Agda.Auto.Syntax.Renaming (Agda.Auto.Syntax.Abs t) instance Agda.Auto.Syntax.Renaming (Agda.Auto.Syntax.Elr o) instance Agda.Auto.Syntax.Renaming (Agda.Auto.Syntax.Exp o) instance Agda.Auto.Syntax.Renaming (Agda.Auto.Syntax.ArgList o) instance (Agda.Auto.Syntax.FreeVars a, Agda.Auto.Syntax.FreeVars b) => Agda.Auto.Syntax.FreeVars (a, b) instance Agda.Auto.Syntax.FreeVars t => Agda.Auto.Syntax.FreeVars (Agda.Auto.NarrowingSearch.MM t a) instance Agda.Auto.Syntax.FreeVars t => Agda.Auto.Syntax.FreeVars (Agda.Auto.Syntax.Abs t) instance Agda.Auto.Syntax.FreeVars (Agda.Auto.Syntax.Elr o) instance Agda.Auto.Syntax.FreeVars (Agda.Auto.Syntax.Exp o) instance Agda.Auto.Syntax.FreeVars (Agda.Auto.Syntax.ArgList o) instance Agda.Auto.Syntax.Weakening a => Agda.Auto.Syntax.Weakening (Agda.Auto.Syntax.TrBr a o) instance Agda.Auto.Syntax.Weakening (Agda.Auto.Syntax.Clos a o) instance Agda.Auto.Syntax.Weakening (Agda.Auto.Syntax.ICArgList o) instance Agda.Auto.Syntax.Weakening (Agda.Auto.Syntax.Elr o) instance Agda.Auto.Syntax.ExpandMetas t => Agda.Auto.Syntax.ExpandMetas (Agda.Auto.NarrowingSearch.MM t a) instance Agda.Auto.Syntax.ExpandMetas t => Agda.Auto.Syntax.ExpandMetas (Agda.Auto.Syntax.Abs t) instance Agda.Auto.Syntax.ExpandMetas (Agda.Auto.Syntax.Exp o) instance Agda.Auto.Syntax.ExpandMetas (Agda.Auto.Syntax.ArgList o) instance Agda.Auto.Syntax.MetaliseOKH t => Agda.Auto.Syntax.MetaliseOKH (Agda.Auto.NarrowingSearch.MM t a) instance Agda.Auto.Syntax.MetaliseOKH t => Agda.Auto.Syntax.MetaliseOKH (Agda.Auto.Syntax.Abs t) instance Agda.Auto.Syntax.MetaliseOKH (Agda.Auto.Syntax.Exp o) instance Agda.Auto.Syntax.MetaliseOKH (Agda.Auto.Syntax.ArgList o) module Agda.Auto.SearchControl data ExpRefInfo o ExpRefInfo :: Maybe (RefInfo o) -> [RefInfo o] -> Bool -> Bool -> Maybe ([UId o], [Elr o]) -> Maybe Bool -> Bool -> Maybe EqReasoningState -> ExpRefInfo o [eriMain] :: ExpRefInfo o -> Maybe (RefInfo o) [eriUnifs] :: ExpRefInfo o -> [RefInfo o] [eriInfTypeUnknown] :: ExpRefInfo o -> Bool [eriIsEliminand] :: ExpRefInfo o -> Bool [eriUsedVars] :: ExpRefInfo o -> Maybe ([UId o], [Elr o]) [eriIotaStep] :: ExpRefInfo o -> Maybe Bool [eriPickSubsVar] :: ExpRefInfo o -> Bool [eriEqRState] :: ExpRefInfo o -> Maybe EqReasoningState initExpRefInfo :: ExpRefInfo o getinfo :: [RefInfo o] -> ExpRefInfo o -- | univar sub v figures out what the name of v -- "outside" of the substitution sub ought to be, if anything. univar :: [CAction o] -> Nat -> Maybe Nat -- | List of the variables instantiated by the substitution subsvars :: [CAction o] -> [Nat] -- | Moves A move is composed of a Cost together with an action -- computing the refined problem. type Move o = Move' (RefInfo o) (Exp o) -- | New constructors Taking a step towards a solution consists in picking -- a constructor and filling in the missing parts with placeholders to be -- discharged later on. newAbs :: MId -> RefCreateEnv blk (Abs (MM a blk)) newLam :: Hiding -> MId -> RefCreateEnv (RefInfo o) (Exp o) newPi :: UId o -> Bool -> Hiding -> RefCreateEnv (RefInfo o) (Exp o) foldArgs :: [(Hiding, MExp o)] -> MArgList o -- | New spine of arguments potentially using placeholders newArgs' :: [Hiding] -> [MExp o] -> RefCreateEnv (RefInfo o) (MArgList o) newArgs :: [Hiding] -> RefCreateEnv (RefInfo o) (MArgList o) -- | New Application node using a new spine of arguments -- respecting the Hiding annotation newApp' :: UId o -> ConstRef o -> [Hiding] -> [MExp o] -> RefCreateEnv (RefInfo o) (Exp o) newApp :: UId o -> ConstRef o -> [Hiding] -> RefCreateEnv (RefInfo o) (Exp o) -- | Equality reasoning steps The begin token is accompanied by two steps -- because it does not make sense to have a derivation any shorter than -- that. eqStep :: UId o -> EqReasoningConsts o -> Move o eqEnd :: UId o -> EqReasoningConsts o -> Move o eqCong :: UId o -> EqReasoningConsts o -> Move o eqSym :: UId o -> EqReasoningConsts o -> Move o eqBeginStep2 :: UId o -> EqReasoningConsts o -> Move o -- | Pick the first unused UId amongst the ones you have seen (GA: ??) -- Defaults to the head of the seen ones. pickUid :: forall o. [UId o] -> [Maybe (UId o)] -> (Maybe (UId o), Bool) extraref :: UId o -> [Maybe (UId o)] -> ConstRef o -> Move o costIncrease :: Cost costUnificationOccurs :: Cost costUnification :: Cost costAppVar :: Cost costAppVarUsed :: Cost costAppHint :: Cost costAppHintUsed :: Cost costAppRecCall :: Cost costAppRecCallUsed :: Cost costAppConstructor :: Cost costAppConstructorSingle :: Cost costAppExtraRef :: Cost costLam :: Cost costLamUnfold :: Cost costPi :: Cost costSort :: Cost costIotaStep :: Cost costInferredTypeUnkown :: Cost costAbsurdLam :: Cost costUnificationIf :: Bool -> Cost costEqStep :: Cost costEqEnd :: Cost costEqSym :: Cost costEqCong :: Cost prioNo :: Prio prioTypeUnknown :: Prio prioTypecheckArgList :: Prio prioInferredTypeUnknown :: Prio prioCompBeta :: Prio prioCompBetaStructured :: Prio prioCompareArgList :: Prio prioCompIota :: Prio prioCompChoice :: Prio prioCompUnif :: Prio prioCompCopy :: Prio prioNoIota :: Prio prioAbsurdLambda :: Prio prioProjIndex :: Prio prioTypecheck :: Bool -> Prio instance Agda.Auto.NarrowingSearch.Refinable (Agda.Auto.Syntax.Exp o) (Agda.Auto.Syntax.RefInfo o) instance Agda.Auto.NarrowingSearch.Refinable (Agda.Auto.Syntax.ArgList o) (Agda.Auto.Syntax.RefInfo o) instance Agda.Auto.NarrowingSearch.Refinable (Agda.Auto.Syntax.ICExp o) (Agda.Auto.Syntax.RefInfo o) instance Agda.Auto.NarrowingSearch.Refinable (Agda.Auto.Syntax.ConstRef o) (Agda.Auto.Syntax.RefInfo o) instance Agda.Auto.NarrowingSearch.Trav a => Agda.Auto.NarrowingSearch.Trav [a] instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.MId, Agda.Auto.Syntax.CExp o) instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.TrBr a o) instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.Exp o) instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.ArgList o) module Agda.Auto.Typecheck -- | Typechecker drives the solution of metas. tcExp :: Bool -> Ctx o -> CExp o -> MExp o -> EE (MyPB o) getDatatype :: ICExp o -> EE (MyMB (Maybe (ICArgList o, [ConstRef o])) o) constructorImpossible :: ICArgList o -> ConstRef o -> EE (MyPB o) unequals :: ICArgList o -> ICArgList o -> ([(Nat, HNExp o)] -> EE (MyPB o)) -> [(Nat, HNExp o)] -> EE (MyPB o) unequal :: ICExp o -> ICExp o -> ([(Nat, HNExp o)] -> EE (MyPB o)) -> [(Nat, HNExp o)] -> EE (MyPB o) traversePi :: Int -> ICExp o -> EE (MyMB (HNExp o) o) tcargs :: Nat -> Bool -> Ctx o -> CExp o -> MArgList o -> MExp o -> Bool -> (CExp o -> MExp o -> EE (MyPB o)) -> EE (MyPB o) addend :: Hiding -> MExp o -> MM (Exp o) blk -> MM (Exp o) blk copyarg :: MExp o -> Bool type HNNBlks o = [HNExp o] noblks :: HNNBlks o addblk :: HNExp o -> HNNBlks o -> HNNBlks o hnn :: ICExp o -> EE (MyMB (HNExp o) o) hnn_blks :: ICExp o -> EE (MyMB (HNExp o, HNNBlks o) o) hnn_checkstep :: ICExp o -> EE (MyMB (HNExp o, Bool) o) hnn' :: ICExp o -> ICArgList o -> EE (MyMB (HNExp o, HNNBlks o) o) hnb :: ICExp o -> ICArgList o -> EE (MyMB (HNExp o) o) data HNRes o HNDone :: Maybe (Metavar (Exp o) (RefInfo o)) -> HNExp o -> HNRes o HNMeta :: ICExp o -> ICArgList o -> [Maybe (UId o)] -> HNRes o hnc :: Bool -> ICExp o -> ICArgList o -> [Maybe (UId o)] -> EE (MyMB (HNRes o) o) hnarglist :: ICArgList o -> EE (MyMB (HNArgList o) o) getNArgs :: Nat -> ICArgList o -> EE (MyMB (Maybe ([ICExp o], ICArgList o)) o) getAllArgs :: ICArgList o -> EE (MyMB [ICExp o] o) data PEval o PENo :: ICExp o -> PEval o PEConApp :: ICExp o -> ConstRef o -> [PEval o] -> PEval o iotastep :: Bool -> HNExp o -> EE (MyMB (Either (ICExp o, ICArgList o) (HNNBlks o)) o) noiotastep :: HNExp o -> EE (MyPB o) noiotastep_term :: ConstRef o -> MArgList o -> EE (MyPB o) data CMode o CMRigid :: Maybe (Metavar (Exp o) (RefInfo o)) -> HNExp o -> CMode o CMFlex :: MM b (RefInfo o) -> CMFlex o -> CMode o data CMFlex o CMFFlex :: ICExp o -> ICArgList o -> [Maybe (UId o)] -> CMFlex o CMFSemi :: Maybe (Metavar (Exp o) (RefInfo o)) -> HNExp o -> CMFlex o CMFBlocked :: Maybe (Metavar (Exp o) (RefInfo o)) -> HNExp o -> CMFlex o comp' :: forall o. Bool -> CExp o -> CExp o -> EE (MyPB o) checkeliminand :: MExp o -> EE (MyPB o) maybeor :: Bool -> Prio -> IO (PB (RefInfo o)) -> IO (PB (RefInfo o)) -> IO (PB (RefInfo o)) iotapossmeta :: ICExp o -> ICArgList o -> EE Bool meta_not_constructor :: ICExp o -> EE (MB Bool (RefInfo o)) calcEqRState :: EqReasoningConsts o -> MExp o -> EE (MyPB o) pickid :: MId -> MId -> MId tcSearch :: Bool -> Ctx o -> CExp o -> MExp o -> EE (MyPB o) module Agda.Auto.CaseSplit abspatvarname :: String costCaseSplitVeryHigh :: Cost costCaseSplitHigh :: Cost costCaseSplitLow :: Cost costAddVarDepth :: Cost data HI a HI :: Hiding -> a -> HI a drophid :: [HI a] -> [a] type CSPat o = HI (CSPatI o) type CSCtx o = [HI (MId, MExp o)] data CSPatI o CSPatConApp :: ConstRef o -> [CSPat o] -> CSPatI o CSPatProj :: ConstRef o -> CSPatI o CSPatVar :: Nat -> CSPatI o CSPatExp :: MExp o -> CSPatI o CSWith :: MExp o -> CSPatI o CSAbsurd :: CSPatI o CSOmittedArg :: CSPatI o type Sol o = [(CSCtx o, [CSPat o], Maybe (MExp o))] caseSplitSearch :: forall o. IORef Int -> Int -> [ConstRef o] -> Maybe (EqReasoningConsts o) -> Int -> Cost -> ConstRef o -> CSCtx o -> MExp o -> [CSPat o] -> IO [Sol o] caseSplitSearch' :: forall o. (Cost -> CSCtx o -> MExp o -> ([Nat], Nat, [Nat]) -> IO (Maybe (MExp o))) -> Int -> Cost -> ConstRef o -> CSCtx o -> MExp o -> [CSPat o] -> IO [Sol o] infertypevar :: CSCtx o -> Nat -> MExp o class Replace t u where { type ReplaceWith t u; } replace' :: Replace t u => Nat -> MExp (ReplaceWith t u) -> t -> Reader (Nat, Nat) u replace :: Replace t u => Nat -> Nat -> MExp (ReplaceWith t u) -> t -> u betareduce :: MExp o -> MArgList o -> MExp o concatargs :: MArgList o -> MArgList o -> MArgList o replacep :: forall o. Nat -> Nat -> CSPatI o -> MExp o -> CSPat o -> CSPat o type Assignments o = [(Nat, Exp o)] class Unify t where { type UnifiesTo t; } unify' :: Unify t => t -> t -> StateT (Assignments (UnifiesTo t)) Maybe () notequal' :: Unify t => t -> t -> ReaderT (Nat, Nat) (StateT (Assignments (UnifiesTo t)) IO) Bool unify :: Unify t => t -> t -> Maybe (Assignments (UnifiesTo t)) notequal :: Unify t => Nat -> Nat -> t -> t -> IO Bool unifyVar :: Nat -> Exp o -> StateT (Assignments o) Maybe () unifyexp :: MExp o -> MExp o -> Maybe [(Nat, MExp o)] class Lift t lift' :: Lift t => Nat -> Nat -> t -> t lift :: Lift t => Nat -> t -> t removevar :: CSCtx o -> MExp o -> [CSPat o] -> [(Nat, MExp o)] -> (CSCtx o, MExp o, [CSPat o]) findperm :: [MExp o] -> Maybe [Nat] freevars :: FreeVars t => t -> [Nat] applyperm :: [Nat] -> CSCtx o -> MExp o -> [CSPat o] -> (CSCtx o, MExp o, [CSPat o]) ren :: [Nat] -> Nat -> Int seqctx :: CSCtx o -> CSCtx o depthofvar :: Nat -> [CSPat o] -> Nat -- | Speculation: Type class computing the size (?) of a pattern and -- collecting the vars it introduces class LocalTerminationEnv a sizeAndBoundVars :: LocalTerminationEnv a => a -> (Sum Nat, [Nat]) -- | Take a list of patterns and returns (is, size, vars) where -- (speculation): localTerminationEnv :: [CSPat o] -> ([Nat], Nat, [Nat]) localTerminationSidecond :: ([Nat], Nat, [Nat]) -> ConstRef o -> MExp o -> EE (MyPB o) getblks :: MExp o -> IO [Nat] instance Agda.Auto.CaseSplit.LocalTerminationEnv a => Agda.Auto.CaseSplit.LocalTerminationEnv (Agda.Auto.CaseSplit.HI a) instance Agda.Auto.CaseSplit.LocalTerminationEnv (Agda.Auto.CaseSplit.CSPatI o) instance Agda.Auto.CaseSplit.LocalTerminationEnv a => Agda.Auto.CaseSplit.LocalTerminationEnv [a] instance Agda.Auto.CaseSplit.LocalTerminationEnv (Agda.Auto.Syntax.MExp o) instance (Agda.Auto.CaseSplit.LocalTerminationEnv a, Agda.Auto.CaseSplit.LocalTerminationEnv b) => Agda.Auto.CaseSplit.LocalTerminationEnv (a, b) instance Agda.Auto.CaseSplit.LocalTerminationEnv (Agda.Auto.Syntax.MArgList o) instance Agda.Auto.CaseSplit.Lift t => Agda.Auto.CaseSplit.Lift (Agda.Auto.Syntax.Abs t) instance Agda.Auto.CaseSplit.Lift t => Agda.Auto.CaseSplit.Lift (Agda.Auto.NarrowingSearch.MM t r) instance Agda.Auto.CaseSplit.Lift (Agda.Auto.Syntax.Exp o) instance Agda.Auto.CaseSplit.Lift (Agda.Auto.Syntax.ArgList o) instance (Agda.Auto.CaseSplit.Unify t, o GHC.Types.~ Agda.Auto.CaseSplit.UnifiesTo t) => Agda.Auto.CaseSplit.Unify (Agda.Auto.NarrowingSearch.MM t (Agda.Auto.Syntax.RefInfo o)) instance Agda.Auto.CaseSplit.Unify t => Agda.Auto.CaseSplit.Unify (Agda.Auto.Syntax.Abs t) instance Agda.Auto.CaseSplit.Unify (Agda.Auto.Syntax.Exp o) instance Agda.Auto.CaseSplit.Unify (Agda.Auto.Syntax.ArgList o) instance Agda.Auto.CaseSplit.Replace t u => Agda.Auto.CaseSplit.Replace (Agda.Auto.Syntax.Abs t) (Agda.Auto.Syntax.Abs u) instance Agda.Auto.CaseSplit.Replace (Agda.Auto.Syntax.Exp o) (Agda.Auto.Syntax.MExp o) instance Agda.Auto.CaseSplit.Replace t u => Agda.Auto.CaseSplit.Replace (Agda.Auto.NarrowingSearch.MM t (Agda.Auto.Syntax.RefInfo o)) u instance Agda.Auto.CaseSplit.Replace (Agda.Auto.Syntax.ArgList o) (Agda.Auto.Syntax.ArgList o) instance Agda.Auto.Syntax.Renaming (Agda.Auto.CaseSplit.CSPatI o) instance Agda.Auto.Syntax.Renaming t => Agda.Auto.Syntax.Renaming (Agda.Auto.CaseSplit.HI t) -- | Ranges. module Agda.Interaction.Highlighting.Range -- | Character ranges. The first character in the file has position 1. Note -- that the to position is considered to be outside of the range. -- -- Invariant: from <= to. data Range Range :: !Int -> Range [from, to] :: Range -> !Int -- | The Range invariant. rangeInvariant :: Range -> Bool -- | Zero or more consecutive and separated ranges. newtype Ranges Ranges :: [Range] -> Ranges -- | The Ranges invariant. rangesInvariant :: Ranges -> Bool -- | True iff the ranges overlap. -- -- The ranges are assumed to be well-formed. overlapping :: Range -> Range -> Bool overlappings :: Ranges -> Ranges -> Bool empty :: Null a => a -- | Converts a range to a list of positions. rangeToPositions :: Range -> [Int] -- | Converts several ranges to a list of positions. rangesToPositions :: Ranges -> [Int] -- | Converts a Range' to a Ranges. rToR :: Range -> Ranges -- | Converts a Range', seen as a continuous range, to a -- Range. rangeToRange :: Range -> Range -- | minus xs ys computes the difference between xs and -- ys: the result contains those positions which are present in -- xs but not in ys. -- -- Linear in the lengths of the input ranges. minus :: Ranges -> Ranges -> Ranges instance GHC.Show.Show Agda.Interaction.Highlighting.Range.Range instance GHC.Classes.Ord Agda.Interaction.Highlighting.Range.Range instance GHC.Classes.Eq Agda.Interaction.Highlighting.Range.Range instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Range.Ranges instance GHC.Show.Show Agda.Interaction.Highlighting.Range.Ranges instance GHC.Classes.Eq Agda.Interaction.Highlighting.Range.Ranges instance Agda.Utils.Null.Null Agda.Interaction.Highlighting.Range.Range instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Range.Range -- | Maps containing non-overlapping intervals. module Agda.Utils.RangeMap -- | A class that is intended to make it easy to swap between different -- range map implementations. -- -- Note that some RangeMap operations are not included in this -- class. class IsBasicRangeMap a m | m -> a -- | The map singleton rs x contains the ranges from -- rs, and every position in those ranges is associated with -- x. singleton :: IsBasicRangeMap a m => Ranges -> a -> m -- | Converts range maps to IntMaps from positions to values. toMap :: IsBasicRangeMap a m => m -> IntMap a -- | Converts the map to a list. The ranges are non-overlapping and -- non-empty, and earlier ranges precede later ones in the list. toList :: IsBasicRangeMap a m => m -> [(Range, a)] -- | Returns the smallest range covering everything in the map (or -- Nothing, if the range would be empty). -- -- Note that the default implementation of this operation might be -- inefficient. coveringRange :: IsBasicRangeMap a m => m -> Maybe Range -- | Like singleton, but with several Ranges instead of only -- one. several :: (IsBasicRangeMap a hl, Monoid hl) => [Ranges] -> a -> hl -- | A strict pair type where the first argument must be an Int. -- -- This type is included because there is no NFData instance for -- Pair in the package strict before version 4. newtype PairInt a PairInt :: Pair Int a -> PairInt a -- | Maps containing non-overlapping intervals. -- -- The implementation does not use IntMap, because IntMap does not come -- with a constant-time size function. -- -- Note the invariant which RangeMaps should satisfy -- (rangeMapInvariant). newtype RangeMap a RangeMap :: Map Int (PairInt a) -> RangeMap a -- | The keys are starting points of ranges, and the pairs contain -- endpoints and values. [rangeMap] :: RangeMap a -> Map Int (PairInt a) -- | Invariant for RangeMap. -- -- The ranges must not be empty, and they must not overlap. rangeMapInvariant :: RangeMap a -> Bool -- | Converts a list of pairs of ranges and values to a RangeMap. -- The ranges have to be non-overlapping and non-empty, and earlier -- ranges have to precede later ones. fromNonOverlappingNonEmptyAscendingList :: [(Range, a)] -> RangeMap a -- | Inserts a value, along with a corresponding Range, into a -- RangeMap. No attempt is made to merge adjacent ranges with -- equal values. -- -- The function argument is used to combine values. The inserted value is -- given as the first argument to the function. insert :: (a -> a -> a) -> Range -> a -> RangeMap a -> RangeMap a -- | The value of splitAt p f is a pair (f1, f2) -- which contains everything from f. All the positions in -- f1 are less than p, and all the positions in -- f2 are greater than or equal to p. splitAt :: Int -> RangeMap a -> (RangeMap a, RangeMap a) -- | Returns a RangeMap overlapping the given range, as well as the -- rest of the map. insideAndOutside :: Range -> RangeMap a -> (RangeMap a, RangeMap a) -- | Restricts the RangeMap to the given range. restrictTo :: Range -> RangeMap a -> RangeMap a instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.RangeMap.PairInt a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Utils.RangeMap.RangeMap a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.RangeMap.RangeMap a) instance Agda.Utils.Null.Null (Agda.Utils.RangeMap.RangeMap a) instance Agda.Utils.RangeMap.IsBasicRangeMap a (Agda.Utils.RangeMap.RangeMap a) instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Agda.Utils.RangeMap.RangeMap a) instance GHC.Base.Semigroup a => GHC.Base.Monoid (Agda.Utils.RangeMap.RangeMap a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Utils.RangeMap.PairInt a) -- | The treeless syntax is intended to be used as input for the compiler -- backends. It is more low-level than Internal syntax and is not used -- for type checking. -- -- Some of the features of treeless syntax are: - case expressions -- instead of case trees - no instantiated datatypes / constructors module Agda.Syntax.Treeless class Unreachable a -- | Checks if the given expression is unreachable or not. isUnreachable :: Unreachable a => a -> Bool data TError -- | Code which is unreachable. E.g. absurd branches or missing case -- defaults. Runtime behaviour of unreachable code is undefined, but -- preferably the program will exit with an error message. The compiler -- is free to assume that this code is unreachable and to remove it. TUnreachable :: TError -- | Code which could not be obtained because of a hole in the program. -- This should throw a runtime error. The string gives some information -- about the meta variable that got compiled. TMeta :: String -> TError data TAlt -- | Matches on the given constructor. If the match succeeds, the pattern -- variables are prepended to the current environment (pushes all -- existing variables aArity steps further away) TACon :: QName -> Int -> TTerm -> TAlt [aCon] :: TAlt -> QName [aArity] :: TAlt -> Int [aBody] :: TAlt -> TTerm -- | Binds no variables TAGuard :: TTerm -> TTerm -> TAlt [aGuard] :: TAlt -> TTerm [aBody] :: TAlt -> TTerm TALit :: Literal -> TTerm -> TAlt [aLit] :: TAlt -> Literal [aBody] :: TAlt -> TTerm data CaseInfo CaseInfo :: Bool -> CaseType -> CaseInfo [caseLazy] :: CaseInfo -> Bool [caseType] :: CaseInfo -> CaseType data CaseType CTData :: Quantity -> QName -> CaseType CTNat :: CaseType CTInt :: CaseType CTChar :: CaseType CTString :: CaseType CTFloat :: CaseType CTQName :: CaseType -- | Compiler-related primitives. This are NOT the same thing as primitives -- in Agda's surface or internal syntax! Some of the primitives have a -- suffix indicating which type of arguments they take, using the -- following naming convention: Char | Type C | Character F | Float I | -- Integer Q | QName S | String data TPrim PAdd :: TPrim PAdd64 :: TPrim PSub :: TPrim PSub64 :: TPrim PMul :: TPrim PMul64 :: TPrim PQuot :: TPrim PQuot64 :: TPrim PRem :: TPrim PRem64 :: TPrim PGeq :: TPrim PLt :: TPrim PLt64 :: TPrim PEqI :: TPrim PEq64 :: TPrim PEqF :: TPrim PEqS :: TPrim PEqC :: TPrim PEqQ :: TPrim PIf :: TPrim PSeq :: TPrim PITo64 :: TPrim P64ToI :: TPrim data TTerm TVar :: Int -> TTerm TPrim :: TPrim -> TTerm TDef :: QName -> TTerm TApp :: TTerm -> Args -> TTerm TLam :: TTerm -> TTerm TLit :: Literal -> TTerm TCon :: QName -> TTerm -- | introduces a new local binding. The bound term MUST only be evaluated -- if it is used inside the body. Sharing may happen, but is optional. It -- is also perfectly valid to just inline the bound term in the body. TLet :: TTerm -> TTerm -> TTerm -- | Case scrutinee (always variable), case type, default value, -- alternatives First, all TACon alternatives are tried; then all TAGuard -- alternatives in top to bottom order. TACon alternatives must not -- overlap. TCase :: Int -> CaseInfo -> TTerm -> [TAlt] -> TTerm TUnit :: TTerm TSort :: TTerm TErased :: TTerm -- | Used by the GHC backend TCoerce :: TTerm -> TTerm -- | A runtime error, something bad has happened. TError :: TError -> TTerm type Args = [TTerm] -- | The treeless compiler can behave differently depending on the target -- language evaluation strategy. For instance, more aggressive erasure -- for lazy targets. data EvaluationStrategy LazyEvaluation :: EvaluationStrategy EagerEvaluation :: EvaluationStrategy -- | Usage status of function arguments in treeless code. data ArgUsage ArgUsed :: ArgUsage ArgUnused :: ArgUsage data Compiled Compiled :: TTerm -> Maybe [ArgUsage] -> Compiled [cTreeless] :: Compiled -> TTerm -- | Nothing if treeless usage analysis has not run yet. [cArgUsage] :: Compiled -> Maybe [ArgUsage] pattern TPFn :: TPrim -> TTerm -> TTerm pattern TPOp :: TPrim -> TTerm -> TTerm -> TTerm isPrimEq :: TPrim -> Bool -- | Strip leading coercions and indicate whether there were some. coerceView :: TTerm -> (Bool, TTerm) mkTApp :: TTerm -> Args -> TTerm tAppView :: TTerm -> (TTerm, [TTerm]) -- | Expose the format coerce f args. -- -- We fuse coercions, even if interleaving with applications. We assume -- that coercion is powerful enough to satisfy coerce (coerce f a) b -- = coerce f a b coerceAppView :: TTerm -> ((Bool, TTerm), [TTerm]) tLetView :: TTerm -> ([TTerm], TTerm) tLamView :: TTerm -> (Int, TTerm) mkTLam :: Int -> TTerm -> TTerm -- | Introduces a new binding mkLet :: TTerm -> TTerm -> TTerm tInt :: Integer -> TTerm intView :: TTerm -> Maybe Integer word64View :: TTerm -> Maybe Word64 tPlusK :: Integer -> TTerm -> TTerm tNegPlusK :: Integer -> TTerm -> TTerm plusKView :: TTerm -> Maybe (Integer, TTerm) negPlusKView :: TTerm -> Maybe (Integer, TTerm) tOp :: TPrim -> TTerm -> TTerm -> TTerm tUnreachable :: TTerm tIfThenElse :: TTerm -> TTerm -> TTerm -> TTerm -- | filterUsed used args drops those args which are -- labelled ArgUnused in list used. -- -- Specification: -- --
--   filterUsed used args = [ a | (a, ArgUsed) <- zip args $ used ++ repeat ArgUsed ]
--   
-- -- Examples: -- --
--   filterUsed []                 == id
--   filterUsed (repeat ArgUsed)   == id
--   filterUsed (repeat ArgUnused) == const []
--   
filterUsed :: [ArgUsage] -> [a] -> [a] instance GHC.Generics.Generic Agda.Syntax.Treeless.ArgUsage instance GHC.Classes.Ord Agda.Syntax.Treeless.ArgUsage instance GHC.Classes.Eq Agda.Syntax.Treeless.ArgUsage instance GHC.Show.Show Agda.Syntax.Treeless.ArgUsage instance GHC.Show.Show Agda.Syntax.Treeless.EvaluationStrategy instance GHC.Classes.Eq Agda.Syntax.Treeless.EvaluationStrategy instance GHC.Generics.Generic Agda.Syntax.Treeless.TPrim instance GHC.Classes.Ord Agda.Syntax.Treeless.TPrim instance GHC.Classes.Eq Agda.Syntax.Treeless.TPrim instance GHC.Show.Show Agda.Syntax.Treeless.TPrim instance GHC.Generics.Generic Agda.Syntax.Treeless.CaseType instance GHC.Classes.Ord Agda.Syntax.Treeless.CaseType instance GHC.Classes.Eq Agda.Syntax.Treeless.CaseType instance GHC.Show.Show Agda.Syntax.Treeless.CaseType instance GHC.Generics.Generic Agda.Syntax.Treeless.CaseInfo instance GHC.Classes.Ord Agda.Syntax.Treeless.CaseInfo instance GHC.Classes.Eq Agda.Syntax.Treeless.CaseInfo instance GHC.Show.Show Agda.Syntax.Treeless.CaseInfo instance GHC.Generics.Generic Agda.Syntax.Treeless.TError instance GHC.Classes.Ord Agda.Syntax.Treeless.TError instance GHC.Classes.Eq Agda.Syntax.Treeless.TError instance GHC.Show.Show Agda.Syntax.Treeless.TError instance GHC.Generics.Generic Agda.Syntax.Treeless.TAlt instance GHC.Classes.Ord Agda.Syntax.Treeless.TAlt instance GHC.Classes.Eq Agda.Syntax.Treeless.TAlt instance GHC.Show.Show Agda.Syntax.Treeless.TAlt instance GHC.Generics.Generic Agda.Syntax.Treeless.TTerm instance GHC.Classes.Ord Agda.Syntax.Treeless.TTerm instance GHC.Classes.Eq Agda.Syntax.Treeless.TTerm instance GHC.Show.Show Agda.Syntax.Treeless.TTerm instance GHC.Generics.Generic Agda.Syntax.Treeless.Compiled instance GHC.Classes.Ord Agda.Syntax.Treeless.Compiled instance GHC.Classes.Eq Agda.Syntax.Treeless.Compiled instance GHC.Show.Show Agda.Syntax.Treeless.Compiled instance Agda.Syntax.Treeless.Unreachable Agda.Syntax.Treeless.TAlt instance Agda.Syntax.Treeless.Unreachable Agda.Syntax.Treeless.TTerm instance Agda.Syntax.Position.KillRange Agda.Syntax.Treeless.Compiled instance Control.DeepSeq.NFData Agda.Syntax.Treeless.Compiled instance Control.DeepSeq.NFData Agda.Syntax.Treeless.TTerm instance Control.DeepSeq.NFData Agda.Syntax.Treeless.TAlt instance Control.DeepSeq.NFData Agda.Syntax.Treeless.TError instance Control.DeepSeq.NFData Agda.Syntax.Treeless.CaseInfo instance Control.DeepSeq.NFData Agda.Syntax.Treeless.CaseType instance Control.DeepSeq.NFData Agda.Syntax.Treeless.TPrim instance Control.DeepSeq.NFData Agda.Syntax.Treeless.ArgUsage -- | Translates guard alternatives to if-then-else cascades. -- -- The builtin translation must be run before this transformation. module Agda.Compiler.Treeless.GuardsToPrims convertGuards :: TTerm -> TTerm module Agda.Compiler.Treeless.AsPatterns -- | We lose track of @-patterns in the internal syntax. This pass puts -- them back. recoverAsPatterns :: Monad m => TTerm -> m TTerm instance GHC.Show.Show Agda.Compiler.Treeless.AsPatterns.AsPat module Agda.Syntax.Parser.Tokens data Token TokKeyword :: Keyword -> Interval -> Token TokId :: (Interval, String) -> Token TokQId :: [(Interval, String)] -> Token TokLiteral :: RLiteral -> Token TokSymbol :: Symbol -> Interval -> Token -- | Arbitrary string (not enclosed in double quotes), used in pragmas. TokString :: (Interval, String) -> Token TokTeX :: (Interval, String) -> Token TokMarkup :: (Interval, String) -> Token TokComment :: (Interval, String) -> Token TokDummy :: Token TokEOF :: Interval -> Token data Keyword KwLet :: Keyword KwIn :: Keyword KwWhere :: Keyword KwData :: Keyword KwCoData :: Keyword KwDo :: Keyword KwPostulate :: Keyword KwAbstract :: Keyword KwPrivate :: Keyword KwInstance :: Keyword KwInterleaved :: Keyword KwMutual :: Keyword KwOverlap :: Keyword KwOpen :: Keyword KwImport :: Keyword KwModule :: Keyword KwPrimitive :: Keyword KwMacro :: Keyword KwInfix :: Keyword KwInfixL :: Keyword KwInfixR :: Keyword KwWith :: Keyword KwRewrite :: Keyword KwForall :: Keyword KwRecord :: Keyword KwConstructor :: Keyword KwField :: Keyword KwInductive :: Keyword KwCoInductive :: Keyword KwEta :: Keyword KwNoEta :: Keyword KwHiding :: Keyword KwUsing :: Keyword KwRenaming :: Keyword KwTo :: Keyword KwPublic :: Keyword KwOPTIONS :: Keyword KwBUILTIN :: Keyword KwLINE :: Keyword KwFOREIGN :: Keyword KwCOMPILE :: Keyword KwIMPOSSIBLE :: Keyword KwSTATIC :: Keyword KwINJECTIVE :: Keyword KwINLINE :: Keyword KwNOINLINE :: Keyword KwETA :: Keyword KwNO_TERMINATION_CHECK :: Keyword KwTERMINATING :: Keyword KwNON_TERMINATING :: Keyword KwNOT_PROJECTION_LIKE :: Keyword KwNON_COVERING :: Keyword KwWARNING_ON_USAGE :: Keyword KwWARNING_ON_IMPORT :: Keyword KwMEASURE :: Keyword KwDISPLAY :: Keyword KwREWRITE :: Keyword KwQuote :: Keyword KwQuoteTerm :: Keyword KwUnquote :: Keyword KwUnquoteDecl :: Keyword KwUnquoteDef :: Keyword KwSyntax :: Keyword KwPatternSyn :: Keyword KwTactic :: Keyword KwCATCHALL :: Keyword KwVariable :: Keyword KwNO_POSITIVITY_CHECK :: Keyword KwPOLARITY :: Keyword KwNO_UNIVERSE_CHECK :: Keyword -- | Unconditional layout keywords. -- -- Some keywords introduce layout only in certain circumstances, these -- are not included here. layoutKeywords :: [Keyword] data Symbol SymDot :: Symbol SymSemi :: Symbol SymVirtualSemi :: Symbol SymBar :: Symbol SymColon :: Symbol SymArrow :: Symbol SymEqual :: Symbol SymLambda :: Symbol SymUnderscore :: Symbol SymQuestionMark :: Symbol SymAs :: Symbol SymOpenParen :: Symbol SymCloseParen :: Symbol SymOpenIdiomBracket :: Symbol SymCloseIdiomBracket :: Symbol SymEmptyIdiomBracket :: Symbol SymDoubleOpenBrace :: Symbol SymDoubleCloseBrace :: Symbol SymOpenBrace :: Symbol SymCloseBrace :: Symbol SymOpenVirtualBrace :: Symbol SymCloseVirtualBrace :: Symbol SymOpenPragma :: Symbol SymClosePragma :: Symbol SymEllipsis :: Symbol SymDotDot :: Symbol -- | A misplaced end-comment "-}". SymEndComment :: Symbol instance GHC.Show.Show Agda.Syntax.Parser.Tokens.Keyword instance GHC.Classes.Eq Agda.Syntax.Parser.Tokens.Keyword instance GHC.Show.Show Agda.Syntax.Parser.Tokens.Symbol instance GHC.Classes.Eq Agda.Syntax.Parser.Tokens.Symbol instance GHC.Show.Show Agda.Syntax.Parser.Tokens.Token instance GHC.Classes.Eq Agda.Syntax.Parser.Tokens.Token instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Tokens.Token -- | Pretty printer for the concrete syntax. module Agda.Syntax.Concrete.Pretty newtype Tel Tel :: Telescope -> Tel data NamedBinding NamedBinding :: Bool -> NamedArg Binder -> NamedBinding [withHiding] :: NamedBinding -> Bool [namedBinding] :: NamedBinding -> NamedArg Binder bracesAndSemicolons :: Foldable t => t Doc -> Doc -- | prettyHiding info visible doc puts the correct braces around -- doc according to info info and returns visible -- doc if the we deal with a visible thing. prettyHiding :: LensHiding a => a -> (Doc -> Doc) -> Doc -> Doc prettyRelevance :: LensRelevance a => a -> Doc -> Doc prettyQuantity :: LensQuantity a => a -> Doc -> Doc prettyErased :: Erased -> Doc -> Doc prettyCohesion :: LensCohesion a => a -> Doc -> Doc prettyTactic :: BoundName -> Doc -> Doc prettyFiniteness :: BoundName -> Doc -> Doc prettyTactic' :: TacticAttribute -> Doc -> Doc -- | Show the attributes necessary to recover a modality, in long-form -- (e.g. using at-syntax rather than dots). For the default modality, the -- result is at-ω (rather than the empty document). Suitable for showing -- modalities outside of binders. attributesForModality :: Modality -> Doc isLabeled :: NamedArg Binder -> Maybe ArgName smashTel :: Telescope -> Telescope pHasEta0 :: HasEta0 -> Doc pRecordDirective :: RecordDirective -> Doc pRecord :: Name -> RecordDirectives -> [LamBinding] -> Maybe Expr -> [Declaration] -> Doc prettyOpApp :: forall a. Pretty a => QName -> [NamedArg (MaybePlaceholder a)] -> [Doc] instance GHC.Show.Show Agda.Syntax.Concrete.Expr instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Concrete.OpApp a) instance GHC.Show.Show Agda.Syntax.Concrete.Declaration instance GHC.Show.Show Agda.Syntax.Concrete.Pattern instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Concrete.Binder' a) instance GHC.Show.Show Agda.Syntax.Concrete.TypedBinding instance GHC.Show.Show Agda.Syntax.Concrete.LamBinding instance GHC.Show.Show Agda.Syntax.Concrete.BoundName instance GHC.Show.Show Agda.Syntax.Concrete.ModuleAssignment instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Agda.Syntax.Common.ImportDirective' a b) instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Agda.Syntax.Common.Using' a b) instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Agda.Syntax.Common.Renaming' a b) instance GHC.Show.Show Agda.Syntax.Concrete.Pragma instance GHC.Show.Show Agda.Syntax.Concrete.RHS instance GHC.Show.Show Agda.Syntax.Concrete.LHS instance GHC.Show.Show Agda.Syntax.Concrete.LHSCore instance GHC.Show.Show Agda.Syntax.Concrete.LamClause instance GHC.Show.Show Agda.Syntax.Concrete.WhereClause instance GHC.Show.Show Agda.Syntax.Concrete.ModuleApplication instance GHC.Show.Show Agda.Syntax.Concrete.DoStmt instance GHC.Show.Show Agda.Syntax.Concrete.Module instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Expr instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Pretty.Tel instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Pretty.NamedBinding instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.LamBinding instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.TypedBinding instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (a, b) instance Agda.Utils.Pretty.Pretty (Agda.Syntax.Fixity.ThingWithFixity Agda.Syntax.Concrete.Name.Name) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.WithHiding a) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Relevance instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Q0Origin instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Q1Origin instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.QωOrigin instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Quantity instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Cohesion instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Modality instance Agda.Utils.Pretty.Pretty (Agda.Syntax.Concrete.OpApp Agda.Syntax.Concrete.Expr) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.MaybePlaceholder a) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Data.Either.Either a b) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Concrete.FieldAssignment' a) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.ModuleAssignment instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.LamClause instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.BoundName instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Concrete.Binder' a) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.RHS instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.WhereClause instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.LHS instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.LHSCore instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.ModuleApplication instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.DoStmt instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Declaration instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.OpenShortHand instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Pragma instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Associativity instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.FixityLevel instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Fixity instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.NotationPart instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.Fixity' instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Arg a) instance Agda.Utils.Pretty.Pretty e => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Named_ e) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Pattern instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.ImportDirective' a b) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Using' a b) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Renaming' a b) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.ImportedName' a b) -- | Split tree for transforming pattern clauses into case trees. -- -- The coverage checker generates a split tree from the clauses. The -- clause compiler uses it to transform clauses to case trees. -- -- The initial problem is a set of clauses. The root node designates on -- which argument to split and has subtrees for all the constructors. -- Splitting continues until there is only a single clause left at each -- leaf of the split tree. module Agda.TypeChecking.Coverage.SplitTree type SplitTree = SplitTree' SplitTag type SplitTrees = SplitTrees' SplitTag -- | Abstract case tree shape. data SplitTree' a -- | No more splits coming. We are at a single, all-variable clause. SplittingDone :: Int -> SplitTree' a -- | The number of variables bound in the clause [splitBindings] :: SplitTree' a -> Int -- | A split is necessary. SplitAt :: Arg Int -> LazySplit -> SplitTrees' a -> SplitTree' a -- | Arg. no to split at. [splitArg] :: SplitTree' a -> Arg Int [splitLazy] :: SplitTree' a -> LazySplit -- | Sub split trees. [splitTrees] :: SplitTree' a -> SplitTrees' a data LazySplit LazySplit :: LazySplit StrictSplit :: LazySplit -- | Split tree branching. A finite map from constructor names to -- splittrees A list representation seems appropriate, since we are -- expecting not so many constructors per data type, and there is no need -- for random access. type SplitTrees' a = [(a, SplitTree' a)] -- | Tag for labeling branches of a split tree. Each branch is associated -- to either a constructor or a literal, or is a catchall branch -- (currently only used for splitting on a literal type). data SplitTag SplitCon :: QName -> SplitTag SplitLit :: Literal -> SplitTag SplitCatchall :: SplitTag data SplitTreeLabel a SplitTreeLabel :: Maybe a -> Maybe (Arg Int) -> LazySplit -> Maybe Int -> SplitTreeLabel a -- | Nothing for root of split tree [lblConstructorName] :: SplitTreeLabel a -> Maybe a [lblSplitArg] :: SplitTreeLabel a -> Maybe (Arg Int) [lblLazy] :: SplitTreeLabel a -> LazySplit [lblBindings] :: SplitTreeLabel a -> Maybe Int -- | Convert a split tree into a Tree (for printing). toTree :: SplitTree' a -> Tree (SplitTreeLabel a) toTrees :: SplitTrees' a -> Forest (SplitTreeLabel a) instance GHC.Generics.Generic Agda.TypeChecking.Coverage.SplitTree.LazySplit instance GHC.Classes.Ord Agda.TypeChecking.Coverage.SplitTree.LazySplit instance GHC.Classes.Eq Agda.TypeChecking.Coverage.SplitTree.LazySplit instance GHC.Show.Show Agda.TypeChecking.Coverage.SplitTree.LazySplit instance GHC.Generics.Generic (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a) instance GHC.Generics.Generic Agda.TypeChecking.Coverage.SplitTree.SplitTag instance GHC.Classes.Ord Agda.TypeChecking.Coverage.SplitTree.SplitTag instance GHC.Classes.Eq Agda.TypeChecking.Coverage.SplitTree.SplitTag instance GHC.Show.Show Agda.TypeChecking.Coverage.SplitTree.SplitTag instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Coverage.SplitTree.SplitTreeLabel a) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Coverage.SplitTree.SplitTag instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Coverage.SplitTree.SplitTag instance Control.DeepSeq.NFData Agda.TypeChecking.Coverage.SplitTree.SplitTag instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a) instance Control.DeepSeq.NFData Agda.TypeChecking.Coverage.SplitTree.LazySplit -- | As a concrete name, a notation is a non-empty list of alternating -- IdParts and holes. In contrast to concrete names, holes can be -- binders. -- -- Example: syntax fmap (λ x → e) xs = for x ∈ xs return e -- -- The declared notation for fmap is for_∈_return_ -- where the first hole is a binder. module Agda.Syntax.Notation -- | Data type constructed in the Happy parser; converted to -- NotationPart before it leaves the Happy code. data HoleName -- | λ x₁ … xₙ → y: The first argument contains the bound names. LambdaHole :: List1 RString -> RString -> HoleName [_bindHoleNames] :: HoleName -> List1 RString [holeName] :: HoleName -> RString -- | Simple named hole with hiding. ExprHole :: RString -> HoleName [holeName] :: HoleName -> RString -- | Is the hole a binder? isLambdaHole :: HoleName -> Bool -- | Get a flat list of identifier parts of a notation. stringParts :: Notation -> [String] -- | Target argument position of a part (Nothing if it is not a hole). holeTarget :: NotationPart -> Maybe Int -- | Is the part a hole? isAHole :: NotationPart -> Bool -- | Is the part a binder? isBinder :: NotationPart -> Bool -- | Classification of notations. data NotationKind -- | Ex: _bla_blub_. InfixNotation :: NotationKind -- | Ex: _bla_blub. PrefixNotation :: NotationKind -- | Ex: bla_blub_. PostfixNotation :: NotationKind -- | Ex: bla_blub. NonfixNotation :: NotationKind NoNotation :: NotationKind -- | Classify a notation by presence of leading and/or trailing -- normal holes. notationKind :: Notation -> NotationKind -- | From notation with names to notation with indices. -- -- An example (with some parts of the code omitted): The lists -- ["for", "x", "∈", "xs", "return", "e"] and -- [LambdaHole ("x" :| []) "e", ExprHole "xs"] are -- mapped to the following notation: [ IdPart "for" , -- VarPart (BoundVariablePosition 0 0) , IdPart "∈" -- , HolePart 1 , IdPart "return" , HolePart 0 ] -- mkNotation :: [NamedArg HoleName] -> [RString] -> Either String Notation -- | All the notation information related to a name. data NewNotation NewNotation :: QName -> Set Name -> Fixity -> Notation -> Bool -> NewNotation [notaName] :: NewNotation -> QName -- | The names the syntax and/or fixity belong to. -- -- Invariant: The set is non-empty. Every name in the list matches -- notaName. [notaNames] :: NewNotation -> Set Name -- | Associativity and precedence (fixity) of the names. [notaFixity] :: NewNotation -> Fixity -- | Syntax associated with the names. [notation] :: NewNotation -> Notation -- | True if the notation comes from an operator (rather than a syntax -- declaration). [notaIsOperator] :: NewNotation -> Bool -- | If an operator has no specific notation, then it is computed from its -- name. namesToNotation :: QName -> Name -> NewNotation -- | Replace noFixity by defaultFixity. useDefaultFixity :: NewNotation -> NewNotation -- | Return the IdParts of a notation, the first part qualified, the -- other parts unqualified. This allows for qualified use of operators, -- e.g., M.for x ∈ xs return e, or x ℕ.+ y. notationNames :: NewNotation -> [QName] -- | Create a Notation (without binders) from a concrete -- Name. Does the obvious thing: Holes become -- HoleParts, Ids become IdParts. If Name -- has no Holes, it returns noNotation. syntaxOf :: Name -> Notation -- | Merges NewNotations that have the same precedence level and -- notation, with two exceptions: -- -- -- -- If NewNotations that are merged have distinct associativities, -- then they get NonAssoc as their associativity. -- -- Precondition: No Name may occur in more than one list element. -- Every NewNotation must have the same notaName. -- -- Postcondition: No Name occurs in more than one list element. mergeNotations :: [NewNotation] -> [NewNotation] -- | Check if a notation contains any lambdas (in which case it cannot be -- used in a pattern). isLambdaNotation :: NewNotation -> Bool -- | Lens for Fixity in NewNotation. _notaFixity :: Lens' Fixity NewNotation -- | Sections, as well as non-sectioned operators. data NotationSection NotationSection :: NewNotation -> NotationKind -> Maybe FixityLevel -> Bool -> NotationSection [sectNotation] :: NotationSection -> NewNotation -- | For non-sectioned operators this should match the notation's -- notationKind. [sectKind] :: NotationSection -> NotationKind -- | Effective precedence level. Nothing for closed notations. [sectLevel] :: NotationSection -> Maybe FixityLevel -- | False for non-sectioned operators. [sectIsSection] :: NotationSection -> Bool -- | Converts a notation to a (non-)section. noSection :: NewNotation -> NotationSection instance GHC.Generics.Generic Agda.Syntax.Notation.NotationKind instance GHC.Show.Show Agda.Syntax.Notation.NotationKind instance GHC.Classes.Eq Agda.Syntax.Notation.NotationKind instance GHC.Generics.Generic Agda.Syntax.Notation.NewNotation instance GHC.Show.Show Agda.Syntax.Notation.NewNotation instance GHC.Generics.Generic Agda.Syntax.Notation.NotationSection instance GHC.Show.Show Agda.Syntax.Notation.NotationSection instance Agda.Utils.Pretty.Pretty Agda.Syntax.Notation.NotationSection instance Control.DeepSeq.NFData Agda.Syntax.Notation.NotationSection instance Agda.Syntax.Common.LensFixity Agda.Syntax.Notation.NewNotation instance Agda.Utils.Pretty.Pretty Agda.Syntax.Notation.NewNotation instance Control.DeepSeq.NFData Agda.Syntax.Notation.NewNotation instance Agda.Utils.Pretty.Pretty Agda.Syntax.Notation.NotationKind instance Control.DeepSeq.NFData Agda.Syntax.Notation.NotationKind -- | Agda-specific benchmarking structure. module Agda.Benchmarking -- | Phases to allocate CPU time to. data Phase -- | Happy parsing and operator parsing. Parsing :: Phase -- | Import chasing. Import :: Phase -- | Reading interface files. Deserialization :: Phase -- | Scope checking and translation to abstract syntax. Scoping :: Phase -- | Type checking and translation to internal syntax. Typing :: Phase -- | Termination checking. Termination :: Phase -- | Positivity checking and polarity computation. Positivity :: Phase -- | Injectivity checking. Injectivity :: Phase -- | Checking for projection likeness. ProjectionLikeness :: Phase -- | Coverage checking and compilation to case trees. Coverage :: Phase -- | Generating highlighting info. Highlighting :: Phase -- | Writing interface files. Serialization :: Phase -- | Deac code elimination. DeadCode :: Phase -- | Subphase for Termination. Graph :: Phase -- | Subphase for Termination. RecCheck :: Phase -- | Subphase for Termination. Reduce :: Phase -- | Subphase for Termination. Level :: Phase -- | Subphase for Termination. Compare :: Phase -- | Subphase for Termination. With :: Phase -- | Subphase for Import. ModuleName :: Phase -- | Subphase for Deserialization: compacting interfaces. Compaction :: Phase -- | Subphase for Serialization. BuildInterface :: Phase -- | Subphase for Serialization. Sort :: Phase -- | Subphase for Serialization. BinaryEncode :: Phase -- | Subphase for Serialization. Compress :: Phase -- | Subphase for Parsing. OperatorsExpr :: Phase -- | Subphase for Parsing. OperatorsPattern :: Phase -- | Subphase for Typing: free variable computation. Free :: Phase -- | Subphase for Typing: occurs check for solving metas. OccursCheck :: Phase -- | Subphase for Typing: checking the LHS CheckLHS :: Phase -- | Subphase for Typing: checking the RHS CheckRHS :: Phase -- | Subphase for Typing: checking a type signature TypeSig :: Phase -- | Subphase for Typing: generalizing over variables Generalize :: Phase -- | Subphase for Typing: solving instance goals InstanceSearch :: Phase -- | Subphase for CheckLHS: unification of the indices UnifyIndices :: Phase -- | Pretty printing names. InverseScopeLookup :: Phase TopModule :: TopLevelModuleName -> Phase Definition :: QName -> Phase type Benchmark = Benchmark Phase type Account = Account Phase isModuleAccount :: Account -> Bool isDefAccount :: Account -> Bool isInternalAccount :: Account -> Bool -- | Global variable to store benchmark statistics. benchmarks :: IORef Benchmark -- | Benchmark an IO computation and bill it to the given account. billToIO :: Account -> IO a -> IO a -- | Benchmark a pure computation and bill it to the given account. billToPure :: Account -> a -> a instance GHC.Generics.Generic Agda.Benchmarking.Phase instance GHC.Show.Show Agda.Benchmarking.Phase instance GHC.Classes.Ord Agda.Benchmarking.Phase instance GHC.Classes.Eq Agda.Benchmarking.Phase instance Agda.Utils.Pretty.Pretty Agda.Benchmarking.Phase instance Control.DeepSeq.NFData Agda.Benchmarking.Phase instance Agda.Utils.Benchmark.MonadBench GHC.Types.IO -- | Tools for patterns in concrete syntax. module Agda.Syntax.Concrete.Pattern -- | Check for ellipsis .... class IsEllipsis a isEllipsis :: IsEllipsis a => a -> Bool -- | Has the lhs an occurrence of the ellipsis ...? class HasEllipsis a hasEllipsis :: HasEllipsis a => a -> Bool -- | Check for with-pattern | p. class IsWithP p isWithP :: IsWithP p => p -> Maybe p isWithP :: (IsWithP p, IsWithP q, Decoration f, f q ~ p) => p -> Maybe p -- | The next patterns are ... -- -- (This view discards PatInfo.) data LHSPatternView -- | Application patterns (non-empty list). LHSAppP :: [NamedArg Pattern] -> LHSPatternView -- | With patterns (non-empty list). These patterns are not prefixed with -- WithP. LHSWithP :: [Pattern] -> LHSPatternView -- | Construct the LHSPatternView of the given list (if not empty). -- -- Return the view and the remaining patterns. lhsPatternView :: [NamedArg Pattern] -> Maybe (LHSPatternView, [NamedArg Pattern]) -- | Add applicative patterns (non-projection / non-with patterns) to the -- right. lhsCoreApp :: LHSCore -> [NamedArg Pattern] -> LHSCore -- | Add with-patterns to the right. lhsCoreWith :: LHSCore -> [Pattern] -> LHSCore -- | Append patterns to LHSCore, separating with patterns from the -- rest. lhsCoreAddSpine :: LHSCore -> [NamedArg Pattern] -> LHSCore -- | Modify the Pattern component in LHS. mapLhsOriginalPattern :: (Pattern -> Pattern) -> LHS -> LHS -- | Effectfully modify the Pattern component in LHS. mapLhsOriginalPatternM :: (Functor m, Applicative m) => (Pattern -> m Pattern) -> LHS -> m LHS -- | Does the LHS contain projection patterns? hasCopatterns :: LHSCore -> Bool -- | Generic pattern traversal. -- -- See APatternLike. class CPatternLike p -- | Fold pattern. foldrCPattern :: (CPatternLike p, Monoid m) => (Pattern -> m -> m) -> p -> m -- | Fold pattern. foldrCPattern :: (CPatternLike p, Monoid m, Foldable f, CPatternLike q, f q ~ p) => (Pattern -> m -> m) -> p -> m -- | Traverse pattern with option of post-traversal modification. traverseCPatternA :: (CPatternLike p, Applicative m, Functor m) => (Pattern -> m Pattern -> m Pattern) -> p -> m p -- | Traverse pattern with option of post-traversal modification. traverseCPatternA :: (CPatternLike p, Traversable f, CPatternLike q, f q ~ p, Applicative m, Functor m) => (Pattern -> m Pattern -> m Pattern) -> p -> m p -- | Traverse pattern. traverseCPatternM :: (CPatternLike p, Monad m) => (Pattern -> m Pattern) -> (Pattern -> m Pattern) -> p -> m p -- | Traverse pattern. traverseCPatternM :: (CPatternLike p, Traversable f, CPatternLike q, f q ~ p, Monad m) => (Pattern -> m Pattern) -> (Pattern -> m Pattern) -> p -> m p -- | Compute a value from each subpattern and collect all values in a -- monoid. foldCPattern :: (CPatternLike p, Monoid m) => (Pattern -> m) -> p -> m -- | Traverse pattern(s) with a modification before the recursive descent. preTraverseCPatternM :: (CPatternLike p, Monad m) => (Pattern -> m Pattern) -> p -> m p -- | Traverse pattern(s) with a modification after the recursive descent. postTraverseCPatternM :: (CPatternLike p, Monad m) => (Pattern -> m Pattern) -> p -> m p -- | Map pattern(s) with a modification after the recursive descent. mapCPattern :: CPatternLike p => (Pattern -> Pattern) -> p -> p -- | Get all the identifiers in a pattern in left-to-right order. -- -- Implemented using difference lists. patternQNames :: CPatternLike p => p -> [QName] -- | Get all the identifiers in a pattern in left-to-right order. patternNames :: Pattern -> [Name] -- | Does the pattern contain a with-pattern? (Shortcutting.) hasWithPatterns :: CPatternLike p => p -> Bool -- | Is WithP? isWithPattern :: Pattern -> Bool -- | Count the number of with-subpatterns in a pattern? numberOfWithPatterns :: CPatternLike p => p -> Int -- | Compute the context in which the ellipsis occurs, if at all. If there -- are several occurrences, this is an error. This only counts ellipsis -- that haven't already been expanded. hasEllipsis' :: CPatternLike p => p -> AffineHole Pattern p reintroduceEllipsis :: ExpandedEllipsis -> Pattern -> Pattern splitEllipsis :: IsWithP p => Int -> [p] -> ([p], [p]) -- | View a pattern p as a list p0 .. pn where -- p0 is the identifier (in most cases a constructor). -- -- Pattern needs to be parsed already (operators resolved). patternAppView :: Pattern -> List1 (NamedArg Pattern) instance Agda.Syntax.Concrete.Pattern.CPatternLike Agda.Syntax.Concrete.Pattern instance (Agda.Syntax.Concrete.Pattern.CPatternLike a, Agda.Syntax.Concrete.Pattern.CPatternLike b) => Agda.Syntax.Concrete.Pattern.CPatternLike (a, b) instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike (Agda.Syntax.Common.Arg p) instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike (Agda.Syntax.Common.Named n p) instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike [p] instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike (Agda.Utils.List1.List1 p) instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike (Agda.Utils.List2.List2 p) instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike (GHC.Maybe.Maybe p) instance Agda.Syntax.Concrete.Pattern.CPatternLike p => Agda.Syntax.Concrete.Pattern.CPatternLike (Agda.Syntax.Concrete.FieldAssignment' p) instance Agda.Syntax.Concrete.Pattern.IsWithP Agda.Syntax.Concrete.Pattern instance Agda.Syntax.Concrete.Pattern.IsWithP p => Agda.Syntax.Concrete.Pattern.IsWithP (Agda.Syntax.Common.Arg p) instance Agda.Syntax.Concrete.Pattern.IsWithP p => Agda.Syntax.Concrete.Pattern.IsWithP (Agda.Syntax.Common.Named n p) instance Agda.Syntax.Concrete.Pattern.HasEllipsis Agda.Syntax.Concrete.Pattern instance Agda.Syntax.Concrete.Pattern.HasEllipsis Agda.Syntax.Concrete.LHS instance Agda.Syntax.Concrete.Pattern.IsEllipsis Agda.Syntax.Concrete.Pattern module Agda.Syntax.Concrete.Operators.Parser placeholder :: PositionInName -> Parser e (MaybePlaceholder e) maybePlaceholder :: Maybe PositionInName -> Parser e e -> Parser e (MaybePlaceholder e) satNoPlaceholder :: (e -> Maybe a) -> Parser e a data ExprView e LocalV :: QName -> ExprView e WildV :: e -> ExprView e OtherV :: e -> ExprView e AppV :: e -> NamedArg e -> ExprView e -- | The QName is possibly ambiguous, but it must correspond to one -- of the names in the set. OpAppV :: QName -> Set Name -> OpAppArgs' e -> ExprView e HiddenArgV :: Named_ e -> ExprView e InstanceArgV :: Named_ e -> ExprView e LamV :: List1 LamBinding -> e -> ExprView e ParenV :: e -> ExprView e class HasRange e => IsExpr e exprView :: IsExpr e => e -> ExprView e unExprView :: IsExpr e => ExprView e -> e patternView :: IsExpr e => e -> Maybe Pattern -- | Should sections be parsed? data ParseSections ParseSections :: ParseSections DoNotParseSections :: ParseSections -- | Runs a parser. If sections should be parsed, then identifiers with at -- least two name parts are split up into multiple tokens, using -- PositionInName to record the tokens' original positions within -- their respective identifiers. parse :: IsExpr e => (ParseSections, Parser e a) -> [e] -> [a] -- | Parse a specific identifier as a NamePart partP :: IsExpr e => [Name] -> RawName -> Parser e Range -- | Parses a split-up, unqualified name consisting of at least two name -- parts. -- -- The parser does not check that underscores and other name parts -- alternate. The range of the resulting name is the range of the first -- name part that is not an underscore. atLeastTwoParts :: IsExpr e => Parser e Name -- | Parses a potentially pattern-matching binder patternBinder :: IsExpr e => Parser e Binder -- | Used to define the return type of opP. type family OperatorType (k :: NotationKind) (e :: Type) :: Type -- | A singleton type for NotationKind (except for the constructor -- NoNotation). data NK (k :: NotationKind) :: Type [In] :: NK 'InfixNotation [Pre] :: NK 'PrefixNotation [Post] :: NK 'PostfixNotation [Non] :: NK 'NonfixNotation -- | Parse the "operator part" of the given notation. -- -- Normal holes (but not binders) at the beginning and end are ignored. -- -- If the notation does not contain any binders, then a section notation -- is allowed. opP :: forall e k. IsExpr e => ParseSections -> Parser e e -> NewNotation -> NK k -> Parser e (OperatorType k e) argsP :: IsExpr e => Parser e e -> Parser e [NamedArg e] appP :: IsExpr e => Parser e e -> Parser e [NamedArg e] -> Parser e e atomP :: IsExpr e => (QName -> Bool) -> Parser e e instance GHC.Show.Show Agda.Syntax.Concrete.Operators.Parser.ParseSections instance GHC.Classes.Eq Agda.Syntax.Concrete.Operators.Parser.ParseSections instance Agda.Syntax.Concrete.Operators.Parser.IsExpr e => Agda.Syntax.Position.HasRange (Agda.Syntax.Concrete.Operators.Parser.ExprView e) instance Agda.Syntax.Concrete.Operators.Parser.IsExpr Agda.Syntax.Concrete.Expr instance Agda.Syntax.Concrete.Operators.Parser.IsExpr Agda.Syntax.Concrete.Pattern -- | Generic traversal and reduce for concrete syntax, in the style of -- Agda.Syntax.Internal.Generic. -- -- However, here we use the terminology of Traversable. module Agda.Syntax.Concrete.Generic -- | Generic traversals for concrete expressions. -- -- Note: does not go into patterns! class ExprLike a -- | This corresponds to map. mapExpr :: ExprLike a => (Expr -> Expr) -> a -> a -- | This corresponds to foldMap. foldExpr :: (ExprLike a, Monoid m) => (Expr -> m) -> a -> m -- | This corresponds to mapM. traverseExpr :: (ExprLike a, Monad m) => (Expr -> m Expr) -> a -> m a -- | This corresponds to map. mapExpr :: (ExprLike a, Functor t, ExprLike b, t b ~ a) => (Expr -> Expr) -> a -> a -- | This corresponds to foldMap. foldExpr :: (ExprLike a, Monoid m, Foldable t, ExprLike b, t b ~ a) => (Expr -> m) -> a -> m -- | This corresponds to mapM. traverseExpr :: (ExprLike a, Monad m, Traversable t, ExprLike b, t b ~ a) => (Expr -> m Expr) -> a -> m a instance Agda.Syntax.Concrete.Generic.ExprLike () instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Concrete.Generic.ExprLike GHC.Types.Bool instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike [a] instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Utils.List1.List1 a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Utils.List2.List2 a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (GHC.Maybe.Maybe a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Common.WithHiding a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Common.MaybePlaceholder a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Concrete.RHS' a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Concrete.TypedBinding' a) instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Concrete.WhereClause' a) instance (Agda.Syntax.Concrete.Generic.ExprLike a, Agda.Syntax.Concrete.Generic.ExprLike b) => Agda.Syntax.Concrete.Generic.ExprLike (Data.Either.Either a b) instance (Agda.Syntax.Concrete.Generic.ExprLike a, Agda.Syntax.Concrete.Generic.ExprLike b) => Agda.Syntax.Concrete.Generic.ExprLike (a, b) instance (Agda.Syntax.Concrete.Generic.ExprLike a, Agda.Syntax.Concrete.Generic.ExprLike b, Agda.Syntax.Concrete.Generic.ExprLike c) => Agda.Syntax.Concrete.Generic.ExprLike (a, b, c) instance (Agda.Syntax.Concrete.Generic.ExprLike a, Agda.Syntax.Concrete.Generic.ExprLike b, Agda.Syntax.Concrete.Generic.ExprLike c, Agda.Syntax.Concrete.Generic.ExprLike d) => Agda.Syntax.Concrete.Generic.ExprLike (a, b, c, d) instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.Expr instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.FieldAssignment instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.ModuleAssignment instance Agda.Syntax.Concrete.Generic.ExprLike a => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Concrete.OpApp a) instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.LamBinding instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.LHS instance (Agda.Syntax.Concrete.Generic.ExprLike qn, Agda.Syntax.Concrete.Generic.ExprLike e) => Agda.Syntax.Concrete.Generic.ExprLike (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.LamClause instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.DoStmt instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.ModuleApplication instance Agda.Syntax.Concrete.Generic.ExprLike Agda.Syntax.Concrete.Declaration -- | Collecting fixity declarations (and polarity pragmas) for concrete -- declarations. module Agda.Syntax.Concrete.Fixity type Fixities = Map Name Fixity' type Polarities = Map Name [Occurrence] class Monad m => MonadFixityError m throwMultipleFixityDecls :: MonadFixityError m => [(Name, [Fixity'])] -> m a throwMultiplePolarityPragmas :: MonadFixityError m => [Name] -> m a warnUnknownNamesInFixityDecl :: (MonadFixityError m, HasCallStack) => [Name] -> m () warnUnknownNamesInPolarityPragmas :: (MonadFixityError m, HasCallStack) => [Name] -> m () warnUnknownFixityInMixfixDecl :: (MonadFixityError m, HasCallStack) => [Name] -> m () warnPolarityPragmasButNotPostulates :: (MonadFixityError m, HasCallStack) => [Name] -> m () data DoWarn NoWarn :: DoWarn DoWarn :: DoWarn -- | Get the fixities and polarity pragmas from the current block. Doesn't -- go inside modules and where blocks. The reason for this is that these -- declarations have to appear at the same level (or possibly outside an -- abstract or mutual block) as their target declaration. fixitiesAndPolarities :: MonadFixityError m => DoWarn -> [Declaration] -> m (Fixities, Polarities) instance GHC.Show.Show Agda.Syntax.Concrete.Fixity.DoWarn instance GHC.Classes.Eq Agda.Syntax.Concrete.Fixity.DoWarn instance GHC.Base.Semigroup Agda.Syntax.Concrete.Fixity.DeclaredNames instance GHC.Base.Monoid Agda.Syntax.Concrete.Fixity.DeclaredNames instance Agda.Syntax.Concrete.Fixity.MonadFixityError m => GHC.Base.Semigroup (Agda.Syntax.Concrete.Fixity.MonadicFixPol m) instance Agda.Syntax.Concrete.Fixity.MonadFixityError m => GHC.Base.Monoid (Agda.Syntax.Concrete.Fixity.MonadicFixPol m) module Agda.Syntax.Concrete.Definitions.Types -- | The nice declarations. No fixity declarations and function definitions -- are contained in a single constructor instead of spread out between -- type signatures and clauses. The private, postulate, -- abstract and instance modifiers have been -- distributed to the individual declarations. -- -- Observe the order of components: -- -- Range Fixity' Access IsAbstract IsInstance TerminationCheck -- PositivityCheck -- -- further attributes -- -- (Q)Name -- -- content (Expr, Declaration ...) data NiceDeclaration -- | IsAbstract argument: We record whether a declaration was made -- in an abstract block. -- -- ArgInfo argument: Axioms and functions can be declared -- irrelevant. (Hiding should be NotHidden.) Axiom :: Range -> Access -> IsAbstract -> IsInstance -> ArgInfo -> Name -> Expr -> NiceDeclaration NiceField :: Range -> Access -> IsAbstract -> IsInstance -> TacticAttribute -> Name -> Arg Expr -> NiceDeclaration PrimitiveFunction :: Range -> Access -> IsAbstract -> Name -> Arg Expr -> NiceDeclaration NiceMutual :: Range -> TerminationCheck -> CoverageCheck -> PositivityCheck -> [NiceDeclaration] -> NiceDeclaration NiceModule :: Range -> Access -> IsAbstract -> QName -> Telescope -> [Declaration] -> NiceDeclaration NiceModuleMacro :: Range -> Access -> Name -> ModuleApplication -> OpenShortHand -> ImportDirective -> NiceDeclaration NiceOpen :: Range -> QName -> ImportDirective -> NiceDeclaration NiceImport :: Range -> QName -> Maybe AsName -> OpenShortHand -> ImportDirective -> NiceDeclaration NicePragma :: Range -> Pragma -> NiceDeclaration NiceRecSig :: Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> Expr -> NiceDeclaration NiceDataSig :: Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> Expr -> NiceDeclaration -- | An uncategorized function clause, could be a function clause without -- type signature or a pattern lhs (e.g. for irrefutable let). The -- Declaration is the actual FunClause. NiceFunClause :: Range -> Access -> IsAbstract -> TerminationCheck -> CoverageCheck -> Catchall -> Declaration -> NiceDeclaration FunSig :: Range -> Access -> IsAbstract -> IsInstance -> IsMacro -> ArgInfo -> TerminationCheck -> CoverageCheck -> Name -> Expr -> NiceDeclaration -- | Block of function clauses (we have seen the type signature before). -- The Declarations are the original declarations that were -- processed into this FunDef and are only used in -- notSoNiceDeclaration. Andreas, 2017-01-01: Because of issue -- #2372, we add IsInstance here. An alias should know that it is -- an instance. FunDef :: Range -> [Declaration] -> IsAbstract -> IsInstance -> TerminationCheck -> CoverageCheck -> Name -> [Clause] -> NiceDeclaration NiceDataDef :: Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> [NiceConstructor] -> NiceDeclaration NiceLoneConstructor :: Range -> [NiceConstructor] -> NiceDeclaration -- | (Maybe Range) gives range of the 'pattern' declaration. NiceRecDef :: Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> RecordDirectives -> [LamBinding] -> [Declaration] -> NiceDeclaration NicePatternSyn :: Range -> Access -> Name -> [Arg Name] -> Pattern -> NiceDeclaration NiceGeneralize :: Range -> Access -> ArgInfo -> TacticAttribute -> Name -> Expr -> NiceDeclaration NiceUnquoteDecl :: Range -> Access -> IsAbstract -> IsInstance -> TerminationCheck -> CoverageCheck -> [Name] -> Expr -> NiceDeclaration NiceUnquoteDef :: Range -> Access -> IsAbstract -> TerminationCheck -> CoverageCheck -> [Name] -> Expr -> NiceDeclaration NiceUnquoteData :: Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [Name] -> Expr -> NiceDeclaration type TerminationCheck = TerminationCheck Measure -- | Termination measure is, for now, a variable name. type Measure = Name type Catchall = Bool -- | Only Axioms. type NiceConstructor = NiceTypeSignature -- | Only Axioms. type NiceTypeSignature = NiceDeclaration -- | One clause in a function definition. There is no guarantee that the -- LHS actually declares the Name. We will have to check -- that later. data Clause Clause :: Name -> Catchall -> LHS -> RHS -> WhereClause -> [Clause] -> Clause -- | When processing a mutual block we collect the various checks present -- in the block before combining them. data MutualChecks MutualChecks :: [TerminationCheck] -> [CoverageCheck] -> [PositivityCheck] -> MutualChecks [mutualTermination] :: MutualChecks -> [TerminationCheck] [mutualCoverage] :: MutualChecks -> [CoverageCheck] [mutualPositivity] :: MutualChecks -> [PositivityCheck] -- | In an inferred mutual block we keep accumulating nice -- declarations until all of the lone signatures have an attached -- definition. The type is therefore a bit span-like: we return an -- initial segment (the inferred mutual block) together with leftovers. data InferredMutual InferredMutual :: MutualChecks -> [NiceDeclaration] -> [NiceDeclaration] -> InferredMutual [inferredChecks] :: InferredMutual -> MutualChecks [inferredBlock] :: InferredMutual -> [NiceDeclaration] [inferredLeftovers] :: InferredMutual -> [NiceDeclaration] extendInferredBlock :: NiceDeclaration -> InferredMutual -> InferredMutual -- | In an `interleaved mutual' block we collect the data signatures, -- function signatures, as well as their associated constructors and -- function clauses respectively. Each signature is given a position in -- the block (from 0 onwards) and each set of constructor / clauses is -- given a *distinct* one. This allows for interleaved forward -- declarations similar to what one gets in a new-style mutual block. type InterleavedMutual = Map Name InterleavedDecl data InterleavedDecl InterleavedData :: DeclNum -> NiceDeclaration -> Maybe (DeclNum, List1 [NiceConstructor]) -> InterleavedDecl -- | Internal number of the data signature. [interleavedDeclNum] :: InterleavedDecl -> DeclNum -- | The data signature. [interleavedDeclSig] :: InterleavedDecl -> NiceDeclaration -- | Constructors associated to the data signature. [interleavedDataCons] :: InterleavedDecl -> Maybe (DeclNum, List1 [NiceConstructor]) InterleavedFun :: DeclNum -> NiceDeclaration -> Maybe (DeclNum, List1 ([Declaration], [Clause])) -> InterleavedDecl -- | Internal number of the data signature. [interleavedDeclNum] :: InterleavedDecl -> DeclNum -- | The data signature. [interleavedDeclSig] :: InterleavedDecl -> NiceDeclaration -- | Function clauses associated to the function signature. [interleavedFunClauses] :: InterleavedDecl -> Maybe (DeclNum, List1 ([Declaration], [Clause])) -- | Numbering declarations in an interleaved mutual block. type DeclNum = Int isInterleavedFun :: InterleavedDecl -> Maybe () isInterleavedData :: InterleavedDecl -> Maybe () interleavedDecl :: Name -> InterleavedDecl -> [(DeclNum, NiceDeclaration)] -- | Several declarations expect only type signatures as sub-declarations. -- These are: data KindOfBlock -- |
--   postulate
--   
PostulateBlock :: KindOfBlock -- | primitive. Ensured by parser. PrimitiveBlock :: KindOfBlock -- | instance. Actually, here all kinds of sub-declarations are -- allowed a priori. InstanceBlock :: KindOfBlock -- | field. Ensured by parser. FieldBlock :: KindOfBlock -- | data ... where. Here we got a bad error message for Agda-2.5 -- (Issue 1698). DataBlock :: KindOfBlock -- | constructor, in interleaved mutual. ConstructorBlock :: KindOfBlock declName :: NiceDeclaration -> String data InMutual -- | we are nicifying a mutual block InMutual :: InMutual -- | we are nicifying decls not in a mutual block NotInMutual :: InMutual -- | The kind of the forward declaration. data DataRecOrFun -- | Name of a data type DataName :: PositivityCheck -> UniverseCheck -> DataRecOrFun [_kindPosCheck] :: DataRecOrFun -> PositivityCheck [_kindUniCheck] :: DataRecOrFun -> UniverseCheck -- | Name of a record type RecName :: PositivityCheck -> UniverseCheck -> DataRecOrFun [_kindPosCheck] :: DataRecOrFun -> PositivityCheck [_kindUniCheck] :: DataRecOrFun -> UniverseCheck -- | Name of a function. FunName :: TerminationCheck -> CoverageCheck -> DataRecOrFun isFunName :: DataRecOrFun -> Bool sameKind :: DataRecOrFun -> DataRecOrFun -> Bool terminationCheck :: DataRecOrFun -> TerminationCheck coverageCheck :: DataRecOrFun -> CoverageCheck positivityCheck :: DataRecOrFun -> PositivityCheck mutualChecks :: DataRecOrFun -> MutualChecks universeCheck :: DataRecOrFun -> UniverseCheck instance GHC.Generics.Generic Agda.Syntax.Concrete.Definitions.Types.Clause instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Types.Clause instance GHC.Generics.Generic Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Types.KindOfBlock instance GHC.Classes.Ord Agda.Syntax.Concrete.Definitions.Types.KindOfBlock instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.Types.KindOfBlock instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Types.InMutual instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.Types.InMutual instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Types.DataRecOrFun instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.Types.DataRecOrFun instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.Types.DataRecOrFun instance GHC.Base.Semigroup Agda.Syntax.Concrete.Definitions.Types.MutualChecks instance GHC.Base.Monoid Agda.Syntax.Concrete.Definitions.Types.MutualChecks instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Definitions.Types.Clause module Agda.Syntax.Concrete.Definitions.Errors -- | Exception with internal source code callstack data DeclarationException DeclarationException :: CallStack -> DeclarationException' -> DeclarationException [deLocation] :: DeclarationException -> CallStack [deException] :: DeclarationException -> DeclarationException' -- | The exception type. data DeclarationException' MultipleEllipses :: Pattern -> DeclarationException' InvalidName :: Name -> DeclarationException' DuplicateDefinition :: Name -> DeclarationException' DuplicateAnonDeclaration :: Range -> DeclarationException' MissingWithClauses :: Name -> LHS -> DeclarationException' WrongDefinition :: Name -> DataRecOrFun -> DataRecOrFun -> DeclarationException' DeclarationPanic :: String -> DeclarationException' WrongContentBlock :: KindOfBlock -> Range -> DeclarationException' -- | In a mutual block, a clause could belong to any of the ≥2 type -- signatures (Name). AmbiguousFunClauses :: LHS -> List1 Name -> DeclarationException' -- | In an interleaved mutual block, a constructor could belong to any of -- the data signatures (Name) AmbiguousConstructor :: Range -> Name -> [Name] -> DeclarationException' -- | In a mutual block, all or none need a MEASURE pragma. Range is of -- mutual block. InvalidMeasureMutual :: Range -> DeclarationException' UnquoteDefRequiresSignature :: List1 Name -> DeclarationException' BadMacroDef :: NiceDeclaration -> DeclarationException' data DeclarationWarning DeclarationWarning :: CallStack -> DeclarationWarning' -> DeclarationWarning [dwLocation] :: DeclarationWarning -> CallStack [dwWarning] :: DeclarationWarning -> DeclarationWarning' -- | Non-fatal errors encountered in the Nicifier. data DeclarationWarning' -- | Empty abstract block. EmptyAbstract :: Range -> DeclarationWarning' -- | Empty constructor block. EmptyConstructor :: Range -> DeclarationWarning' -- | Empty field block. EmptyField :: Range -> DeclarationWarning' -- | Empty variable block. EmptyGeneralize :: Range -> DeclarationWarning' -- | Empty instance block EmptyInstance :: Range -> DeclarationWarning' -- | Empty macro block. EmptyMacro :: Range -> DeclarationWarning' -- | Empty mutual block. EmptyMutual :: Range -> DeclarationWarning' -- | Empty postulate block. EmptyPostulate :: Range -> DeclarationWarning' -- | Empty private block. EmptyPrivate :: Range -> DeclarationWarning' -- | Empty primitive block. EmptyPrimitive :: Range -> DeclarationWarning' -- | A Hidden identifier in a variable declaration. -- Hiding has no effect there as generalized variables are always hidden -- (or instance variables). HiddenGeneralize :: Range -> DeclarationWarning' -- | A {-# CATCHALL #-} pragma that does not precede a function clause. InvalidCatchallPragma :: Range -> DeclarationWarning' -- | Invalid definition in a constructor block InvalidConstructor :: Range -> DeclarationWarning' -- | Invalid constructor block (not inside an interleaved mutual block) InvalidConstructorBlock :: Range -> DeclarationWarning' -- | A {-# NON_COVERING #-} pragma that does not apply to any function. InvalidCoverageCheckPragma :: Range -> DeclarationWarning' -- | A {-# NO_POSITIVITY_CHECK #-} pragma that does not apply to any data -- or record type. InvalidNoPositivityCheckPragma :: Range -> DeclarationWarning' -- | A {-# NO_UNIVERSE_CHECK #-} pragma that does not apply to a data or -- record type. InvalidNoUniverseCheckPragma :: Range -> DeclarationWarning' -- | A record directive outside of a record / below existing fields. InvalidRecordDirective :: Range -> DeclarationWarning' -- | A {-# TERMINATING #-} and {-# NON_TERMINATING #-} pragma that does not -- apply to any function. InvalidTerminationCheckPragma :: Range -> DeclarationWarning' -- | Definitions (e.g. constructors or functions) without a declaration. MissingDeclarations :: [(Name, Range)] -> DeclarationWarning' -- | Declarations (e.g. type signatures) without a definition. MissingDefinitions :: [(Name, Range)] -> DeclarationWarning' NotAllowedInMutual :: Range -> String -> DeclarationWarning' -- | private has no effect on open public. (But the user -- might think so.) OpenPublicPrivate :: Range -> DeclarationWarning' -- | abstract has no effect on open public. (But the user -- might think so.) OpenPublicAbstract :: Range -> DeclarationWarning' PolarityPragmasButNotPostulates :: [Name] -> DeclarationWarning' -- | Pragma {-# NO_TERMINATION_CHECK #-} has been replaced by -- {-# TERMINATING #-} and {-# NON_TERMINATING #-}. PragmaNoTerminationCheck :: Range -> DeclarationWarning' -- | COMPILE pragmas are not allowed in safe mode PragmaCompiled :: Range -> DeclarationWarning' ShadowingInTelescope :: List1 (Name, List2 Range) -> DeclarationWarning' UnknownFixityInMixfixDecl :: [Name] -> DeclarationWarning' UnknownNamesInFixityDecl :: [Name] -> DeclarationWarning' UnknownNamesInPolarityPragmas :: [Name] -> DeclarationWarning' -- | abstract block with nothing that can (newly) be made -- abstract. UselessAbstract :: Range -> DeclarationWarning' -- | instance block with nothing that can (newly) become an -- instance. UselessInstance :: Range -> DeclarationWarning' -- | private block with nothing that can (newly) be made private. UselessPrivate :: Range -> DeclarationWarning' declarationWarningName :: DeclarationWarning -> WarningName declarationWarningName' :: DeclarationWarning' -> WarningName -- | Nicifier warnings turned into errors in --safe mode. unsafeDeclarationWarning :: DeclarationWarning -> Bool unsafeDeclarationWarning' :: DeclarationWarning' -> Bool instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Errors.DeclarationException' instance GHC.Generics.Generic Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning' instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning' instance GHC.Generics.Generic Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning' instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning' instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning' instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.Errors.DeclarationException instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.Errors.DeclarationException' instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.Errors.DeclarationException' module Agda.Syntax.Concrete.Definitions.Monad -- | Nicifier monad. Preserve the state when throwing an exception. newtype Nice a Nice :: ExceptT DeclarationException (State NiceEnv) a -> Nice a [unNice] :: Nice a -> ExceptT DeclarationException (State NiceEnv) a -- | Run a Nicifier computation, return result and warnings (in -- chronological order). runNice :: Nice a -> (Either DeclarationException a, NiceWarnings) -- | Nicifier state. data NiceEnv NiceEnv :: LoneSigs -> TerminationCheck -> PositivityCheck -> UniverseCheck -> Catchall -> CoverageCheck -> NiceWarnings -> NameId -> NiceEnv -- | Lone type signatures that wait for their definition. [_loneSigs] :: NiceEnv -> LoneSigs -- | Termination checking pragma waiting for a definition. [_termChk] :: NiceEnv -> TerminationCheck -- | Positivity checking pragma waiting for a definition. [_posChk] :: NiceEnv -> PositivityCheck -- | Universe checking pragma waiting for a data/rec signature or -- definition. [_uniChk] :: NiceEnv -> UniverseCheck -- | Catchall pragma waiting for a function clause. [_catchall] :: NiceEnv -> Catchall -- | Coverage pragma waiting for a definition. [_covChk] :: NiceEnv -> CoverageCheck -- | Stack of warnings. Head is last warning. [niceWarn] :: NiceEnv -> NiceWarnings -- | We distinguish different NoNames (anonymous definitions) by a -- unique NameId. [_nameId] :: NiceEnv -> NameId data LoneSig LoneSig :: Range -> Name -> DataRecOrFun -> LoneSig [loneSigRange] :: LoneSig -> Range -- | If isNoName, this name can have a different NameId than -- the key of LoneSigs pointing to it. [loneSigName] :: LoneSig -> Name [loneSigKind] :: LoneSig -> DataRecOrFun type LoneSigs = Map Name LoneSig " We retain the 'Name' also in the codomain since 'Name' as a key is up to @Eq Name@ which ignores the range. However, without range names are not unique in case the user gives a second definition of the same name. This causes then problems in 'replaceSigs' which might replace the wrong signature. Another reason is that we want to distinguish different occurrences of 'NoName' in a mutual block (issue #4157). The 'NoName' in the codomain will have a unique 'NameId'." type NiceWarnings = [DeclarationWarning] " Stack of warnings. Head is last warning." -- | Initial nicifier state. initNiceEnv :: NiceEnv lensNameId :: Lens' NameId NiceEnv nextNameId :: Nice NameId -- | Lens for field _loneSigs. loneSigs :: Lens' LoneSigs NiceEnv -- | Adding a lone signature to the state. Return the name (which is made -- unique if isNoName). addLoneSig :: Range -> Name -> DataRecOrFun -> Nice Name -- | Remove a lone signature from the state. removeLoneSig :: Name -> Nice () -- | Search for forward type signature. getSig :: Name -> Nice (Maybe DataRecOrFun) -- | Check that no lone signatures are left in the state. noLoneSigs :: Nice Bool -- | Ensure that all forward declarations have been given a definition. forgetLoneSigs :: Nice () checkLoneSigs :: LoneSigs -> Nice () -- | Get names of lone function signatures, plus their unique names. loneFuns :: LoneSigs -> [(Name, Name)] -- | Create a LoneSigs map from an association list. loneSigsFromLoneNames :: [(Range, Name, DataRecOrFun)] -> LoneSigs -- | Lens for field _termChk. terminationCheckPragma :: Lens' TerminationCheck NiceEnv withTerminationCheckPragma :: TerminationCheck -> Nice a -> Nice a coverageCheckPragma :: Lens' CoverageCheck NiceEnv withCoverageCheckPragma :: CoverageCheck -> Nice a -> Nice a -- | Lens for field _posChk. positivityCheckPragma :: Lens' PositivityCheck NiceEnv withPositivityCheckPragma :: PositivityCheck -> Nice a -> Nice a -- | Lens for field _uniChk. universeCheckPragma :: Lens' UniverseCheck NiceEnv withUniverseCheckPragma :: UniverseCheck -> Nice a -> Nice a -- | Get universe check pragma from a data/rec signature. Defaults to -- YesUniverseCheck. getUniverseCheckFromSig :: Name -> Nice UniverseCheck -- | Lens for field _catchall. catchallPragma :: Lens' Catchall NiceEnv -- | Get current catchall pragma, and reset it for the next clause. popCatchallPragma :: Nice Catchall withCatchallPragma :: Catchall -> Nice a -> Nice a -- | Add a new warning. niceWarning :: DeclarationWarning -> Nice () declarationException :: HasCallStack => DeclarationException' -> Nice a declarationWarning' :: DeclarationWarning' -> CallStack -> Nice () declarationWarning :: HasCallStack => DeclarationWarning' -> Nice () instance Control.Monad.Error.Class.MonadError Agda.Syntax.Concrete.Definitions.Errors.DeclarationException Agda.Syntax.Concrete.Definitions.Monad.Nice instance Control.Monad.State.Class.MonadState Agda.Syntax.Concrete.Definitions.Monad.NiceEnv Agda.Syntax.Concrete.Definitions.Monad.Nice instance GHC.Base.Monad Agda.Syntax.Concrete.Definitions.Monad.Nice instance GHC.Base.Applicative Agda.Syntax.Concrete.Definitions.Monad.Nice instance GHC.Base.Functor Agda.Syntax.Concrete.Definitions.Monad.Nice module Agda.Syntax.Concrete.Attribute -- | An attribute is a modifier for ArgInfo. data Attribute RelevanceAttribute :: Relevance -> Attribute QuantityAttribute :: Quantity -> Attribute TacticAttribute :: Expr -> Attribute CohesionAttribute :: Cohesion -> Attribute LockAttribute :: Lock -> Attribute -- | (Conjunctive constraint.) type LensAttribute a = (LensRelevance a, LensQuantity a, LensCohesion a, LensLock a) -- | Modifiers for Relevance. relevanceAttributeTable :: [(String, Relevance)] -- | Modifiers for Quantity. quantityAttributeTable :: [(String, Quantity)] cohesionAttributeTable :: [(String, Cohesion)] -- | Information about cohesion attributes (printed representations and -- positions). -- -- This information is returned by the parser. Code that calls the parser -- should, if appropriate, complain if support for cohesion attributes -- has not been enabled and the returned list is non-empty. This can be -- taken care of by checkCohesionAttributes, which should not be -- called until after pragma options have been set. type CohesionAttributes = [(String, Range)] -- | Modifiers for Quantity. lockAttributeTable :: [(String, Lock)] -- | Concrete syntax for all attributes. attributesMap :: Map String Attribute -- | Parsing a string into an attribute. stringToAttribute :: String -> Maybe Attribute -- | Parsing an expression into an attribute. exprToAttribute :: Expr -> Maybe Attribute -- | Setting an attribute (in e.g. an Arg). Overwrites previous -- value. setAttribute :: LensAttribute a => Attribute -> a -> a -- | Setting some attributes in left-to-right order. Blindly overwrites -- previous settings. setAttributes :: LensAttribute a => [Attribute] -> a -> a -- | Setting Relevance if unset. setPristineRelevance :: LensRelevance a => Relevance -> a -> Maybe a -- | Setting Quantity if unset. setPristineQuantity :: LensQuantity a => Quantity -> a -> Maybe a -- | Setting Cohesion if unset. setPristineCohesion :: LensCohesion a => Cohesion -> a -> Maybe a -- | Setting Lock if unset. setPristineLock :: LensLock a => Lock -> a -> Maybe a -- | Setting an unset attribute (to e.g. an Arg). setPristineAttribute :: LensAttribute a => Attribute -> a -> Maybe a -- | Setting a list of unset attributes. setPristineAttributes :: LensAttribute a => [Attribute] -> a -> Maybe a isRelevanceAttribute :: Attribute -> Maybe Relevance isQuantityAttribute :: Attribute -> Maybe Quantity isTacticAttribute :: Attribute -> Maybe Expr relevanceAttributes :: [Attribute] -> [Attribute] quantityAttributes :: [Attribute] -> [Attribute] tacticAttributes :: [Attribute] -> [Attribute] instance GHC.Show.Show Agda.Syntax.Concrete.Attribute.Attribute instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Attribute.Attribute instance Agda.Syntax.Position.SetRange Agda.Syntax.Concrete.Attribute.Attribute instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Attribute.Attribute module Agda.Syntax.Parser.Monad -- | The parse monad. data Parser a -- | The result of parsing something. data ParseResult a ParseOk :: ParseState -> a -> ParseResult a ParseFailed :: ParseError -> ParseResult a -- | The parser state. Contains everything the parser and the lexer could -- ever need. data ParseState PState :: !SrcFile -> !PositionWithoutFile -> !PositionWithoutFile -> String -> !Char -> String -> LayoutContext -> LayoutStatus -> Keyword -> [LexState] -> ParseFlags -> ![ParseWarning] -> !CohesionAttributes -> ParseState [parseSrcFile] :: ParseState -> !SrcFile -- | position at current input location [parsePos] :: ParseState -> !PositionWithoutFile -- | position of last token [parseLastPos] :: ParseState -> !PositionWithoutFile -- | the current input [parseInp] :: ParseState -> String -- | the character before the input [parsePrevChar] :: ParseState -> !Char -- | the previous token [parsePrevToken] :: ParseState -> String -- | the stack of layout blocks [parseLayout] :: ParseState -> LayoutContext -- | the status of the coming layout block [parseLayStatus] :: ParseState -> LayoutStatus -- | the keyword for the coming layout block [parseLayKw] :: ParseState -> Keyword -- | the state of the lexer (states can be nested so we need a stack) [parseLexState] :: ParseState -> [LexState] -- | parametrization of the parser [parseFlags] :: ParseState -> ParseFlags -- | In reverse order. [parseWarnings] :: ParseState -> ![ParseWarning] -- | Every encountered occurrence of a cohesion attribute. [parseCohesion] :: ParseState -> !CohesionAttributes -- | Parse errors: what you get if parsing fails. data ParseError -- | Errors that arise at a specific position in the file ParseError :: !SrcFile -> !PositionWithoutFile -> String -> String -> String -> ParseError -- | The file in which the error occurred. [errSrcFile] :: ParseError -> !SrcFile -- | Where the error occurred. [errPos] :: ParseError -> !PositionWithoutFile -- | The remaining input. [errInput] :: ParseError -> String -- | The previous token. [errPrevToken] :: ParseError -> String -- | Hopefully an explanation of what happened. [errMsg] :: ParseError -> String -- | Parse errors that concern a range in a file. OverlappingTokensError :: !Range' SrcFile -> ParseError -- | The range of the bigger overlapping token [errRange] :: ParseError -> !Range' SrcFile -- | Parse errors that concern a whole file. InvalidExtensionError :: !RangeFile -> [String] -> ParseError -- | The file which the error concerns. [errPath] :: ParseError -> !RangeFile [errValidExts] :: ParseError -> [String] ReadFileError :: !RangeFile -> IOError -> ParseError -- | The file which the error concerns. [errPath] :: ParseError -> !RangeFile [errIOError] :: ParseError -> IOError -- | Warnings for parsing. data ParseWarning -- | Parse errors that concern a range in a file. OverlappingTokensWarning :: !Range' SrcFile -> ParseWarning -- | The range of the bigger overlapping token [warnRange] :: ParseWarning -> !Range' SrcFile -- | Unsupported attribute. UnsupportedAttribute :: Range -> !Maybe String -> ParseWarning -- | Multiple attributes. MultipleAttributes :: Range -> !Maybe String -> ParseWarning -- | For context sensitive lexing alex provides what is called start -- codes in the Alex documentation. It is really an integer -- representing the state of the lexer, so we call it LexState -- instead. type LexState = Int -- | We need to keep track of the context to do layout. The context -- specifies the indentation columns of the open layout blocks. See -- Agda.Syntax.Parser.Layout for more informaton. data LayoutBlock -- | Layout at specified Column, introduced by Keyword. Layout :: Keyword -> LayoutStatus -> Column -> LayoutBlock -- | The stack of layout blocks. -- -- When we encounter a layout keyword, we push a Tentative block -- with noColumn. This is replaced by aproper column once we -- reach the next token. type LayoutContext = [LayoutBlock] -- | Status of a layout column (see #1145). A layout column is -- Tentative until we encounter a new line. This allows stacking -- of layout keywords. -- -- Inside a LayoutContext the sequence of Confirmed -- columns needs to be strictly increasing. 'Tentative columns between -- Confirmed columns need to be strictly increasing as well. data LayoutStatus -- | The token defining the layout column was on the same line as the -- layout keyword and we have not seen a new line yet. Tentative :: LayoutStatus -- | We have seen a new line since the layout keyword and the layout column -- has not been superseded by a smaller column. Confirmed :: LayoutStatus -- | A (layout) column. type Column = Int32 -- | Parser flags. data ParseFlags ParseFlags :: Bool -> ParseFlags -- | Should comment tokens be returned by the lexer? [parseKeepComments] :: ParseFlags -> Bool -- | Constructs the initial state of the parser. The string argument is the -- input string, the file path is only there because it's part of a -- position. initState :: Maybe RangeFile -> ParseFlags -> String -> [LexState] -> ParseState -- | The default flags. defaultParseFlags :: ParseFlags -- | The most general way of parsing a string. The -- Agda.Syntax.Parser will define more specialised functions that -- supply the ParseFlags and the LexState. parse :: ParseFlags -> [LexState] -> Parser a -> String -> ParseResult a -- | The even more general way of parsing a string. parsePosString :: Position -> ParseFlags -> [LexState] -> Parser a -> String -> ParseResult a -- | Parses a string as if it were the contents of the given file Useful -- for integrating preprocessors. parseFromSrc :: ParseFlags -> [LexState] -> Parser a -> SrcFile -> String -> ParseResult a setParsePos :: PositionWithoutFile -> Parser () setLastPos :: PositionWithoutFile -> Parser () -- | The parse interval is between the last position and the current -- position. getParseInterval :: Parser Interval setPrevToken :: String -> Parser () getParseFlags :: Parser ParseFlags getLexState :: Parser [LexState] pushLexState :: LexState -> Parser () popLexState :: Parser () -- | Return the current layout block. topBlock :: Parser (Maybe LayoutBlock) popBlock :: Parser () pushBlock :: LayoutBlock -> Parser () getContext :: MonadState ParseState m => m LayoutContext setContext :: LayoutContext -> Parser () modifyContext :: (LayoutContext -> LayoutContext) -> Parser () -- | When we see a layout keyword, by default we expect a Tentative -- block. resetLayoutStatus :: Parser () -- | Records a warning. parseWarning :: ParseWarning -> Parser () parseWarningName :: ParseWarning -> WarningName -- | Throw a parse error at the current position. parseError :: String -> Parser a -- | Fake a parse error at the specified position. Used, for instance, when -- lexing nested comments, which when failing will always fail at the end -- of the file. A more informative position is the beginning of the -- failing comment. parseErrorAt :: PositionWithoutFile -> String -> Parser a -- | Use parseErrorAt or parseError as appropriate. parseError' :: Maybe PositionWithoutFile -> String -> Parser a -- | Report a parse error at the beginning of the given Range'. parseErrorRange :: HasRange r => r -> String -> Parser a -- | For lexical errors we want to report the current position as the site -- of the error, whereas for parse errors the previous position is the -- one we're interested in (since this will be the position of the token -- we just lexed). This function does parseErrorAt the current -- position. lexError :: String -> Parser a instance GHC.Show.Show Agda.Syntax.Parser.Monad.LayoutStatus instance GHC.Classes.Eq Agda.Syntax.Parser.Monad.LayoutStatus instance GHC.Show.Show Agda.Syntax.Parser.Monad.LayoutBlock instance GHC.Show.Show Agda.Syntax.Parser.Monad.ParseFlags instance GHC.Show.Show Agda.Syntax.Parser.Monad.ParseError instance GHC.Show.Show Agda.Syntax.Parser.Monad.ParseWarning instance GHC.Show.Show Agda.Syntax.Parser.Monad.ParseState instance Control.Monad.Error.Class.MonadError Agda.Syntax.Parser.Monad.ParseError Agda.Syntax.Parser.Monad.Parser instance Control.Monad.State.Class.MonadState Agda.Syntax.Parser.Monad.ParseState Agda.Syntax.Parser.Monad.Parser instance GHC.Base.Monad Agda.Syntax.Parser.Monad.Parser instance GHC.Base.Applicative Agda.Syntax.Parser.Monad.Parser instance GHC.Base.Functor Agda.Syntax.Parser.Monad.Parser instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Parser.Monad.ParseResult a) instance Control.DeepSeq.NFData Agda.Syntax.Parser.Monad.ParseWarning instance Agda.Utils.Pretty.Pretty Agda.Syntax.Parser.Monad.ParseWarning instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Monad.ParseWarning instance Agda.Utils.Pretty.Pretty Agda.Syntax.Parser.Monad.ParseError instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Monad.ParseError -- | Maintaining a list of favorites of some partially ordered type. Only -- the best elements are kept. -- -- To avoid name clashes, import this module qualified, as in import -- Agda.Utils.Favorites (Favorites) import qualified Agda.Utils.Favorites -- as Fav module Agda.Utils.Favorites -- | A list of incomparable favorites. newtype Favorites a Favorites :: [a] -> Favorites a [toList] :: Favorites a -> [a] -- | Result of comparing a candidate with the current favorites. data CompareResult a -- | Great, you are dominating a possibly (empty list of favorites) but -- there is also a rest that is not dominated. If null -- dominated, then notDominated is necessarily the complete -- list of favorites. Dominates :: [a] -> [a] -> CompareResult a [dominated] :: CompareResult a -> [a] [notDominated] :: CompareResult a -> [a] -- | Sorry, but you are dominated by that favorite. IsDominated :: a -> CompareResult a [dominator] :: CompareResult a -> a -- | Gosh, got some pretty a here, compare with my current -- favorites! Discard it if there is already one that is better or equal. -- (Skewed conservatively: faithful to the old favorites.) If there is no -- match for it, add it, and dispose of all that are worse than -- a. -- -- We require a partial ordering. Less is better! (Maybe paradoxically.) compareWithFavorites :: PartialOrd a => a -> Favorites a -> CompareResult a -- | Compare a new set of favorites to an old one and discard the new -- favorites that are dominated by the old ones and vice verse. (Skewed -- conservatively: faithful to the old favorites.) -- --
--   compareFavorites new old = (new', old')
--   
compareFavorites :: PartialOrd a => Favorites a -> Favorites a -> (Favorites a, Favorites a) unionCompared :: (Favorites a, Favorites a) -> Favorites a -- | After comparing, do the actual insertion. insertCompared :: a -> Favorites a -> CompareResult a -> Favorites a -- | Compare, then insert accordingly. insert a l = insertCompared a l -- (compareWithFavorites a l) insert :: PartialOrd a => a -> Favorites a -> Favorites a -- | Insert all the favorites from the first list into the second. union :: PartialOrd a => Favorites a -> Favorites a -> Favorites a -- | Construct favorites from elements of a partial order. The result -- depends on the order of the list if it contains equal elements, since -- earlier seen elements are favored over later seen equals. The first -- element of the list is seen first. fromList :: PartialOrd a => [a] -> Favorites a instance Agda.Utils.Singleton.Singleton a (Agda.Utils.Favorites.Favorites a) instance Agda.Utils.Null.Null (Agda.Utils.Favorites.Favorites a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.Favorites.Favorites a) instance Data.Foldable.Foldable Agda.Utils.Favorites.Favorites instance GHC.Classes.Ord a => GHC.Classes.Eq (Agda.Utils.Favorites.Favorites a) instance Agda.Utils.PartialOrd.PartialOrd a => GHC.Base.Semigroup (Agda.Utils.Favorites.Favorites a) instance Agda.Utils.PartialOrd.PartialOrd a => GHC.Base.Monoid (Agda.Utils.Favorites.Favorites a) -- | Additional functions for association lists. module Agda.Utils.AssocList -- | A finite map, represented as a set of pairs. -- -- Invariant: at most one value per key. type AssocList k v = [(k, v)] -- | Lookup keys in the same association list often. Use partially applied -- to create partial function apply m :: k -> Maybe v. -- -- -- -- Specification: apply m == (lookup m). apply :: Ord k => AssocList k v -> k -> Maybe v -- | O(n). Get the domain (list of keys) of the finite map. keys :: AssocList k v -> [k] -- | O(1). Add a new binding. Assumes the binding is not yet in the list. insert :: k -> v -> AssocList k v -> AssocList k v -- | O(n). Update the value at a key. The key must be in the domain of the -- finite map. Otherwise, an internal error is raised. update :: Eq k => k -> v -> AssocList k v -> AssocList k v -- | O(n). Delete a binding. The key must be in the domain of the finite -- map. Otherwise, an internal error is raised. delete :: Eq k => k -> AssocList k v -> AssocList k v -- | O(n). Update the value at a key with a certain function. The key must -- be in the domain of the finite map. Otherwise, an internal error is -- raised. updateAt :: Eq k => k -> (v -> v) -> AssocList k v -> AssocList k v -- | O(n). Map over an association list, preserving the order. mapWithKey :: (k -> v -> v) -> AssocList k v -> AssocList k v -- | O(n). If called with a effect-producing function, violation of the -- invariant could matter here (duplicating effects). mapWithKeyM :: Applicative m => (k -> v -> m v) -> AssocList k v -> m (AssocList k v) -- | O(n). Named in analogy to mapKeysMonotonic. To preserve the -- invariant, it is sufficient that the key transformation is injective -- (rather than monotonic). mapKeysMonotonic :: (k -> k') -> AssocList k v -> AssocList k' v -- | <math>. lookup key assocs looks up a key in an -- association list. -- --
--   >>> lookup 2 []
--   Nothing
--   
--   >>> lookup 2 [(1, "first")]
--   Nothing
--   
--   >>> lookup 2 [(1, "first"), (2, "second"), (3, "third")]
--   Just "second"
--   
lookup :: Eq a => a -> [(a, b)] -> Maybe b -- | This module defines the notion of a scope and operations on scopes. module Agda.Syntax.Scope.Base -- | A scope is a named collection of names partitioned into public and -- private names. data Scope Scope :: ModuleName -> [ModuleName] -> ScopeNameSpaces -> Map QName ModuleName -> Maybe DataOrRecordModule -> Scope [scopeName] :: Scope -> ModuleName [scopeParents] :: Scope -> [ModuleName] [scopeNameSpaces] :: Scope -> ScopeNameSpaces [scopeImports] :: Scope -> Map QName ModuleName [scopeDatatypeModule] :: Scope -> Maybe DataOrRecordModule data DataOrRecordModule IsDataModule :: DataOrRecordModule IsRecordModule :: DataOrRecordModule -- | See Access. data NameSpaceId -- | Things not exported by this module. PrivateNS :: NameSpaceId -- | Things defined and exported by this module. PublicNS :: NameSpaceId -- | Things from open public, exported by this module. ImportedNS :: NameSpaceId allNameSpaces :: [NameSpaceId] type ScopeNameSpaces = [(NameSpaceId, NameSpace)] localNameSpace :: Access -> NameSpaceId nameSpaceAccess :: NameSpaceId -> Access -- | Get a NameSpace from Scope. scopeNameSpace :: NameSpaceId -> Scope -> NameSpace -- | A lens for scopeNameSpaces updateScopeNameSpaces :: (ScopeNameSpaces -> ScopeNameSpaces) -> Scope -> Scope -- | `Monadic' lens (Functor sufficient). updateScopeNameSpacesM :: Functor m => (ScopeNameSpaces -> m ScopeNameSpaces) -> Scope -> m Scope -- | The complete information about the scope at a particular program point -- includes the scope stack, the local variables, and the context -- precedence. data ScopeInfo ScopeInfo :: ModuleName -> Map ModuleName Scope -> LocalVars -> LocalVars -> !PrecedenceStack -> NameMap -> ModuleMap -> InScopeSet -> Fixities -> Polarities -> ScopeInfo [_scopeCurrent] :: ScopeInfo -> ModuleName [_scopeModules] :: ScopeInfo -> Map ModuleName Scope -- | The variables that will be bound at the end of the current block of -- variables (i.e. clause). We collect them here instead of binding them -- immediately so we can avoid shadowing between variables in the same -- variable block. [_scopeVarsToBind] :: ScopeInfo -> LocalVars [_scopeLocals] :: ScopeInfo -> LocalVars [_scopePrecedence] :: ScopeInfo -> !PrecedenceStack [_scopeInverseName] :: ScopeInfo -> NameMap [_scopeInverseModule] :: ScopeInfo -> ModuleMap [_scopeInScope] :: ScopeInfo -> InScopeSet -- | Maps concrete names C.Name to fixities [_scopeFixities] :: ScopeInfo -> Fixities -- | Maps concrete names C.Name to polarities [_scopePolarities] :: ScopeInfo -> Polarities -- | For the sake of highlighting, the _scopeInverseName map also -- stores the KindOfName of an A.QName. data NameMapEntry NameMapEntry :: KindOfName -> List1 QName -> NameMapEntry -- | The anameKind. [qnameKind] :: NameMapEntry -> KindOfName -- | Possible renderings of the abstract name. [qnameConcrete] :: NameMapEntry -> List1 QName type NameMap = Map QName NameMapEntry type ModuleMap = Map ModuleName [QName] -- | Local variables. type LocalVars = AssocList Name LocalVar -- | For each bound variable, we want to know whether it was bound by a λ, -- Π, module telescope, pattern, or let. data BindingSource -- | λ (currently also used for Π and module parameters) LambdaBound :: BindingSource -- |
--   f ... =
--   
PatternBound :: BindingSource -- |
--   let ... in
--   
LetBound :: BindingSource -- |
--   | ... in q
--   
WithBound :: BindingSource -- | A local variable can be shadowed by an import. In case of reference to -- a shadowed variable, we want to report a scope error. data LocalVar LocalVar :: Name -> BindingSource -> [AbstractName] -> LocalVar -- | Unique ID of local variable. [localVar] :: LocalVar -> Name -- | Kind of binder used to introduce the variable (λ, -- let, ...). [localBindingSource] :: LocalVar -> BindingSource -- | If this list is not empty, the local variable is shadowed by one or -- more imports. [localShadowedBy] :: LocalVar -> [AbstractName] -- | Shadow a local name by a non-empty list of imports. shadowLocal :: [AbstractName] -> LocalVar -> LocalVar -- | Treat patternBound variable as a module parameter patternToModuleBound :: LocalVar -> LocalVar -- | Project name of unshadowed local variable. notShadowedLocal :: LocalVar -> Maybe Name -- | Get all locals that are not shadowed by imports. notShadowedLocals :: LocalVars -> AssocList Name Name -- | Lenses for ScopeInfo components scopeCurrent :: Lens' ModuleName ScopeInfo scopeModules :: Lens' (Map ModuleName Scope) ScopeInfo scopeVarsToBind :: Lens' LocalVars ScopeInfo scopeLocals :: Lens' LocalVars ScopeInfo scopePrecedence :: Lens' PrecedenceStack ScopeInfo scopeInverseName :: Lens' NameMap ScopeInfo scopeInverseModule :: Lens' ModuleMap ScopeInfo scopeInScope :: Lens' InScopeSet ScopeInfo scopeFixities :: Lens' Fixities ScopeInfo scopePolarities :: Lens' Polarities ScopeInfo scopeFixitiesAndPolarities :: Lens' (Fixities, Polarities) ScopeInfo -- | Lens for scopeVarsToBind. updateVarsToBind :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo setVarsToBind :: LocalVars -> ScopeInfo -> ScopeInfo -- | Lens for scopeLocals. updateScopeLocals :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo setScopeLocals :: LocalVars -> ScopeInfo -> ScopeInfo -- | A NameSpace contains the mappings from concrete names that -- the user can write to the abstract fully qualified names that the type -- checker wants to read. data NameSpace NameSpace :: NamesInScope -> ModulesInScope -> InScopeSet -> NameSpace -- | Maps concrete names to a list of abstract names. [nsNames] :: NameSpace -> NamesInScope -- | Maps concrete module names to a list of abstract module names. [nsModules] :: NameSpace -> ModulesInScope -- | All abstract names targeted by a concrete name in scope. Computed by -- recomputeInScopeSets. [nsInScope] :: NameSpace -> InScopeSet type ThingsInScope a = Map Name [a] type NamesInScope = ThingsInScope AbstractName type ModulesInScope = ThingsInScope AbstractModule type InScopeSet = Set QName -- | Set of types consisting of exactly AbstractName and -- AbstractModule. -- -- A GADT just for some dependent-types trickery. data InScopeTag a [NameTag] :: InScopeTag AbstractName [ModuleTag] :: InScopeTag AbstractModule -- | Type class for some dependent-types trickery. class Ord a => InScope a inScopeTag :: InScope a => InScopeTag a -- | inNameSpace selects either the name map or the module name -- map from a NameSpace. What is selected is determined by result -- type (using the dependent-type trickery). inNameSpace :: forall a. InScope a => NameSpace -> ThingsInScope a -- | Non-dependent tag for name or module. data NameOrModule NameNotModule :: NameOrModule ModuleNotName :: NameOrModule -- | For the sake of parsing left-hand sides, we distinguish constructor -- and record field names from defined names. data KindOfName -- | Constructor name (Inductive or don't know). ConName :: KindOfName -- | Constructor name (definitely CoInductive). CoConName :: KindOfName -- | Record field name. FldName :: KindOfName -- | Name of a pattern synonym. PatternSynName :: KindOfName -- | Name to be generalized GeneralizeName :: KindOfName -- | Generalizable variable from a let open DisallowedGeneralizeName :: KindOfName -- | Name of a macro MacroName :: KindOfName -- | A name that can only be quoted. Previous category DefName: -- (Refined in a flat manner as Enum and Bounded are not hereditary.) QuotableName :: KindOfName -- | Name of a data. DataName :: KindOfName -- | Name of a record. RecName :: KindOfName -- | Name of a defined function. FunName :: KindOfName -- | Name of a postulate. AxiomName :: KindOfName -- | Name of a primitive. PrimName :: KindOfName -- | A DefName, but either other kind or don't know which kind. -- End DefName. Keep these together in sequence, for sake of -- isDefName! OtherDefName :: KindOfName isDefName :: KindOfName -> Bool isConName :: KindOfName -> Maybe Induction conKindOfName :: Induction -> KindOfName -- | For ambiguous constructors, we might have both alternatives of -- Induction. In this case, we default to ConName. conKindOfName' :: Foldable t => t Induction -> KindOfName -- | For ambiguous constructors, we might have both alternatives of -- Induction. In this case, we default to Inductive. approxConInduction :: Foldable t => t Induction -> Induction exactConInduction :: Foldable t => t Induction -> Maybe Induction -- | Only return [Co]ConName if no ambiguity. exactConName :: Foldable t => t Induction -> Maybe KindOfName -- | A set of KindOfName, for the sake of elemKindsOfNames. data KindsOfNames AllKindsOfNames :: KindsOfNames -- | Only these kinds. SomeKindsOfNames :: Set KindOfName -> KindsOfNames -- | All but these Kinds. ExceptKindsOfNames :: Set KindOfName -> KindsOfNames elemKindsOfNames :: KindOfName -> KindsOfNames -> Bool allKindsOfNames :: KindsOfNames someKindsOfNames :: [KindOfName] -> KindsOfNames exceptKindsOfNames :: [KindOfName] -> KindsOfNames -- | Decorate something with KindOfName data WithKind a WithKind :: KindOfName -> a -> WithKind a [theKind] :: WithKind a -> KindOfName [kindedThing] :: WithKind a -> a -- | Where does a name come from? -- -- This information is solely for reporting to the user, see -- whyInScope. data WhyInScope -- | Defined in this module. Defined :: WhyInScope -- | Imported from another module. Opened :: QName -> WhyInScope -> WhyInScope -- | Imported by a module application. Applied :: QName -> WhyInScope -> WhyInScope -- | A decoration of QName. data AbstractName AbsName :: QName -> KindOfName -> WhyInScope -> NameMetadata -> AbstractName -- | The resolved qualified name. [anameName] :: AbstractName -> QName -- | The kind (definition, constructor, record field etc.). [anameKind] :: AbstractName -> KindOfName -- | Explanation where this name came from. [anameLineage] :: AbstractName -> WhyInScope -- | Additional information needed during scope checking. Currently used -- for generalized data/record params. [anameMetadata] :: AbstractName -> NameMetadata data NameMetadata NoMetadata :: NameMetadata GeneralizedVarsMetadata :: Map QName Name -> NameMetadata -- | A decoration of abstract syntax module names. data AbstractModule AbsModule :: ModuleName -> WhyInScope -> AbstractModule -- | The resolved module name. [amodName] :: AbstractModule -> ModuleName -- | Explanation where this name came from. [amodLineage] :: AbstractModule -> WhyInScope -- | Van Laarhoven lens on anameName. lensAnameName :: Lens' QName AbstractName -- | Van Laarhoven lens on amodName. lensAmodName :: Lens' ModuleName AbstractModule data ResolvedName -- | Local variable bound by λ, Π, module telescope, pattern, let. VarName :: Name -> BindingSource -> ResolvedName [resolvedVar] :: ResolvedName -> Name -- | What kind of binder? [resolvedBindingSource] :: ResolvedName -> BindingSource -- | Function, data/record type, postulate. DefinedName :: Access -> AbstractName -> Suffix -> ResolvedName -- | Record field name. Needs to be distinguished to parse copatterns. FieldName :: List1 AbstractName -> ResolvedName -- | Data or record constructor name. ConstructorName :: Set Induction -> List1 AbstractName -> ResolvedName -- | Name of pattern synonym. PatternSynResName :: List1 AbstractName -> ResolvedName -- | Unbound name. UnknownName :: ResolvedName -- | Why is a resolved name ambiguous? What did it resolve to? -- -- Invariant (statically enforced): At least two resolvents in total. data AmbiguousNameReason -- | The name resolves both to a local variable and some declared names. AmbiguousLocalVar :: LocalVar -> List1 AbstractName -> AmbiguousNameReason -- | The name resolves to at least 2 declared names. AmbiguousDeclName :: List2 AbstractName -> AmbiguousNameReason -- | The flat list of ambiguous names in AmbiguousNameReason. ambiguousNamesInReason :: AmbiguousNameReason -> List2 QName data WhyInScopeData WhyInScopeData :: QName -> FilePath -> Maybe LocalVar -> [AbstractName] -> [AbstractModule] -> WhyInScopeData whyInScopeDataFromAmbiguousNameReason :: QName -> AmbiguousNameReason -> WhyInScopeData mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a mergeNamesMany :: Eq a => [ThingsInScope a] -> ThingsInScope a -- | The empty name space. emptyNameSpace :: NameSpace -- | Map functions over the names and modules in a name space. mapNameSpace :: (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> NameSpace -> NameSpace -- | Zip together two name spaces. zipNameSpace :: (NamesInScope -> NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet -> InScopeSet) -> NameSpace -> NameSpace -> NameSpace -- | Map monadic function over a namespace. mapNameSpaceM :: Applicative m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> (InScopeSet -> m InScopeSet) -> NameSpace -> m NameSpace -- | The empty scope. emptyScope :: Scope -- | The empty scope info. emptyScopeInfo :: ScopeInfo -- | Map functions over the names and modules in a scope. mapScope :: (NameSpaceId -> NamesInScope -> NamesInScope) -> (NameSpaceId -> ModulesInScope -> ModulesInScope) -> (NameSpaceId -> InScopeSet -> InScopeSet) -> Scope -> Scope -- | Same as mapScope but applies the same function to all name -- spaces. mapScope_ :: (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> Scope -> Scope -- | Same as mapScope but applies the function only on the given -- name space. mapScopeNS :: NameSpaceId -> (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> Scope -> Scope -- | Map monadic functions over the names and modules in a scope. mapScopeM :: Applicative m => (NameSpaceId -> NamesInScope -> m NamesInScope) -> (NameSpaceId -> ModulesInScope -> m ModulesInScope) -> (NameSpaceId -> InScopeSet -> m InScopeSet) -> Scope -> m Scope -- | Same as mapScopeM but applies the same function to both the -- public and private name spaces. mapScopeM_ :: Applicative m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> (InScopeSet -> m InScopeSet) -> Scope -> m Scope -- | Zip together two scopes. The resulting scope has the same name as the -- first scope. zipScope :: (NameSpaceId -> NamesInScope -> NamesInScope -> NamesInScope) -> (NameSpaceId -> ModulesInScope -> ModulesInScope -> ModulesInScope) -> (NameSpaceId -> InScopeSet -> InScopeSet -> InScopeSet) -> Scope -> Scope -> Scope -- | Same as zipScope but applies the same function to both the -- public and private name spaces. zipScope_ :: (NamesInScope -> NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet -> InScopeSet) -> Scope -> Scope -> Scope -- | Recompute the inScope sets of a scope. recomputeInScopeSets :: Scope -> Scope -- | Filter a scope keeping only concrete names matching the predicates. -- The first predicate is applied to the names and the second to the -- modules. filterScope :: (Name -> Bool) -> (Name -> Bool) -> Scope -> Scope -- | Return all names in a scope. allNamesInScope :: InScope a => Scope -> ThingsInScope a allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access) -- | Look up a single name in the current scope. -- -- This is equivalent to Map.lookup n . allNamesInScope', but -- more efficient when only a single name needs to be looked up. findNameInScope :: InScope a => Name -> Scope -> [(a, Access)] -- | Returns the scope's non-private names. exportedNamesInScope :: InScope a => Scope -> ThingsInScope a namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a allThingsInScope :: Scope -> NameSpace thingsInScope :: [NameSpaceId] -> Scope -> NameSpace -- | Merge two scopes. The result has the name of the first scope. mergeScope :: Scope -> Scope -> Scope -- | Merge a non-empty list of scopes. The result has the name of the first -- scope in the list. mergeScopes :: [Scope] -> Scope -- | Move all names in a scope to the given name space (except never move -- from Imported to Public). setScopeAccess :: NameSpaceId -> Scope -> Scope -- | Update a particular name space. setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope -- | Modify a particular name space. modifyNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> Scope -> Scope -- | Add a name to a scope. addNameToScope :: NameSpaceId -> Name -> AbstractName -> Scope -> Scope -- | Remove a name from a scope. Caution: does not update the nsInScope -- set. This is only used by rebindName and in that case we add the name -- right back (but with a different kind). removeNameFromScope :: NameSpaceId -> Name -> Scope -> Scope -- | Add a module to a scope. addModuleToScope :: NameSpaceId -> Name -> AbstractModule -> Scope -> Scope -- | When we get here we cannot have both using and -- hiding. data UsingOrHiding UsingOnly :: [ImportedName] -> UsingOrHiding HidingOnly :: [ImportedName] -> UsingOrHiding usingOrHiding :: ImportDirective -> UsingOrHiding -- | Apply an ImportDirective to a scope: -- --
    --
  1. rename keys (C.Name) according to renaming;
  2. --
  3. for untouched keys, either of
  4. --
-- -- a) remove keys according to hiding, or b) filter keys -- according to using. -- -- Both steps could be done in one pass, by first preparing key-filtering -- functions C.Name -> Maybe C.Name for defined names and -- module names. However, the penalty of doing it in two passes should -- not be too high. (Doubling the run time.) applyImportDirective :: ImportDirective -> Scope -> Scope -- | Version of applyImportDirective that also returns sets of name -- and module name clashes introduced by renaming to identifiers -- that are already imported by using or lack of -- hiding. applyImportDirective_ :: ImportDirective -> Scope -> (Scope, (Set Name, Set Name)) -- | Rename the abstract names in a scope. renameCanonicalNames :: Map QName QName -> Map ModuleName ModuleName -> Scope -> Scope -- | Remove private name space of a scope. -- -- Should be a right identity for exportedNamesInScope. -- exportedNamesInScope . restrictPrivate == -- exportedNamesInScope. restrictPrivate :: Scope -> Scope -- | Remove private things from the given module from a scope. restrictLocalPrivate :: ModuleName -> Scope -> Scope -- | Filter privates out of a ScopeInfo withoutPrivates :: ScopeInfo -> ScopeInfo -- | Disallow using generalized variables from the scope disallowGeneralizedVars :: Scope -> Scope -- | Add an explanation to why things are in scope. inScopeBecause :: (WhyInScope -> WhyInScope) -> Scope -> Scope -- | Get the public parts of the public modules of a scope publicModules :: ScopeInfo -> Map ModuleName Scope publicNames :: ScopeInfo -> Set AbstractName everythingInScope :: ScopeInfo -> NameSpace everythingInScopeQualified :: ScopeInfo -> NameSpace -- | Get all concrete names in scope. Includes bound variables. concreteNamesInScope :: ScopeInfo -> Set QName -- | Look up a name in the scope scopeLookup :: InScope a => QName -> ScopeInfo -> [a] scopeLookup' :: forall a. InScope a => QName -> ScopeInfo -> [(a, Access)] data AllowAmbiguousNames -- | Used for instance arguments to check whether a name is in scope, but -- we do not care whether is is ambiguous AmbiguousAnything :: AllowAmbiguousNames -- | Ambiguous constructors, projections, or pattern synonyms. AmbiguousConProjs :: AllowAmbiguousNames AmbiguousNothing :: AllowAmbiguousNames isNameInScope :: QName -> ScopeInfo -> Bool isNameInScopeUnqualified :: QName -> ScopeInfo -> Bool -- | Find the concrete names that map (uniquely) to a given abstract -- qualified name. Sort by number of modules in the qualified name, -- unqualified names first. inverseScopeLookupName :: QName -> ScopeInfo -> [QName] inverseScopeLookupName' :: AllowAmbiguousNames -> QName -> ScopeInfo -> [QName] -- | A version of inverseScopeLookupName that also delivers the -- KindOfName. Used in highlighting. inverseScopeLookupName'' :: AllowAmbiguousNames -> QName -> ScopeInfo -> Maybe NameMapEntry -- | Find the concrete names that map (uniquely) to a given abstract module -- name. Sort by length, shortest first. inverseScopeLookupModule :: ModuleName -> ScopeInfo -> [QName] inverseScopeLookupModule' :: AllowAmbiguousNames -> ModuleName -> ScopeInfo -> [QName] recomputeInverseScopeMaps :: ScopeInfo -> ScopeInfo -- | Set the nameBindingSite in an abstract name. class SetBindingSite a setBindingSite :: SetBindingSite a => Range -> a -> a setBindingSite :: (SetBindingSite a, SetBindingSite b, Functor t, t b ~ a) => Range -> a -> a prettyNameSpace :: NameSpace -> [Doc] -- | Add first string only if list is non-empty. blockOfLines :: Doc -> [Doc] -> [Doc] instance GHC.Generics.Generic Agda.Syntax.Scope.Base.DataOrRecordModule instance GHC.Enum.Bounded Agda.Syntax.Scope.Base.DataOrRecordModule instance GHC.Enum.Enum Agda.Syntax.Scope.Base.DataOrRecordModule instance GHC.Classes.Eq Agda.Syntax.Scope.Base.DataOrRecordModule instance GHC.Show.Show Agda.Syntax.Scope.Base.DataOrRecordModule instance GHC.Generics.Generic Agda.Syntax.Scope.Base.NameSpaceId instance GHC.Show.Show Agda.Syntax.Scope.Base.NameSpaceId instance GHC.Enum.Enum Agda.Syntax.Scope.Base.NameSpaceId instance GHC.Enum.Bounded Agda.Syntax.Scope.Base.NameSpaceId instance GHC.Classes.Eq Agda.Syntax.Scope.Base.NameSpaceId instance GHC.Generics.Generic Agda.Syntax.Scope.Base.BindingSource instance GHC.Classes.Eq Agda.Syntax.Scope.Base.BindingSource instance GHC.Show.Show Agda.Syntax.Scope.Base.BindingSource instance GHC.Generics.Generic Agda.Syntax.Scope.Base.NameOrModule instance GHC.Enum.Bounded Agda.Syntax.Scope.Base.NameOrModule instance GHC.Enum.Enum Agda.Syntax.Scope.Base.NameOrModule instance GHC.Show.Show Agda.Syntax.Scope.Base.NameOrModule instance GHC.Classes.Ord Agda.Syntax.Scope.Base.NameOrModule instance GHC.Classes.Eq Agda.Syntax.Scope.Base.NameOrModule instance GHC.Generics.Generic Agda.Syntax.Scope.Base.KindOfName instance GHC.Enum.Bounded Agda.Syntax.Scope.Base.KindOfName instance GHC.Enum.Enum Agda.Syntax.Scope.Base.KindOfName instance GHC.Show.Show Agda.Syntax.Scope.Base.KindOfName instance GHC.Classes.Ord Agda.Syntax.Scope.Base.KindOfName instance GHC.Classes.Eq Agda.Syntax.Scope.Base.KindOfName instance GHC.Generics.Generic Agda.Syntax.Scope.Base.NameMapEntry instance GHC.Show.Show Agda.Syntax.Scope.Base.NameMapEntry instance Data.Traversable.Traversable Agda.Syntax.Scope.Base.WithKind instance Data.Foldable.Foldable Agda.Syntax.Scope.Base.WithKind instance GHC.Base.Functor Agda.Syntax.Scope.Base.WithKind instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Scope.Base.WithKind a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Scope.Base.WithKind a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Scope.Base.WithKind a) instance GHC.Generics.Generic Agda.Syntax.Scope.Base.WhyInScope instance GHC.Show.Show Agda.Syntax.Scope.Base.WhyInScope instance GHC.Generics.Generic Agda.Syntax.Scope.Base.NameMetadata instance GHC.Show.Show Agda.Syntax.Scope.Base.NameMetadata instance GHC.Generics.Generic Agda.Syntax.Scope.Base.AbstractName instance GHC.Show.Show Agda.Syntax.Scope.Base.AbstractName instance GHC.Generics.Generic Agda.Syntax.Scope.Base.LocalVar instance GHC.Show.Show Agda.Syntax.Scope.Base.LocalVar instance GHC.Generics.Generic Agda.Syntax.Scope.Base.AbstractModule instance GHC.Show.Show Agda.Syntax.Scope.Base.AbstractModule instance GHC.Generics.Generic Agda.Syntax.Scope.Base.NameSpace instance GHC.Show.Show Agda.Syntax.Scope.Base.NameSpace instance GHC.Classes.Eq Agda.Syntax.Scope.Base.NameSpace instance GHC.Generics.Generic Agda.Syntax.Scope.Base.Scope instance GHC.Show.Show Agda.Syntax.Scope.Base.Scope instance GHC.Classes.Eq Agda.Syntax.Scope.Base.Scope instance GHC.Generics.Generic Agda.Syntax.Scope.Base.ScopeInfo instance GHC.Show.Show Agda.Syntax.Scope.Base.ScopeInfo instance GHC.Generics.Generic Agda.Syntax.Scope.Base.ResolvedName instance GHC.Classes.Eq Agda.Syntax.Scope.Base.ResolvedName instance GHC.Show.Show Agda.Syntax.Scope.Base.ResolvedName instance GHC.Generics.Generic Agda.Syntax.Scope.Base.AmbiguousNameReason instance GHC.Show.Show Agda.Syntax.Scope.Base.AmbiguousNameReason instance GHC.Classes.Eq Agda.Syntax.Scope.Base.AllowAmbiguousNames instance Agda.Syntax.Scope.Base.SetBindingSite a => Agda.Syntax.Scope.Base.SetBindingSite [a] instance Agda.Syntax.Scope.Base.SetBindingSite Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Scope.Base.SetBindingSite Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Scope.Base.SetBindingSite Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Scope.Base.SetBindingSite Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Scope.Base.SetBindingSite Agda.Syntax.Scope.Base.AbstractModule instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.AmbiguousNameReason instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.ResolvedName instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.ResolvedName instance GHC.Classes.Eq Agda.Syntax.Scope.Base.ScopeInfo instance Agda.Utils.Null.Null Agda.Syntax.Scope.Base.ScopeInfo instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.ScopeInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Scope.Base.ScopeInfo instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.ScopeInfo instance Agda.Utils.Null.Null Agda.Syntax.Scope.Base.Scope instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.Scope instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.Scope instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.NameSpace instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.NameSpace instance Agda.Syntax.Scope.Base.InScope Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Scope.Base.InScope Agda.Syntax.Scope.Base.AbstractModule instance GHC.Classes.Eq Agda.Syntax.Scope.Base.AbstractModule instance GHC.Classes.Ord Agda.Syntax.Scope.Base.AbstractModule instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.AbstractModule instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.AbstractModule instance GHC.Classes.Eq Agda.Syntax.Scope.Base.LocalVar instance GHC.Classes.Ord Agda.Syntax.Scope.Base.LocalVar instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.LocalVar instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.LocalVar instance GHC.Classes.Eq Agda.Syntax.Scope.Base.AbstractName instance GHC.Classes.Ord Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Common.LensFixity Agda.Syntax.Scope.Base.AbstractName instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Position.HasRange Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Position.SetRange Agda.Syntax.Scope.Base.AbstractName instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.AbstractName instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.NameMetadata instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.WhyInScope instance GHC.Base.Semigroup Agda.Syntax.Scope.Base.NameMapEntry instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.NameMapEntry instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.KindOfName instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.NameOrModule instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.BindingSource instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.BindingSource instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.NameSpaceId instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.NameSpaceId instance Control.DeepSeq.NFData Agda.Syntax.Scope.Base.DataOrRecordModule instance Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.Name.Suffix -- | An info object contains additional information about a piece of -- abstract syntax that isn't part of the actual syntax. For instance, it -- might contain the source code position of an expression or the -- concrete syntax that an internal expression originates from. module Agda.Syntax.Info data MetaInfo MetaInfo :: Range -> ScopeInfo -> Maybe MetaId -> String -> MetaInfo [metaRange] :: MetaInfo -> Range [metaScope] :: MetaInfo -> ScopeInfo [metaNumber] :: MetaInfo -> Maybe MetaId [metaNameSuggestion] :: MetaInfo -> String emptyMetaInfo :: MetaInfo newtype ExprInfo ExprRange :: Range -> ExprInfo exprNoRange :: ExprInfo -- | Information about application data AppInfo AppInfo :: Range -> Origin -> ParenPreference -> AppInfo [appRange] :: AppInfo -> Range [appOrigin] :: AppInfo -> Origin -- | Do we prefer a lambda argument with or without parens? [appParens] :: AppInfo -> ParenPreference -- | Default is system inserted and prefer parens. defaultAppInfo :: Range -> AppInfo -- | AppInfo with no range information. defaultAppInfo_ :: AppInfo data ModuleInfo ModuleInfo :: Range -> Range -> Maybe Name -> Maybe OpenShortHand -> Maybe ImportDirective -> ModuleInfo [minfoRange] :: ModuleInfo -> Range -- | The range of the "as" and "to" keywords, if any. Retained for -- highlighting purposes. [minfoAsTo] :: ModuleInfo -> Range -- | The "as" module name, if any. Retained for highlighting purposes. [minfoAsName] :: ModuleInfo -> Maybe Name [minfoOpenShort] :: ModuleInfo -> Maybe OpenShortHand -- | Retained for abstractToConcrete of ModuleMacro. [minfoDirective] :: ModuleInfo -> Maybe ImportDirective newtype LetInfo LetRange :: Range -> LetInfo data DefInfo' t DefInfo :: Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> DeclInfo -> Maybe t -> DefInfo' t [defFixity] :: DefInfo' t -> Fixity' [defAccess] :: DefInfo' t -> Access [defAbstract] :: DefInfo' t -> IsAbstract [defInstance] :: DefInfo' t -> IsInstance [defMacro] :: DefInfo' t -> IsMacro [defInfo] :: DefInfo' t -> DeclInfo [defTactic] :: DefInfo' t -> Maybe t mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t -- | Same as mkDefInfo but where we can also give the -- IsInstance mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo' t data DeclInfo DeclInfo :: Name -> Range -> DeclInfo [declName] :: DeclInfo -> Name [declRange] :: DeclInfo -> Range data MutualInfo MutualInfo :: TerminationCheck Name -> CoverageCheck -> PositivityCheck -> Range -> MutualInfo [mutualTerminationCheck] :: MutualInfo -> TerminationCheck Name [mutualCoverageCheck] :: MutualInfo -> CoverageCheck [mutualPositivityCheck] :: MutualInfo -> PositivityCheck [mutualRange] :: MutualInfo -> Range data LHSInfo LHSInfo :: Range -> ExpandedEllipsis -> LHSInfo [lhsRange] :: LHSInfo -> Range [lhsEllipsis] :: LHSInfo -> ExpandedEllipsis -- | For a general pattern we remember the source code position. newtype PatInfo PatRange :: Range -> PatInfo -- | Empty range for patterns. patNoRange :: PatInfo -- | Constructor pattern info. data ConPatInfo ConPatInfo :: ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo -- | Does this pattern come form the eta-expansion of an implicit pattern? [conPatOrigin] :: ConPatInfo -> ConOrigin [conPatInfo] :: ConPatInfo -> PatInfo [conPatLazy] :: ConPatInfo -> ConPatLazy -- | Has the constructor pattern a dotted (forced) constructor? data ConPatLazy -- | Dotted constructor. ConPatLazy :: ConPatLazy -- | Ordinary constructor. ConPatEager :: ConPatLazy instance GHC.Generics.Generic Agda.Syntax.Info.MetaInfo instance GHC.Classes.Eq Agda.Syntax.Info.MetaInfo instance GHC.Show.Show Agda.Syntax.Info.MetaInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.ExprInfo instance Agda.Utils.Null.Null Agda.Syntax.Info.ExprInfo instance GHC.Classes.Eq Agda.Syntax.Info.ExprInfo instance GHC.Show.Show Agda.Syntax.Info.ExprInfo instance GHC.Generics.Generic Agda.Syntax.Info.AppInfo instance GHC.Classes.Ord Agda.Syntax.Info.AppInfo instance GHC.Classes.Eq Agda.Syntax.Info.AppInfo instance GHC.Show.Show Agda.Syntax.Info.AppInfo instance GHC.Generics.Generic Agda.Syntax.Info.ModuleInfo instance GHC.Show.Show Agda.Syntax.Info.ModuleInfo instance GHC.Classes.Eq Agda.Syntax.Info.ModuleInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.LetInfo instance Agda.Utils.Null.Null Agda.Syntax.Info.LetInfo instance GHC.Classes.Eq Agda.Syntax.Info.LetInfo instance GHC.Show.Show Agda.Syntax.Info.LetInfo instance GHC.Generics.Generic Agda.Syntax.Info.DeclInfo instance GHC.Classes.Eq Agda.Syntax.Info.DeclInfo instance GHC.Show.Show Agda.Syntax.Info.DeclInfo instance GHC.Generics.Generic (Agda.Syntax.Info.DefInfo' t) instance GHC.Classes.Eq t => GHC.Classes.Eq (Agda.Syntax.Info.DefInfo' t) instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Info.DefInfo' t) instance GHC.Generics.Generic Agda.Syntax.Info.MutualInfo instance GHC.Classes.Eq Agda.Syntax.Info.MutualInfo instance GHC.Show.Show Agda.Syntax.Info.MutualInfo instance GHC.Generics.Generic Agda.Syntax.Info.LHSInfo instance GHC.Classes.Eq Agda.Syntax.Info.LHSInfo instance GHC.Show.Show Agda.Syntax.Info.LHSInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.PatInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.PatInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.PatInfo instance Agda.Syntax.Position.SetRange Agda.Syntax.Info.PatInfo instance GHC.Show.Show Agda.Syntax.Info.PatInfo instance GHC.Base.Monoid Agda.Syntax.Info.PatInfo instance GHC.Base.Semigroup Agda.Syntax.Info.PatInfo instance Agda.Utils.Null.Null Agda.Syntax.Info.PatInfo instance GHC.Classes.Eq Agda.Syntax.Info.PatInfo instance GHC.Generics.Generic Agda.Syntax.Info.ConPatLazy instance GHC.Enum.Enum Agda.Syntax.Info.ConPatLazy instance GHC.Enum.Bounded Agda.Syntax.Info.ConPatLazy instance GHC.Show.Show Agda.Syntax.Info.ConPatLazy instance GHC.Classes.Ord Agda.Syntax.Info.ConPatLazy instance GHC.Classes.Eq Agda.Syntax.Info.ConPatLazy instance GHC.Generics.Generic Agda.Syntax.Info.ConPatInfo instance GHC.Show.Show Agda.Syntax.Info.ConPatInfo instance GHC.Classes.Eq Agda.Syntax.Info.ConPatInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.ConPatInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.ConPatInfo instance Agda.Syntax.Position.SetRange Agda.Syntax.Info.ConPatInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.ConPatInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.ConPatLazy instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.LHSInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.LHSInfo instance Agda.Utils.Null.Null Agda.Syntax.Info.LHSInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.LHSInfo instance Agda.Utils.Null.Null Agda.Syntax.Info.MutualInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.MutualInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.MutualInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.MutualInfo instance Agda.Syntax.Position.HasRange (Agda.Syntax.Info.DefInfo' t) instance Agda.Syntax.Position.SetRange (Agda.Syntax.Info.DefInfo' t) instance Agda.Syntax.Position.KillRange t => Agda.Syntax.Position.KillRange (Agda.Syntax.Info.DefInfo' t) instance Agda.Syntax.Common.LensIsAbstract (Agda.Syntax.Info.DefInfo' t) instance Agda.Syntax.Common.AnyIsAbstract (Agda.Syntax.Info.DefInfo' t) instance Control.DeepSeq.NFData t => Control.DeepSeq.NFData (Agda.Syntax.Info.DefInfo' t) instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.DeclInfo instance Agda.Syntax.Position.SetRange Agda.Syntax.Info.DeclInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.DeclInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.DeclInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.LetInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.LetInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.ModuleInfo instance Agda.Syntax.Position.SetRange Agda.Syntax.Info.ModuleInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.ModuleInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.ModuleInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.AppInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.AppInfo instance Agda.Syntax.Common.LensOrigin Agda.Syntax.Info.AppInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.AppInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.ExprInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.ExprInfo instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.MetaInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.MetaInfo instance Control.DeepSeq.NFData Agda.Syntax.Info.MetaInfo -- | Types used for precise syntax highlighting. module Agda.Interaction.Highlighting.Precise -- | Syntactic aspects of the code. (These cannot overlap.) data Aspect Comment :: Aspect Keyword :: Aspect String :: Aspect Number :: Aspect Hole :: Aspect -- | Symbols like forall, =, ->, etc. Symbol :: Aspect -- | Things like Set and Prop. PrimitiveType :: Aspect -- | Is the name an operator part? Name :: Maybe NameKind -> Bool -> Aspect -- | Text occurring in pragmas that does not have a more specific aspect. Pragma :: Aspect -- | Non-code contents in literate Agda Background :: Aspect -- | Delimiters used to separate the Agda code blocks from the other -- contents in literate Agda Markup :: Aspect -- | NameKinds are figured out during scope checking. data NameKind -- | Bound variable. Bound :: NameKind -- | Generalizable variable. (This includes generalizable variables that -- have been generalized). Generalizable :: NameKind -- | Inductive or coinductive constructor. Constructor :: Induction -> NameKind Datatype :: NameKind -- | Record field. Field :: NameKind Function :: NameKind -- | Module name. Module :: NameKind Postulate :: NameKind -- | Primitive. Primitive :: NameKind -- | Record type. Record :: NameKind -- | Named argument, like x in {x = v} Argument :: NameKind -- | Macro. Macro :: NameKind -- | Other aspects, generated by type checking. (These can overlap with -- each other and with Aspects.) data OtherAspect Error :: OtherAspect -- | A warning that is considered fatal in the end. ErrorWarning :: OtherAspect DottedPattern :: OtherAspect UnsolvedMeta :: OtherAspect -- | Unsolved constraint not connected to meta-variable. This could for -- instance be an emptyness constraint. UnsolvedConstraint :: OtherAspect TerminationProblem :: OtherAspect PositivityProblem :: OtherAspect -- | Used for highlighting unreachable clauses, unreachable RHS (because of -- an absurd pattern), etc. Deadcode :: OtherAspect -- | Used for shadowed repeated variable names in telescopes. ShadowingInTelescope :: OtherAspect CoverageProblem :: OtherAspect -- | When this constructor is used it is probably a good idea to include a -- note explaining why the pattern is incomplete. IncompletePattern :: OtherAspect -- | Code which is being type-checked. TypeChecks :: OtherAspect -- | Function declaration without matching definition NB: We put -- CatchallClause last so that it is overwritten by other, more -- important, aspects in the emacs mode. MissingDefinition :: OtherAspect CatchallClause :: OtherAspect ConfluenceProblem :: OtherAspect -- | Meta information which can be associated with a character/character -- range. data Aspects Aspects :: Maybe Aspect -> Set OtherAspect -> String -> Maybe DefinitionSite -> !TokenBased -> Aspects [aspect] :: Aspects -> Maybe Aspect [otherAspects] :: Aspects -> Set OtherAspect -- | This note, if not null, can be displayed as a tool-tip or something -- like that. It should contain useful information about the range (like -- the module containing a certain identifier, or the fixity of an -- operator). [note] :: Aspects -> String -- | The definition site of the annotated thing, if applicable and known. [definitionSite] :: Aspects -> Maybe DefinitionSite -- | Is this entry token-based? [tokenBased] :: Aspects -> !TokenBased data DefinitionSite DefinitionSite :: TopLevelModuleName -> Int -> Bool -> Maybe String -> DefinitionSite -- | The defining module. [defSiteModule] :: DefinitionSite -> TopLevelModuleName -- | The file position in that module. File positions are counted from 1. [defSitePos] :: DefinitionSite -> Int -- | Has this DefinitionSite been created at the defining site of -- the name? [defSiteHere] :: DefinitionSite -> Bool -- | A pretty name for the HTML linking. [defSiteAnchor] :: DefinitionSite -> Maybe String -- | Is the highlighting "token-based", i.e. based only on information from -- the lexer? data TokenBased TokenBased :: TokenBased NotOnlyTokenBased :: TokenBased -- | A limited kind of syntax highlighting information: a pair consisting -- of Ranges and Aspects. -- -- Note the invariant which RangePairs should satisfy -- (rangePairInvariant). newtype RangePair RangePair :: (Ranges, Aspects) -> RangePair [rangePair] :: RangePair -> (Ranges, Aspects) -- | Invariant for RangePair. rangePairInvariant :: RangePair -> Bool -- | Syntax highlighting information, represented by maps from positions to -- Aspects. -- -- The first position in the file has number 1. newtype PositionMap PositionMap :: IntMap Aspects -> PositionMap [positionMap] :: PositionMap -> IntMap Aspects -- | Highlighting info with delayed merging. -- -- Merging large sets of highlighting info repeatedly might be costly. -- The idea of this type is to accumulate small pieces of highlighting -- information, and then to merge them all at the end. -- -- Note the invariant which values of this type should satisfy -- (delayedMergeInvariant). newtype DelayedMerge hl DelayedMerge :: Endo [hl] -> DelayedMerge hl -- | Invariant for DelayedMerge hl, parametrised by the -- invariant for hl. -- -- Additionally the endofunction should be extensionally equal to (fs -- ++) for some list fs. delayedMergeInvariant :: (hl -> Bool) -> DelayedMerge hl -> Bool -- | Highlighting information. -- -- Note the invariant which values of this type should satisfy -- (highlightingInfoInvariant). -- -- This is a type synonym in order to make it easy to change to another -- representation. type HighlightingInfo = RangeMap Aspects -- | The invariant for HighlightingInfo. highlightingInfoInvariant :: HighlightingInfo -> Bool -- | A type that is intended to be used when constructing highlighting -- information. -- -- Note the invariant which values of this type should satisfy -- (highlightingInfoBuilderInvariant). -- -- This is a type synonym in order to make it easy to change to another -- representation. -- -- The type should be an instance of IsBasicRangeMap -- Aspects, Semigroup and Monoid, and there -- should be an instance of Convert -- HighlightingInfoBuilder HighlightingInfo. type HighlightingInfoBuilder = DelayedMerge RangePair -- | The invariant for HighlightingInfoBuilder. -- -- Additionally the endofunction should be extensionally equal to (fs -- ++) for some list fs. highlightingInfoBuilderInvariant :: HighlightingInfoBuilder -> Bool -- | A variant of mempty with tokenBased set to -- NotOnlyTokenBased. parserBased :: Aspects -- | Conversion from classification of the scope checker. kindOfNameToNameKind :: KindOfName -> NameKind -- | A class that is intended to make it easy to swap between different -- range map implementations. -- -- Note that some RangeMap operations are not included in this -- class. class IsBasicRangeMap a m | m -> a -- | The map singleton rs x contains the ranges from -- rs, and every position in those ranges is associated with -- x. singleton :: IsBasicRangeMap a m => Ranges -> a -> m -- | Converts range maps to IntMaps from positions to values. toMap :: IsBasicRangeMap a m => m -> IntMap a -- | Converts the map to a list. The ranges are non-overlapping and -- non-empty, and earlier ranges precede later ones in the list. toList :: IsBasicRangeMap a m => m -> [(Range, a)] -- | Returns the smallest range covering everything in the map (or -- Nothing, if the range would be empty). -- -- Note that the default implementation of this operation might be -- inefficient. coveringRange :: IsBasicRangeMap a m => m -> Maybe Range -- | Like singleton, but with several Ranges instead of only -- one. several :: (IsBasicRangeMap a hl, Monoid hl) => [Ranges] -> a -> hl -- | Conversion between different types. class Convert a b convert :: Convert a b => a -> b -- | Returns a RangeMap overlapping the given range, as well as the -- rest of the map. insideAndOutside :: Range -> RangeMap a -> (RangeMap a, RangeMap a) -- | Restricts the RangeMap to the given range. restrictTo :: Range -> RangeMap a -> RangeMap a instance GHC.Generics.Generic Agda.Interaction.Highlighting.Precise.NameKind instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.NameKind instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.NameKind instance GHC.Generics.Generic Agda.Interaction.Highlighting.Precise.Aspect instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.Aspect instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.Aspect instance GHC.Generics.Generic Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Enum.Bounded Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Enum.Enum Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Classes.Ord Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Generics.Generic Agda.Interaction.Highlighting.Precise.DefinitionSite instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.DefinitionSite instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.TokenBased instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.TokenBased instance GHC.Generics.Generic Agda.Interaction.Highlighting.Precise.Aspects instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.Aspects instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.RangePair instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.RangePair instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.PositionMap instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.PositionMap instance GHC.Base.Monoid (Agda.Interaction.Highlighting.Precise.DelayedMerge hl) instance GHC.Base.Semigroup (Agda.Interaction.Highlighting.Precise.DelayedMerge hl) instance Agda.Utils.RangeMap.IsBasicRangeMap Agda.Interaction.Highlighting.Precise.Aspects Agda.Interaction.Highlighting.Precise.RangePair instance GHC.Base.Semigroup a => Agda.Utils.RangeMap.IsBasicRangeMap a (Agda.Interaction.Highlighting.Precise.DelayedMerge (Agda.Utils.RangeMap.RangeMap a)) instance Agda.Utils.RangeMap.IsBasicRangeMap Agda.Interaction.Highlighting.Precise.Aspects (Agda.Interaction.Highlighting.Precise.DelayedMerge Agda.Interaction.Highlighting.Precise.RangePair) instance Agda.Utils.RangeMap.IsBasicRangeMap Agda.Interaction.Highlighting.Precise.Aspects (Agda.Interaction.Highlighting.Precise.DelayedMerge Agda.Interaction.Highlighting.Precise.PositionMap) instance GHC.Base.Monoid hl => Agda.Interaction.Highlighting.Precise.Convert (Agda.Interaction.Highlighting.Precise.DelayedMerge hl) hl instance Agda.Interaction.Highlighting.Precise.Convert (Agda.Utils.RangeMap.RangeMap Agda.Interaction.Highlighting.Precise.Aspects) (Agda.Utils.RangeMap.RangeMap Agda.Interaction.Highlighting.Precise.Aspects) instance Agda.Interaction.Highlighting.Precise.Convert Agda.Interaction.Highlighting.Precise.PositionMap (Agda.Utils.RangeMap.RangeMap Agda.Interaction.Highlighting.Precise.Aspects) instance Agda.Interaction.Highlighting.Precise.Convert (Agda.Interaction.Highlighting.Precise.DelayedMerge Agda.Interaction.Highlighting.Precise.PositionMap) (Agda.Utils.RangeMap.RangeMap Agda.Interaction.Highlighting.Precise.Aspects) instance Agda.Interaction.Highlighting.Precise.Convert (Agda.Interaction.Highlighting.Precise.DelayedMerge Agda.Interaction.Highlighting.Precise.RangePair) Agda.Interaction.Highlighting.Precise.PositionMap instance Agda.Interaction.Highlighting.Precise.Convert (Agda.Interaction.Highlighting.Precise.DelayedMerge Agda.Interaction.Highlighting.Precise.RangePair) (Agda.Utils.RangeMap.RangeMap Agda.Interaction.Highlighting.Precise.Aspects) instance GHC.Show.Show hl => GHC.Show.Show (Agda.Interaction.Highlighting.Precise.DelayedMerge hl) instance Agda.Utils.RangeMap.IsBasicRangeMap Agda.Interaction.Highlighting.Precise.Aspects Agda.Interaction.Highlighting.Precise.PositionMap instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.PositionMap instance GHC.Base.Monoid Agda.Interaction.Highlighting.Precise.PositionMap instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.Aspects instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.Aspects instance GHC.Base.Monoid Agda.Interaction.Highlighting.Precise.Aspects instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.Aspects instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.TokenBased instance GHC.Base.Monoid Agda.Interaction.Highlighting.Precise.TokenBased instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.DefinitionSite instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.DefinitionSite instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.DefinitionSite instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.OtherAspect instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.Aspect instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.Aspect instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.NameKind instance Control.DeepSeq.NFData Agda.Interaction.Highlighting.Precise.NameKind -- | Sparse matrices. -- -- We assume the matrices to be very sparse, so we just implement them as -- sorted association lists. -- -- Most operations are linear in the number of non-zero elements. -- -- An exception is transposition, which needs to sort the association -- list again; it has the complexity of sorting: n log n where -- n is the number of non-zero elements. -- -- Another exception is matrix multiplication, of course. module Agda.Termination.SparseMatrix -- | Type of matrices, parameterised on the type of values. -- -- Sparse matrices are implemented as an ordered association list, -- mapping coordinates to values. data Matrix i b Matrix :: Size i -> [(MIx i, b)] -> Matrix i b -- | Association of indices to values. unM :: Matrix i b -> [(MIx i, b)] -- | Size of a matrix. data Size i Size :: i -> i -> Size i -- | Number of rows, >= 0. [rows] :: Size i -> i -- | Number of columns, >= 0. [cols] :: Size i -> i -- | Type of matrix indices (row, column). data MIx i MIx :: i -> i -> MIx i -- | Row index, 1 <= row <= rows. [row] :: MIx i -> i -- | Column index 1 <= col <= cols. [col] :: MIx i -> i -- | fromLists sz rs constructs a matrix from a list of -- lists of values (a list of rows). O(size) where size = -- rows × cols. -- -- Precondition: length rs == rows sz and -- all ((cols sz ==) . length) rs. fromLists :: (Ord i, Num i, Enum i, HasZero b) => Size i -> [[b]] -> Matrix i b -- | Constructs a matrix from a list of (index, value)-pairs. -- O(n) where n is size of the list. -- -- Precondition: indices are unique. fromIndexList :: (Ord i, HasZero b) => Size i -> [(MIx i, b)] -> Matrix i b -- | Converts a matrix to a list of row lists. O(size) where -- size = rows × cols. toLists :: (Integral i, HasZero b) => Matrix i b -> [[b]] -- | Dimensions of the matrix. size :: Matrix i b -> Size i -- | True iff the matrix is square. square :: Ix i => Matrix i b -> Bool -- | Returns True iff the matrix is empty. isEmpty :: (Num i, Ix i) => Matrix i b -> Bool -- | Returns 'Just b' iff it is a 1x1 matrix with just one entry -- b. O(1). isSingleton :: (Eq i, Num i, HasZero b) => Matrix i b -> Maybe b -- | General pointwise combination function for sparse matrices. O(n1 + -- n2). zipMatrices :: forall a b c i. Ord i => (a -> c) -> (b -> c) -> (a -> b -> c) -> (c -> Bool) -> Matrix i a -> Matrix i b -> Matrix i c -- | add (+) m1 m2 adds m1 and m2, using -- (+) to add values. O(n1 + n2). -- -- Returns a matrix of size supSize m1 m2. add :: (Ord i, HasZero a) => (a -> a -> a) -> Matrix i a -> Matrix i a -> Matrix i a -- | intersectWith f m1 m2 build the pointwise conjunction -- m1 and m2. Uses f to combine non-zero -- values. O(n1 + n2). -- -- Returns a matrix of size infSize m1 m2. intersectWith :: Ord i => (a -> a -> a) -> Matrix i a -> Matrix i a -> Matrix i a -- | Association list intersection. O(n1 + n2). -- --
--   interAssocWith f l l' = { (i, f a b) | (i,a) ∈ l and (i,b) ∈ l' }
--   
-- -- Used to combine sparse matrices, it might introduce zero elements if -- f can return zero for non-zero arguments. interAssocWith :: Ord i => (a -> a -> a) -> [(i, a)] -> [(i, a)] -> [(i, a)] -- | mul semiring m1 m2 multiplies matrices m1 and -- m2. Uses the operations of the semiring semiring to -- perform the multiplication. -- -- O(n1 + n2 log n2 + Σ(i <= r1) Σ(j <= c2) d(i,j)) where -- r1 is the number of non-empty rows in m1 and -- c2 is the number of non-empty columns in m2 and -- d(i,j) is the bigger one of the following two quantifies: the -- length of sparse row i in m1 and the length of -- sparse column j in m2. -- -- Given dimensions m1 : r1 × c1 and m2 : r2 × c2, a -- matrix of size r1 × c2 is returned. It is not necessary that -- c1 == r2, the matrices are implicitly patched with zeros to -- match up for multiplication. For sparse matrices, this patching is a -- no-op. mul :: (Ix i, Eq a) => Semiring a -> Matrix i a -> Matrix i a -> Matrix i a transpose :: Transpose a => a -> a -- | diagonal m extracts the diagonal of m. -- -- For non-square matrices, the length of the diagonal is the minimum of -- the dimensions of the matrix. class Diagonal m e | m -> e diagonal :: Diagonal m e => m -> [e] -- | Converts a sparse matrix to a sparse list of rows. O(n) where -- n is the number of non-zero entries of the matrix. -- -- Only non-empty rows are generated. toSparseRows :: Eq i => Matrix i b -> [(i, [(i, b)])] -- | Compute the matrix size of the union of two matrices. supSize :: Ord i => Matrix i a -> Matrix i b -> Size i -- | General pointwise combination function for association lists. O(n1 -- + n2) where ni is the number of non-zero element in -- matrix i. -- -- In zipAssocWith fs gs f g h l l', -- -- fs is possibly more efficient version of mapMaybe -- ( (i, a) -> (i,) $ f a), and same for gs and -- g. zipAssocWith :: Ord i => ([(i, a)] -> [(i, c)]) -> ([(i, b)] -> [(i, c)]) -> (a -> Maybe c) -> (b -> Maybe c) -> (a -> b -> Maybe c) -> [(i, a)] -> [(i, b)] -> [(i, c)] -- | addRow x m adds a new row to m, after the -- rows already existing in the matrix. All elements in the new row get -- set to x. addRow :: (Num i, HasZero b) => b -> Matrix i b -> Matrix i b -- | addColumn x m adds a new column to m, after -- the columns already existing in the matrix. All elements in the new -- column get set to x. addColumn :: (Num i, HasZero b) => b -> Matrix i b -> Matrix i b instance GHC.Show.Show i => GHC.Show.Show (Agda.Termination.SparseMatrix.Size i) instance GHC.Classes.Ord i => GHC.Classes.Ord (Agda.Termination.SparseMatrix.Size i) instance GHC.Classes.Eq i => GHC.Classes.Eq (Agda.Termination.SparseMatrix.Size i) instance GHC.Ix.Ix i => GHC.Ix.Ix (Agda.Termination.SparseMatrix.MIx i) instance GHC.Show.Show i => GHC.Show.Show (Agda.Termination.SparseMatrix.MIx i) instance GHC.Classes.Ord i => GHC.Classes.Ord (Agda.Termination.SparseMatrix.MIx i) instance GHC.Classes.Eq i => GHC.Classes.Eq (Agda.Termination.SparseMatrix.MIx i) instance Data.Traversable.Traversable (Agda.Termination.SparseMatrix.Matrix i) instance Data.Foldable.Foldable (Agda.Termination.SparseMatrix.Matrix i) instance GHC.Base.Functor (Agda.Termination.SparseMatrix.Matrix i) instance (GHC.Classes.Ord i, GHC.Classes.Ord b) => GHC.Classes.Ord (Agda.Termination.SparseMatrix.Matrix i b) instance (GHC.Classes.Eq i, GHC.Classes.Eq b) => GHC.Classes.Eq (Agda.Termination.SparseMatrix.Matrix i b) instance Agda.Termination.SparseMatrix.Transpose (Agda.Termination.SparseMatrix.Size i) instance Agda.Termination.SparseMatrix.Transpose (Agda.Termination.SparseMatrix.MIx i) instance GHC.Classes.Ord i => Agda.Termination.SparseMatrix.Transpose (Agda.Termination.SparseMatrix.Matrix i b) instance (GHC.Real.Integral i, Agda.Termination.Semiring.HasZero b, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Termination.SparseMatrix.Matrix i b) instance (GHC.Real.Integral i, Agda.Termination.Semiring.HasZero b) => Agda.Termination.SparseMatrix.Diagonal (Agda.Termination.SparseMatrix.Matrix i b) b instance (GHC.Classes.Ord i, Agda.Utils.PartialOrd.PartialOrd a) => Agda.Utils.PartialOrd.PartialOrd (Agda.Termination.SparseMatrix.Matrix i a) instance (GHC.Real.Integral i, Agda.Termination.Semiring.HasZero b, GHC.Show.Show i, GHC.Show.Show b) => GHC.Show.Show (Agda.Termination.SparseMatrix.Matrix i b) -- | An Abstract domain of relative sizes, i.e., differences between size -- of formal function parameter and function argument in recursive call; -- used in the termination checker. module Agda.Termination.Order -- | In the paper referred to above, there is an order R with -- Unknown <= Le <= -- Lt. -- -- This is generalized to Unknown <= 'Decr k' -- where Decr 1 replaces Lt and Decr 0 -- replaces Le. A negative decrease means an increase. The -- generalization allows the termination checker to record an increase by -- 1 which can be compensated by a following decrease by 2 which results -- in an overall decrease. -- -- However, the termination checker of the paper itself terminates -- because there are only finitely many different call-matrices. To -- maintain termination of the terminator we set a cutoff point -- which determines how high the termination checker can count. This -- value should be set by a global or file-wise option. -- -- See Call for more information. -- -- TODO: document orders which are call-matrices themselves. data Order -- | Decrease of callee argument wrt. caller parameter. -- -- The Bool indicates whether the decrease (if any) is usable. -- In any chain, there needs to be one usable decrease. Unusable -- decreases come from SIZELT constraints which are not in inductive -- pattern match or a coinductive copattern match. See issue #2331. -- -- UPDATE: Andreas, 2017-07-26: Feature #2331 is unsound due to size -- quantification in terms. While the infrastructure for usable/unusable -- decrease remains in place, no unusable decreases are generated by -- TermCheck. Decr :: !Bool -> {-# UNPACK #-} !Int -> Order -- | No relation, infinite increase, or increase beyond termination depth. Unknown :: Order -- | Matrix-shaped order, currently UNUSED. Mat :: {-# UNPACK #-} !Matrix Int Order -> Order -- | Smart constructor for Decr k :: Order which cuts off too big -- values. -- -- Possible values for k: - ?cutoff <= k -- <= ?cutoff + 1. decr :: (?cutoff :: CutOff) => Bool -> Int -> Order -- | Raw increase which does not cut off. increase :: Int -> Order -> Order -- | Raw decrease which does not cut off. decrease :: Int -> Order -> Order setUsability :: Bool -> Order -> Order -- | Multiplication of Orders. (Corresponds to sequential -- composition.) (.*.) :: (?cutoff :: CutOff) => Order -> Order -> Order -- | The supremum of a (possibly empty) list of Orders. More -- information (i.e., more decrease) is bigger. Unknown is no -- information, thus, smallest. supremum :: (?cutoff :: CutOff) => [Order] -> Order -- | The infimum of a (non empty) list of Orders. Gets the worst -- information. Unknown is the least element, thus, dominant. infimum :: (?cutoff :: CutOff) => [Order] -> Order -- | We use a record for semiring instead of a type class since implicit -- arguments cannot occur in instance constraints, like instance -- (?cutoff :: Int) => SemiRing Order. orderSemiring :: (?cutoff :: CutOff) => Semiring Order -- | le, lt, decreasing, unknown: for -- backwards compatibility, and for external use. le :: Order -- | Usable decrease. lt :: Order unknown :: Order -- | Smart constructor for matrix shaped orders, avoiding empty and -- singleton matrices. orderMat :: Matrix Int Order -> Order collapseO :: (?cutoff :: CutOff) => Order -> Order nonIncreasing :: Order -> Bool -- | Decreasing and usable? decreasing :: Order -> Bool -- | Matrix-shaped order is decreasing if any diagonal element is -- decreasing. isDecr :: Order -> Bool -- | A partial order, aimed at deciding whether a call graph gets worse -- during the completion. class NotWorse a notWorse :: NotWorse a => a -> a -> Bool isOrder :: (?cutoff :: CutOff) => Order -> Bool instance GHC.Show.Show Agda.Termination.Order.Order instance GHC.Classes.Ord Agda.Termination.Order.Order instance GHC.Classes.Eq Agda.Termination.Order.Order instance Agda.Termination.Order.NotWorse Agda.Termination.Order.Order instance (GHC.Classes.Ord i, Agda.Termination.Semiring.HasZero o, Agda.Termination.Order.NotWorse o) => Agda.Termination.Order.NotWorse (Agda.Termination.SparseMatrix.Matrix i o) instance Agda.Termination.Semiring.HasZero Agda.Termination.Order.Order instance Agda.Utils.PartialOrd.PartialOrd Agda.Termination.Order.Order instance Agda.Utils.Pretty.Pretty Agda.Termination.Order.Order module Agda.Termination.CallMatrix -- | Call matrix indices = function argument indices. -- -- Machine integer Int is sufficient, since we cannot index more -- arguments than we have addresses on our machine. type ArgumentIndex = Int -- | Call matrices. -- -- A call matrix for a call f --> g has dimensions ar(g) -- × ar(f). -- -- Each column corresponds to one formal argument of caller f. -- Each row corresponds to one argument in the call to g. -- -- In the presence of dot patterns, a call argument can be related to -- several different formal arguments of f. -- -- See e.g. testsucceedDotPatternTermination.agda: -- --
--   data D : Nat -> Set where
--     cz : D zero
--     c1 : forall n -> D n -> D (suc n)
--     c2 : forall n -> D n -> D n
--   
--   f : forall n -> D n -> Nat
--   f .zero    cz        = zero
--   f .(suc n) (c1  n d) = f n (c2 n d)
--   f n        (c2 .n d) = f n d
--   
--   
-- -- Call matrices (without guardedness) are -- --
--   -1 -1   n < suc n  and       n <  c1 n d
--    ?  =                   c2 n d <= c1 n d
--   
--    = -1   n <= n     and  n < c2 n d
--    ? -1                   d < c2 n d
--   
--   
-- -- Here is a part of the original documentation for call matrices (kept -- for historical reasons): -- -- This datatype encodes information about a single recursive function -- application. The columns of the call matrix stand for source -- function arguments (patterns). The rows of the matrix stand for -- target function arguments. Element (i, j) in the -- matrix should be computed as follows: -- -- newtype CallMatrix' a CallMatrix :: Matrix ArgumentIndex a -> CallMatrix' a [mat] :: CallMatrix' a -> Matrix ArgumentIndex a type CallMatrix = CallMatrix' Order -- | Call matrix multiplication and call combination. class CallComb a (>*<) :: (CallComb a, ?cutoff :: CutOff) => a -> a -> a -- | Call matrix augmented with path information. data CallMatrixAug cinfo CallMatrixAug :: CallMatrix -> cinfo -> CallMatrixAug cinfo -- | The matrix of the (composed call). [augCallMatrix] :: CallMatrixAug cinfo -> CallMatrix -- | Meta info, like call path. [augCallInfo] :: CallMatrixAug cinfo -> cinfo -- | Non-augmented call matrix. noAug :: Monoid cinfo => CallMatrix -> CallMatrixAug cinfo -- | Sets of incomparable call matrices augmented with path information. -- Use overloaded Null, empty, singleton, -- mappend. newtype CMSet cinfo CMSet :: Favorites (CallMatrixAug cinfo) -> CMSet cinfo [cmSet] :: CMSet cinfo -> Favorites (CallMatrixAug cinfo) -- | Insert into a call matrix set. insert :: CallMatrixAug cinfo -> CMSet cinfo -> CMSet cinfo -- | Union two call matrix sets. union :: CMSet cinfo -> CMSet cinfo -> CMSet cinfo -- | Convert into a list of augmented call matrices. toList :: CMSet cinfo -> [CallMatrixAug cinfo] instance Agda.Utils.PartialOrd.PartialOrd a => Agda.Utils.PartialOrd.PartialOrd (Agda.Termination.CallMatrix.CallMatrix' a) instance Data.Traversable.Traversable Agda.Termination.CallMatrix.CallMatrix' instance Data.Foldable.Foldable Agda.Termination.CallMatrix.CallMatrix' instance GHC.Base.Functor Agda.Termination.CallMatrix.CallMatrix' instance (Agda.Termination.Semiring.HasZero a, GHC.Show.Show a) => GHC.Show.Show (Agda.Termination.CallMatrix.CallMatrix' a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Termination.CallMatrix.CallMatrix' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Termination.CallMatrix.CallMatrix' a) instance GHC.Show.Show cinfo => GHC.Show.Show (Agda.Termination.CallMatrix.CallMatrixAug cinfo) instance GHC.Classes.Eq cinfo => GHC.Classes.Eq (Agda.Termination.CallMatrix.CallMatrixAug cinfo) instance Agda.Utils.Singleton.Singleton (Agda.Termination.CallMatrix.CallMatrixAug cinfo) (Agda.Termination.CallMatrix.CMSet cinfo) instance Agda.Utils.Null.Null (Agda.Termination.CallMatrix.CMSet cinfo) instance GHC.Base.Monoid (Agda.Termination.CallMatrix.CMSet cinfo) instance GHC.Base.Semigroup (Agda.Termination.CallMatrix.CMSet cinfo) instance GHC.Show.Show cinfo => GHC.Show.Show (Agda.Termination.CallMatrix.CMSet cinfo) instance Agda.Termination.Order.NotWorse Agda.Termination.CallMatrix.CallMatrix instance GHC.Base.Monoid cinfo => Agda.Termination.CallMatrix.CallComb (Agda.Termination.CallMatrix.CMSet cinfo) instance Agda.Utils.Pretty.Pretty cinfo => Agda.Utils.Pretty.Pretty (Agda.Termination.CallMatrix.CMSet cinfo) instance Agda.Termination.SparseMatrix.Diagonal (Agda.Termination.CallMatrix.CallMatrixAug cinfo) Agda.Termination.Order.Order instance Agda.Utils.PartialOrd.PartialOrd (Agda.Termination.CallMatrix.CallMatrixAug cinfo) instance Agda.Termination.Order.NotWorse (Agda.Termination.CallMatrix.CallMatrixAug cinfo) instance GHC.Base.Monoid cinfo => Agda.Termination.CallMatrix.CallComb (Agda.Termination.CallMatrix.CallMatrixAug cinfo) instance Agda.Utils.Pretty.Pretty cinfo => Agda.Utils.Pretty.Pretty (Agda.Termination.CallMatrix.CallMatrixAug cinfo) instance Agda.Termination.CallMatrix.CallComb Agda.Termination.CallMatrix.CallMatrix instance Agda.Utils.Pretty.Pretty Agda.Termination.CallMatrix.CallMatrix instance Agda.Termination.Semiring.HasZero a => Agda.Termination.SparseMatrix.Diagonal (Agda.Termination.CallMatrix.CallMatrix' a) a -- | Call graphs and related concepts, more or less as defined in "A -- Predicative Analysis of Structural Recursion" by Andreas Abel and -- Thorsten Altenkirch. module Agda.Termination.CallGraph -- | Call graph nodes. -- -- Machine integer Int is sufficient, since we cannot index more -- than we have addresses on our machine. type Node = Int -- | Calls are edges in the call graph. It can be labelled with several -- call matrices if there are several pathes from one function to -- another. type Call cinfo = Edge Node (CMSet cinfo) -- | Make a call with a single matrix. mkCall :: Node -> Node -> CallMatrix -> cinfo -> Call cinfo -- | Make a call with empty cinfo. mkCall' :: Monoid cinfo => Node -> Node -> CallMatrix -> Call cinfo -- | Outgoing node. source :: Edge n e -> n -- | Incoming node. target :: Edge n e -> n callMatrixSet :: Call cinfo -> CMSet cinfo (>*<) :: (CallComb a, ?cutoff :: CutOff) => a -> a -> a -- | A call graph is a set of calls. Every call also has some associated -- meta information, which should be Monoidal so that the meta -- information for different calls can be combined when the calls are -- combined. newtype CallGraph cinfo CallGraph :: Graph Node (CMSet cinfo) -> CallGraph cinfo [theCallGraph] :: CallGraph cinfo -> Graph Node (CMSet cinfo) -- | Returns all the nodes with incoming edges. Somewhat expensive. -- O(e). targetNodes :: CallGraph cinfo -> Set Node fromList :: Collection el coll => [el] -> coll -- | Converts a call graph to a list of calls with associated meta -- information. toList :: CallGraph cinfo -> [Call cinfo] -- | Takes the union of two call graphs. union :: CallGraph cinfo -> CallGraph cinfo -> CallGraph cinfo -- | Inserts a call into a call graph. insert :: Node -> Node -> CallMatrix -> cinfo -> CallGraph cinfo -> CallGraph cinfo -- | Call graph comparison. A graph cs' is `worse' than -- cs if it has a new edge (call) or a call got worse, which -- means that one of its elements that was better or equal to Le -- moved a step towards Un. -- -- A call graph is complete if combining it with itself does not make it -- any worse. This is sound because of monotonicity: By combining a graph -- with itself, it can only get worse, but if it does not get worse after -- one such step, it gets never any worse. -- -- complete cs completes the call graph cs. A -- call graph is complete if it contains all indirect calls; if f -- -> g and g -> h are present in the graph, then -- f -> h should also be present. complete :: (?cutoff :: CutOff) => Monoid cinfo => CallGraph cinfo -> CallGraph cinfo completionStep :: (?cutoff :: CutOff) => Monoid cinfo => CallGraph cinfo -> CallGraph cinfo -> (CallGraph cinfo, CallGraph cinfo) instance GHC.Show.Show cinfo => GHC.Show.Show (Agda.Termination.CallGraph.CallGraph cinfo) instance Agda.Termination.CallGraph.CombineNewOld (Agda.Termination.CallMatrix.CMSet cinfo) instance Agda.Utils.PartialOrd.PartialOrd a => Agda.Termination.CallGraph.CombineNewOld (Agda.Utils.Favorites.Favorites a) instance (GHC.Base.Monoid a, Agda.Termination.CallGraph.CombineNewOld a, GHC.Classes.Ord n) => Agda.Termination.CallGraph.CombineNewOld (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n a) instance Agda.Utils.Null.Null (Agda.Termination.CallGraph.CallGraph cinfo) instance GHC.Base.Semigroup (Agda.Termination.CallGraph.CallGraph cinfo) instance GHC.Base.Monoid (Agda.Termination.CallGraph.CallGraph cinfo) instance Agda.Utils.Singleton.Singleton (Agda.Termination.CallGraph.Call cinfo) (Agda.Termination.CallGraph.CallGraph cinfo) instance Agda.Utils.Singleton.Collection (Agda.Termination.CallGraph.Call cinfo) (Agda.Termination.CallGraph.CallGraph cinfo) instance Agda.Utils.Pretty.Pretty cinfo => Agda.Utils.Pretty.Pretty (Agda.Termination.CallGraph.CallGraph cinfo) -- | Termination checker, based on "A Predicative Analysis of Structural -- Recursion" by Andreas Abel and Thorsten Altenkirch (JFP'01), and "The -- Size-Change Principle for Program Termination" by Chin Soon Lee, Neil -- Jones, and Amir Ben-Amram (POPL'01). module Agda.Termination.Termination -- | TODO: This comment seems to be partly out of date. -- -- terminates cs checks if the functions represented by -- cs terminate. The call graph cs should have one -- entry (Call) per recursive function application. -- -- Right perms is returned if the functions are -- size-change terminating. -- -- If termination can not be established, then Left -- problems is returned instead. Here problems contains an -- indication of why termination cannot be established. See -- lexOrder for further details. -- -- Note that this function assumes that all data types are strictly -- positive. -- -- The termination criterion is taken from Jones et al. In the completed -- call graph, each idempotent call-matrix from a function to itself must -- have a decreasing argument. Idempotency is wrt. matrix multiplication. -- -- This criterion is strictly more liberal than searching for a -- lexicographic order (and easier to implement, but harder to justify). terminates :: (Monoid cinfo, ?cutoff :: CutOff) => CallGraph cinfo -> Either cinfo () terminatesFilter :: (Monoid cinfo, ?cutoff :: CutOff) => (Node -> Bool) -> CallGraph cinfo -> Either cinfo () endos :: [Call cinfo] -> [CallMatrixAug cinfo] -- | A call c is idempotent if it is an endo (source == -- target) of order 1. (Endo-calls of higher orders are e.g. -- argument permutations). We can test idempotency by self-composition. -- Self-composition c >*< c should not make any -- parameter-argument relation worse. idempotent :: (?cutoff :: CutOff) => CallMatrixAug cinfo -> Bool -- | This module defines the things required by Alex and some other Alex -- related things. module Agda.Syntax.Parser.Alex -- | This is what the lexer manipulates. data AlexInput AlexInput :: !SrcFile -> !PositionWithoutFile -> String -> !Char -> AlexInput -- | File. [lexSrcFile] :: AlexInput -> !SrcFile -- | Current position. [lexPos] :: AlexInput -> !PositionWithoutFile -- | Current input. [lexInput] :: AlexInput -> String -- | Previously read character. [lexPrevChar] :: AlexInput -> !Char -- | A lens for lexInput. lensLexInput :: Lens' String AlexInput -- | Get the previously lexed character. Same as lexPrevChar. Alex -- needs this to be defined to handle "patterns with a left-context". alexInputPrevChar :: AlexInput -> Char -- | Returns the next character, and updates the AlexInput value. -- -- This function is not suitable for use by Alex 2, because it can return -- non-ASCII characters. alexGetChar :: AlexInput -> Maybe (Char, AlexInput) -- | Returns the next byte, and updates the AlexInput value. -- -- A trick is used to handle the fact that there are more than 256 -- Unicode code points. The function translates characters to bytes in -- the following way: -- -- -- -- Note that it is important that there are no keywords containing 'z', -- '+', ' ' or '\1'. -- -- This function is used by Alex (version 3). alexGetByte :: AlexInput -> Maybe (Word8, AlexInput) -- | In the lexer, regular expressions are associated with lex actions -- who's task it is to construct the tokens. newtype LexAction r LexAction :: (PreviousInput -> CurrentInput -> TokenLength -> Parser r) -> LexAction r [runLexAction] :: LexAction r -> PreviousInput -> CurrentInput -> TokenLength -> Parser r -- | Sometimes regular expressions aren't enough. Alex provides a way to do -- arbitrary computations to see if the input matches. This is done with -- a lex predicate. type LexPredicate = ([LexState], ParseFlags) -> PreviousInput -> TokenLength -> CurrentInput -> Bool -- | Conjunction of LexPredicates. (.&&.) :: LexPredicate -> LexPredicate -> LexPredicate -- | Disjunction of LexPredicates. (.||.) :: LexPredicate -> LexPredicate -> LexPredicate -- | Negation of LexPredicates. not' :: LexPredicate -> LexPredicate type PreviousInput = AlexInput type CurrentInput = AlexInput type TokenLength = Int getLexInput :: Parser AlexInput setLexInput :: AlexInput -> Parser () instance GHC.Base.Functor Agda.Syntax.Parser.Alex.LexAction instance GHC.Base.Applicative Agda.Syntax.Parser.Alex.LexAction instance GHC.Base.Monad Agda.Syntax.Parser.Alex.LexAction instance Control.Monad.State.Class.MonadState Agda.Syntax.Parser.Monad.ParseState Agda.Syntax.Parser.Alex.LexAction -- | When lexing by hand (for instance string literals) we need to do some -- looking ahead. The LookAhead monad keeps track of the position -- we are currently looking at, and provides facilities to synchronise -- the look-ahead position with the actual position of the Parser -- monad (see sync and rollback). module Agda.Syntax.Parser.LookAhead -- | The LookAhead monad is basically a state monad keeping with an extra -- AlexInput, wrapped around the Parser monad. data LookAhead a -- | Run a LookAhead computation. The first argument is the error -- function. runLookAhead :: (forall b. String -> LookAhead b) -> LookAhead a -> Parser a -- | Throw an error message according to the supplied method. lookAheadError :: String -> LookAhead a -- | Get the current look-ahead position. getInput :: LookAhead AlexInput -- | Set the look-ahead position. setInput :: AlexInput -> LookAhead () -- | Lift a computation in the Parser monad to the LookAhead -- monad. liftP :: Parser a -> LookAhead a -- | Look at the next character. Fails if there are no more characters. nextChar :: LookAhead Char -- | Consume the next character. Does nextChar followed by -- sync. eatNextChar :: LookAhead Char -- | Consume all the characters up to the current look-ahead position. sync :: LookAhead () -- | Undo look-ahead. Restores the input from the ParseState. rollback :: LookAhead () -- | Do a case on the current input string. If any of the given strings -- match we move past it and execute the corresponding action. If no -- string matches, we execute a default action, advancing the input one -- character. This function only affects the look-ahead position. match :: [(String, LookAhead a)] -> LookAhead a -> LookAhead a -- | Same as match but takes the initial character from the first -- argument instead of reading it from the input. Consequently, in the -- default case the input is not advanced. match' :: Char -> [(String, LookAhead a)] -> LookAhead a -> LookAhead a instance GHC.Base.Monad Agda.Syntax.Parser.LookAhead.LookAhead instance GHC.Base.Applicative Agda.Syntax.Parser.LookAhead.LookAhead instance GHC.Base.Functor Agda.Syntax.Parser.LookAhead.LookAhead -- | The code to lex string and character literals. Basically the same code -- as in GHC. module Agda.Syntax.Parser.StringLiterals -- | Lex a string literal. Assumes that a double quote has been lexed. litString :: LexAction Token -- | Lex a character literal. Assumes that a single quote has been lexed. A -- character literal is lexed in exactly the same way as a string -- literal. Only before returning the token do we check that the lexed -- string is of length 1. This is maybe not the most efficient way of -- doing things, but on the other hand it will only be inefficient if -- there is a lexical error. litChar :: LexAction Token -- | This module defines the lex action to lex nested comments. As is -- well-known this cannot be done by regular expressions (which, -- incidently, is probably the reason why C-comments don't nest). -- -- When scanning nested comments we simply keep track of the nesting -- level, counting up for open comments and down for close -- comments. module Agda.Syntax.Parser.Comments -- | Should comment tokens be output? keepComments :: LexPredicate -- | Should comment tokens be output? keepCommentsM :: Parser Bool -- | Manually lexing a block comment. Assumes an open comment has -- been lexed. In the end the comment is discarded and lexToken is -- called to lex a real token. nestedComment :: LexAction Token -- | Lex a hole ({! ... !}). Holes can be nested. Returns -- TokSymbol SymQuestionMark. hole :: LexAction Token -- | Skip a block of text enclosed by the given open and close strings. -- Assumes the first open string has been consumed. Open-close pairs may -- be nested. skipBlock :: String -> String -> LookAhead () -- | This module contains the building blocks used to construct the lexer. module Agda.Syntax.Parser.LexActions -- | Scan the input to find the next token. Calls alexScanUser. This -- is the main lexing function where all the work happens. The function -- lexer, used by the parser is the continuation version of this -- function. lexToken :: Parser Token -- | The most general way of parsing a token. token :: (String -> Parser tok) -> LexAction tok -- | Parse a token from an Interval' and the lexed string. withInterval :: ((Interval, String) -> tok) -> LexAction tok -- | Like withInterval, but applies a function to the string. withInterval' :: (String -> a) -> ((Interval, a) -> tok) -> LexAction tok -- | Return a token without looking at the lexed string. withInterval_ :: (Interval -> r) -> LexAction r -- | Executed for layout keywords. Enters the layout state and -- performs the given action. withLayout :: Keyword -> LexAction r -> LexAction r -- | Prepend some parser manipulation to an action. andThen :: Parser () -> LexAction r -> LexAction r infixr 1 `andThen` -- | Throw away the current lexeme. skip :: LexAction Token -- | Enter a new state without consuming any input. begin :: LexState -> LexAction Token -- | Exit the current state without consuming any input. end :: LexAction Token -- | Enter a new state and perform the given action. beginWith :: LexState -> LexAction a -> LexAction a -- | Exit the current state and perform the given action. endWith :: LexAction a -> LexAction a -- | Enter a new state throwing away the current lexeme. begin_ :: LexState -> LexAction Token -- | Exit the current state throwing away the current lexeme. end_ :: LexAction Token -- | For lexical errors we want to report the current position as the site -- of the error, whereas for parse errors the previous position is the -- one we're interested in (since this will be the position of the token -- we just lexed). This function does parseErrorAt the current -- position. lexError :: String -> Parser a -- | Parse a Keyword token, triggers layout for -- layoutKeywords. keyword :: Keyword -> LexAction Token -- | Parse a Symbol token. symbol :: Symbol -> LexAction Token -- | Parse an identifier. Identifiers can be qualified (see Name). -- Example: Foo.Bar.f identifier :: LexAction Token literal :: Read a => (a -> Literal) -> LexAction Token -- | Parse a literal. literal' :: (String -> a) -> (a -> Literal) -> LexAction Token integer :: String -> Integer -- | True when the given character is the next character of the input -- string. followedBy :: Char -> LexPredicate -- | True if we are at the end of the file. eof :: LexPredicate -- | True if the given state appears somewhere on the state stack inState :: LexState -> LexPredicate -- | The lexer is generated by Alex (http://www.haskell.org/alex) -- and is an adaptation of GHC's lexer. The main lexing function -- lexer is called by the Agda.Syntax.Parser.Parser to get -- the next token from the input. module Agda.Syntax.Parser.Lexer -- | Return the next token. This is the function used by Happy in the -- parser. -- --
--   lexer k = lexToken >>= k
--   
lexer :: (Token -> Parser a) -> Parser a -- | This is the initial state for parsing a regular, non-literate file. normal :: LexState code :: Int -- | The layout state. Entered when we see a layout keyword -- (withLayout) and exited at the next token -- (newLayoutBlock). layout :: LexState -- | We enter this state from newLayoutBlock when the token -- following a layout keyword is to the left of (or at the same column -- as) the current layout context. Example: -- --
--   data Empty : Set where
--   foo : Empty -> Nat
--   
-- -- Here the second line is not part of the where clause since it -- is has the same indentation as the data definition. What we -- have to do is insert an empty layout block {} after the -- where. The only thing that can happen in this state is that -- emptyLayout is executed, generating the closing brace. The open -- brace is generated when entering by newLayoutBlock. empty_layout :: LexState -- | This state is entered at the beginning of each line. You can't lex -- anything in this state, and to exit you have to check the layout rule. -- Done with offsideRule. bol :: LexState -- | This state can only be entered by the parser. In this state you can -- only lex the keywords using, hiding, -- renaming and to. Moreover they are only keywords in -- this particular state. The lexer will never enter this state by -- itself, that has to be done in the parser. imp_dir :: LexState data AlexReturn a AlexEOF :: AlexReturn a AlexError :: !AlexInput -> AlexReturn a AlexSkip :: !AlexInput -> !Int -> AlexReturn a AlexToken :: !AlexInput -> !Int -> a -> AlexReturn a -- | This is the main lexing function generated by Alex. alexScanUser :: ([LexState], ParseFlags) -> AlexInput -> Int -> AlexReturn (LexAction Token) -- | This module contains the lex actions that handle the layout rules. The -- way it works is that the Parser monad keeps track of a stack of -- LayoutContexts specifying the indentation of the layout blocks -- in scope. For instance, consider the following incomplete (Haskell) -- program: -- --
--   f x = x'
--     where
--       x' = do y <- foo x; bar ...
--   
-- -- At the ... the layout context would be -- --
--   [Layout 12, Layout 4, Layout 0]
--   
-- -- The closest layout block is the one following do which is -- started by token y at column 12. The second closest block is -- the where clause started by the x' token which has -- indentation 4. Finally, there is a top-level layout block with -- indentation 0. -- -- In April 2021 we changed layout handling in the lexer to allow -- stacking of layout keywords on the same line, e.g.: -- --
--   private module M where
--      postulate A : Set
--                private
--                  B : Set
--   
-- -- The layout columns in the layout context (stack of layout blocks) can -- have LayoutStatus either Tentative or Confirmed. -- New layout columns following a layout keyword are tentative until we -- see a new line. E.g. -- -- -- -- In contrast, -- -- -- -- A new layout column has to be strictly above the last confirmed -- column only. E.g., when encountering postulate at column 2 -- after where, the confirmed column is still 0, so this is a -- valid start of the block following where. -- -- The column 8 of the private block never enters the -- Confirmed status but remains Tentative. Also, this block -- can never get more than the one declaration it has -- (module...), because when the module block closes -- due to a column < 2, it closes as well. One could say that -- tentative blocks buried under confirmed blocks are passive, the only -- wait for their closing. -- -- To implement the process of block confirmation (function -- confirmLayout), the lexer has to act on newline characters -- (except for those in a block comment). -- -- -- -- In order to implement confirmedLayoutComing we have a -- LayoutStatus flag in the parse state (field -- stateLayStatus). By default, for a new layout block, the -- status is Tentative (unless we saw a newline). -- -- New layout blocks are created as follows. When a layout keyword is -- encountered, we enter lexer state layout via function -- withLayout. When we exit the layout state via -- newLayoutBlock with a token that marks the new layout column, -- we push a new LayoutBlock onto the LayoutContext using -- the given column and the current parseLayStatus which is then -- reset to Tentative. -- -- The new block is actually only pushed if the column is above the last -- confirmed layout column (confirmedLayoutColumn). If this -- check fails, we instead enter the empty_layout state. This -- state produces the closing brace and is immediately left for -- bol (beginning of line). -- -- (Remark: In bol we might confirm some tentative top blocks, but -- this is irrelevant, since they will be closed immediately, given that -- the current token is left of the confirmed column, and tentative -- columns above it must be to the right of this column.) -- -- The offsideRule (state bol) is unchanged. It checks how -- the first token on a new line relates to the top layout column, be it -- tentative or confirmed. (Since we are on a new line, Tentative -- can only happen when we popped some Confirmed columns and -- continue popping the top Tentative columns here.) While the -- token is to the left of the layout column, we keep closing blocks. module Agda.Syntax.Parser.Layout -- | Executed for layout keywords. Enters the layout state and -- performs the given action. withLayout :: Keyword -> LexAction r -> LexAction r -- | Executed for the first token in each line (see bol), except -- when the last token was a layout keyword. -- -- Checks the position of the token relative to the current layout -- context. If the token is -- -- offsideRule :: LexAction Token -- | Start a new layout block. This is how to get out of the layout -- state. There are two possibilities: -- -- -- -- In the first case everything is fine and we enter a new layout block -- at the column of the current token. In the second case we have an -- empty layout block so we enter the empty_layout state. In both -- cases we return a virtual open brace without consuming any input. -- -- Entering a new state when we know we want to generate a virtual -- {} may seem a bit roundabout. The thing is that we can only -- generate one token at a time, so the way to generate two tokens is to -- generate the first one and then enter a state in which the only thing -- you can do is generate the second one. newLayoutBlock :: LexAction Token -- | This action is only executed from the empty_layout state. It -- will exit this state, enter the bol state, and return a virtual -- close brace (closing the empty layout block started by -- newLayoutBlock). emptyLayout :: LexAction Token -- | At a new line, we confirm either existing tentative layout columns, -- or, if the last token was a layout keyword, the expected new layout -- column. confirmLayout :: Parser () -- | The parser is generated by Happy -- (http://www.haskell.org/happy). - - Ideally, ranges should be -- as precise as possible, to get messages that - emphasize precisely the -- faulting term(s) upon error. - - However, interactive highlighting is -- only applied at the end of each - mutual block, keywords are only -- highlighted once (see - Decl). So if the ranges of two -- declarations - interleave, one must ensure that keyword ranges are not -- included in - the intersection. (Otherwise they are uncolored by the -- interactive - highlighting.) - module Agda.Syntax.Parser.Parser -- | Parse a module. moduleParser :: Parser Module moduleNameParser :: Parser QName -- | Parse an expression. Could be used in interactions. exprParser :: Parser Expr -- | Parse an expression followed by a where clause. Could be used in -- interactions. exprWhereParser :: Parser ExprWhere -- | Parse the token stream. Used by the TeX compiler. tokensParser :: Parser [Token] holeContentParser :: Parser HoleContent -- | Breaks up a string into substrings. Returns every maximal subsequence -- of zero or more characters distinct from .. -- --
--   splitOnDots ""         == [""]
--   splitOnDots "foo.bar"  == ["foo", "bar"]
--   splitOnDots ".foo.bar" == ["", "foo", "bar"]
--   splitOnDots "foo.bar." == ["foo", "bar", ""]
--   splitOnDots "foo..bar" == ["foo", "", "bar"]
--   
splitOnDots :: String -> [String] instance GHC.Base.Functor Agda.Syntax.Parser.Parser.LamBinds' instance GHC.Show.Show Agda.Syntax.Parser.Parser.RHSOrTypeSigs instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Parser.Attr instance Agda.Syntax.Position.SetRange Agda.Syntax.Parser.Parser.Attr module Agda.Syntax.Parser -- | Wrapped Parser type. data Parser a -- | Parse without top-level layout. parse :: Parser a -> String -> PM (a, CohesionAttributes) parsePosString :: Parser a -> Position -> String -> PM (a, CohesionAttributes) parseFile :: Show a => Parser a -> RangeFile -> String -> PM ((a, CohesionAttributes), FileType) -- | Parses a module. moduleParser :: Parser Module -- | Parses a module name. moduleNameParser :: Parser QName -- | Extensions supported by parseFile. acceptableFileExts :: [String] -- | Parses an expression. exprParser :: Parser Expr -- | Parses an expression followed by a where clause. exprWhereParser :: Parser ExprWhere -- | Parses an expression or some other content of an interaction hole. holeContentParser :: Parser HoleContent -- | Gives the parsed token stream (including comments). tokensParser :: Parser [Token] -- | Returns the contents of the given file. readFilePM :: RangeFile -> PM Text -- | Parse errors: what you get if parsing fails. data ParseError -- | Errors that arise at a specific position in the file ParseError :: !SrcFile -> !PositionWithoutFile -> String -> String -> String -> ParseError -- | The file in which the error occurred. [errSrcFile] :: ParseError -> !SrcFile -- | Where the error occurred. [errPos] :: ParseError -> !PositionWithoutFile -- | The remaining input. [errInput] :: ParseError -> String -- | The previous token. [errPrevToken] :: ParseError -> String -- | Hopefully an explanation of what happened. [errMsg] :: ParseError -> String -- | Parse errors that concern a range in a file. OverlappingTokensError :: !Range' SrcFile -> ParseError -- | The range of the bigger overlapping token [errRange] :: ParseError -> !Range' SrcFile -- | Parse errors that concern a whole file. InvalidExtensionError :: !RangeFile -> [String] -> ParseError -- | The file which the error concerns. [errPath] :: ParseError -> !RangeFile [errValidExts] :: ParseError -> [String] ReadFileError :: !RangeFile -> IOError -> ParseError -- | The file which the error concerns. [errPath] :: ParseError -> !RangeFile [errIOError] :: ParseError -> IOError -- | Warnings for parsing. data ParseWarning -- | Parse errors that concern a range in a file. OverlappingTokensWarning :: !Range' SrcFile -> ParseWarning -- | The range of the bigger overlapping token [warnRange] :: ParseWarning -> !Range' SrcFile -- | Unsupported attribute. UnsupportedAttribute :: Range -> !Maybe String -> ParseWarning -- | Multiple attributes. MultipleAttributes :: Range -> !Maybe String -> ParseWarning -- | A monad for handling parse errors and warnings. newtype PM a PM :: ExceptT ParseError (StateT [ParseWarning] IO) a -> PM a [unPM] :: PM a -> ExceptT ParseError (StateT [ParseWarning] IO) a -- | Run a PM computation, returning a list of warnings in -- first-to-last order and either a parse error or the parsed thing. runPMIO :: MonadIO m => PM a -> m (Either ParseError a, [ParseWarning]) instance Control.Monad.State.Class.MonadState [Agda.Syntax.Parser.Monad.ParseWarning] Agda.Syntax.Parser.PM instance Control.Monad.Error.Class.MonadError Agda.Syntax.Parser.Monad.ParseError Agda.Syntax.Parser.PM instance Control.Monad.IO.Class.MonadIO Agda.Syntax.Parser.PM instance GHC.Base.Monad Agda.Syntax.Parser.PM instance GHC.Base.Applicative Agda.Syntax.Parser.PM instance GHC.Base.Functor Agda.Syntax.Parser.PM module Agda.Syntax.Internal.Elim -- | Eliminations, subsuming applications and projections. data Elim' a -- | Application. Apply :: Arg a -> Elim' a -- | Projection. QName is name of a record projection. Proj :: ProjOrigin -> QName -> Elim' a -- | IApply x y r, x and y are the endpoints IApply :: a -> a -> a -> Elim' a -- | Drop Apply constructor. (Safe) isApplyElim :: Elim' a -> Maybe (Arg a) isApplyElim' :: Empty -> Elim' a -> Arg a -- | Only Apply variant. isProperApplyElim :: Elim' a -> Bool -- | Drop Apply constructors. (Safe) allApplyElims :: [Elim' a] -> Maybe [Arg a] -- | Split at first non-Apply splitApplyElims :: [Elim' a] -> ([Arg a], [Elim' a]) class IsProjElim e isProjElim :: IsProjElim e => e -> Maybe (ProjOrigin, QName) -- | Discards Proj f entries. argsFromElims :: [Elim' t] -> [Arg t] -- | Drop Proj constructors. (Safe) allProjElims :: [Elim' t] -> Maybe [(ProjOrigin, QName)] instance Data.Traversable.Traversable Agda.Syntax.Internal.Elim.Elim' instance Data.Foldable.Foldable Agda.Syntax.Internal.Elim.Elim' instance GHC.Base.Functor Agda.Syntax.Internal.Elim.Elim' instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Internal.Elim.IsProjElim (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Common.LensOrigin (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Utils.Pretty.Pretty tm => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Elim.Elim' tm) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Internal.Elim.Elim' a) module Agda.Syntax.Internal.Blockers -- | Even if we are not stuck on a meta during reduction we can fail to -- reduce a definition by pattern matching for another reason. data NotBlocked' t -- | The Elim is neutral and blocks a pattern match. StuckOn :: Elim' t -> NotBlocked' t -- | Not enough arguments were supplied to complete the matching. Underapplied :: NotBlocked' t -- | We matched an absurd clause, results in a neutral Def. AbsurdMatch :: NotBlocked' t -- | We ran out of clauses for QName, all considered clauses -- produced an actual mismatch. This can happen when try to reduce a -- function application but we are still missing some function clauses. -- See Agda.TypeChecking.Patterns.Match. MissingClauses :: QName -> NotBlocked' t -- | Reduction was not blocked, we reached a whnf which can be anything but -- a stuck Def. ReallyNotBlocked :: NotBlocked' t -- | What is causing the blocking? Or in other words which metas or -- problems need to be solved to unblock the blocked -- computation/constraint. data Blocker UnblockOnAll :: Set Blocker -> Blocker UnblockOnAny :: Set Blocker -> Blocker -- | Unblock if meta is instantiated UnblockOnMeta :: MetaId -> Blocker UnblockOnProblem :: ProblemId -> Blocker -- | Unblock when function is defined UnblockOnDef :: QName -> Blocker alwaysUnblock :: Blocker neverUnblock :: Blocker unblockOnAll :: Set Blocker -> Blocker unblockOnAny :: Set Blocker -> Blocker unblockOnEither :: Blocker -> Blocker -> Blocker unblockOnBoth :: Blocker -> Blocker -> Blocker unblockOnMeta :: MetaId -> Blocker unblockOnProblem :: ProblemId -> Blocker unblockOnDef :: QName -> Blocker unblockOnAllMetas :: Set MetaId -> Blocker unblockOnAnyMeta :: Set MetaId -> Blocker onBlockingMetasM :: Monad m => (MetaId -> m Blocker) -> Blocker -> m Blocker allBlockingMetas :: Blocker -> Set MetaId allBlockingProblems :: Blocker -> Set ProblemId allBlockingDefs :: Blocker -> Set QName -- | Something where a meta variable may block reduction. Notably a -- top-level meta is considered blocking. This did not use to be the case -- (pre Aug 2020). data Blocked' t a Blocked :: Blocker -> a -> Blocked' t a [theBlocker] :: Blocked' t a -> Blocker [ignoreBlocking] :: Blocked' t a -> a NotBlocked :: NotBlocked' t -> a -> Blocked' t a [blockingStatus] :: Blocked' t a -> NotBlocked' t [ignoreBlocking] :: Blocked' t a -> a -- | When trying to reduce f es, on match failed on one -- elimination e ∈ es that came with info r :: -- NotBlocked. stuckOn e r produces the new -- NotBlocked info. -- -- MissingClauses must be propagated, as this is blockage that can -- be lifted in the future (as more clauses are added). -- -- StuckOn e0 is also propagated, since it provides more -- precise information as StuckOn e (as e0 is the -- original reason why reduction got stuck and usually a subterm of -- e). An information like StuckOn (Apply (Arg info (Var i -- []))) (stuck on a variable) could be used by the lhs/coverage -- checker to trigger a split on that (pattern) variable. -- -- In the remaining cases for r, we are terminally stuck due to -- StuckOn e. Propagating AbsurdMatch does not -- seem useful. -- -- Underapplied must not be propagated, as this would mean that -- f es is underapplied, which is not the case (it is stuck). -- Note that Underapplied can only arise when projection patterns -- were missing to complete the original match (in e). (Missing -- ordinary pattern would mean the e is of function type, but we -- cannot match against something of function type.) stuckOn :: Elim' t -> NotBlocked' t -> NotBlocked' t blockedOn :: Blocker -> a -> Blocked' t a blocked :: MetaId -> a -> Blocked' t a notBlocked :: a -> Blocked' t a blocked_ :: MetaId -> Blocked' t () notBlocked_ :: Blocked' t () getBlocker :: Blocked' t a -> Blocker -- | Should a constraint wake up or not? If not, we might refine the -- unblocker. data WakeUp WakeUp :: WakeUp DontWakeUp :: Maybe Blocker -> WakeUp wakeUpWhen :: (constr -> Bool) -> (constr -> WakeUp) -> constr -> WakeUp wakeUpWhen_ :: (constr -> Bool) -> constr -> WakeUp wakeIfBlockedOnProblem :: ProblemId -> Blocker -> WakeUp wakeIfBlockedOnMeta :: MetaId -> Blocker -> WakeUp wakeIfBlockedOnDef :: QName -> Blocker -> WakeUp unblockMeta :: MetaId -> Blocker -> Blocker unblockProblem :: ProblemId -> Blocker -> Blocker unblockDef :: QName -> Blocker -> Blocker instance GHC.Generics.Generic (Agda.Syntax.Internal.Blockers.NotBlocked' t) instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Internal.Blockers.NotBlocked' t) instance GHC.Generics.Generic Agda.Syntax.Internal.Blockers.Blocker instance GHC.Classes.Ord Agda.Syntax.Internal.Blockers.Blocker instance GHC.Classes.Eq Agda.Syntax.Internal.Blockers.Blocker instance GHC.Show.Show Agda.Syntax.Internal.Blockers.Blocker instance GHC.Generics.Generic (Agda.Syntax.Internal.Blockers.Blocked' t a) instance Data.Traversable.Traversable (Agda.Syntax.Internal.Blockers.Blocked' t) instance Data.Foldable.Foldable (Agda.Syntax.Internal.Blockers.Blocked' t) instance GHC.Base.Functor (Agda.Syntax.Internal.Blockers.Blocked' t) instance (GHC.Show.Show a, GHC.Show.Show t) => GHC.Show.Show (Agda.Syntax.Internal.Blockers.Blocked' t a) instance GHC.Classes.Eq Agda.Syntax.Internal.Blockers.WakeUp instance GHC.Show.Show Agda.Syntax.Internal.Blockers.WakeUp instance Agda.Utils.Functor.Decoration (Agda.Syntax.Internal.Blockers.Blocked' t) instance GHC.Base.Applicative (Agda.Syntax.Internal.Blockers.Blocked' t) instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Agda.Syntax.Internal.Blockers.Blocked' t a) instance (GHC.Base.Semigroup a, GHC.Base.Monoid a) => GHC.Base.Monoid (Agda.Syntax.Internal.Blockers.Blocked' t a) instance (Control.DeepSeq.NFData t, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Agda.Syntax.Internal.Blockers.Blocked' t a) instance Control.DeepSeq.NFData Agda.Syntax.Internal.Blockers.Blocker instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Blockers.Blocker instance GHC.Base.Semigroup (Agda.Syntax.Internal.Blockers.NotBlocked' t) instance GHC.Base.Monoid (Agda.Syntax.Internal.Blockers.NotBlocked' t) instance Control.DeepSeq.NFData t => Control.DeepSeq.NFData (Agda.Syntax.Internal.Blockers.NotBlocked' t) module Agda.Syntax.Internal -- | The size of a term is roughly the number of nodes in its syntax tree. -- This number need not be precise for logical correctness of Agda, it is -- only used for reporting (and maybe decisions regarding performance). -- -- Not counting towards the term size are: -- -- class TermSize a termSize :: TermSize a => a -> Int tsize :: TermSize a => a -> Sum Int data Suggestion Suggestion :: a -> Suggestion -- | Suggest a name if available (i.e. name is not "_") class Suggest a suggestName :: Suggest a => a -> Maybe String -- | Constructing a singleton telescope. class SgTel a sgTel :: SgTel a => a -> Telescope -- | Drop the types from a telescope. class TelToArgs a telToArgs :: TelToArgs a => a -> [Arg ArgName] type ListTel = ListTel' ArgName -- | Telescope as list. type ListTel' a = [Dom (a, Type)] type DummyTermKind = String data IntervalView IZero :: IntervalView IOne :: IntervalView IMin :: Arg Term -> Arg Term -> IntervalView IMax :: Arg Term -> Arg Term -> IntervalView INeg :: Arg Term -> IntervalView OTerm :: Term -> IntervalView -- | View type as path type. data PathView PathType :: Sort -> QName -> Arg Term -> Arg Term -> Arg Term -> Arg Term -> PathView -- | Sort of this type. [pathSort] :: PathView -> Sort -- | Builtin PATH. [pathName] :: PathView -> QName -- | Hidden [pathLevel] :: PathView -> Arg Term -- | Hidden [pathType] :: PathView -> Arg Term -- | NotHidden [pathLhs] :: PathView -> Arg Term -- | NotHidden [pathRhs] :: PathView -> Arg Term -- | reduced OType :: Type -> PathView data EqualityTypeData EqualityTypeData :: Sort -> QName -> Args -> Arg Term -> Arg Term -> Arg Term -> EqualityTypeData -- | Sort of this type. [_eqtSort] :: EqualityTypeData -> Sort -- | Builtin EQUALITY. [_eqtName] :: EqualityTypeData -> QName -- | Hidden. Empty or Level. [_eqtParams] :: EqualityTypeData -> Args -- | Hidden. [_eqtType] :: EqualityTypeData -> Arg Term -- | NotHidden. [_eqtLhs] :: EqualityTypeData -> Arg Term -- | NotHidden. [_eqtRhs] :: EqualityTypeData -> Arg Term -- | View type as equality type. data EqualityView EqualityViewType :: EqualityTypeData -> EqualityView -- | reduced OtherType :: Type -> EqualityView -- | reduced IdiomType :: Type -> EqualityView type PatternSubstitution = Substitution' DeBruijnPattern type Substitution = Substitution' Term -- | Substitutions. data Substitution' a -- | Identity substitution. Γ ⊢ IdS : Γ IdS :: Substitution' a -- | Empty substitution, lifts from the empty context. First argument is -- IMPOSSIBLE. Apply this to closed terms you want to use -- in a non-empty context. Γ ⊢ EmptyS : () EmptyS :: Impossible -> Substitution' a -- | Substitution extension, `cons'. Γ ⊢ u : Aρ Γ ⊢ ρ : Δ -- ---------------------- Γ ⊢ u :# ρ : Δ, A (:#) :: a -> Substitution' a -> Substitution' a -- | Strengthening substitution. First argument is -- IMPOSSIBLE. In 'Strengthen err n ρ the number -- n must be non-negative. This substitution should only be -- applied to values t for which none of the variables -- 0 up to n - 1 are free in t[ρ], and in that -- case n is subtracted from all free de Bruijn indices in -- t[ρ]. Γ ⊢ ρ : Δ |Θ| = n --------------------------- Γ ⊢ -- Strengthen n ρ : Δ, Θ @ Strengthen :: Impossible -> !Int -> Substitution' a -> Substitution' a -- | Weakening substitution, lifts to an extended context. Γ ⊢ ρ : Δ -- ------------------- Γ, Ψ ⊢ Wk |Ψ| ρ : Δ Wk :: !Int -> Substitution' a -> Substitution' a -- | Lifting substitution. Use this to go under a binder. Lift 1 ρ == -- var 0 :# Wk 1 ρ. Γ ⊢ ρ : Δ ------------------------- Γ, Ψρ ⊢ -- Lift |Ψ| ρ : Δ, Ψ Lift :: !Int -> Substitution' a -> Substitution' a infixr 4 :# -- | Extract pattern variables in left-to-right order. A DotP is -- also treated as variable (see docu for Clause). class PatternVars a where { type PatternVarOut a; } patternVars :: PatternVars a => a -> [Arg (Either (PatternVarOut a) Term)] -- | The ConPatternInfo states whether the constructor belongs to -- a record type (True) or data type (False). In the -- former case, the PatOrigin of the conPInfo says -- whether the record pattern orginates from the expansion of an implicit -- pattern. The Type is the type of the whole record pattern. -- The scope used for the type is given by any outer scope plus the -- clause's telescope (clauseTel). data ConPatternInfo ConPatternInfo :: PatternInfo -> Bool -> Bool -> Maybe (Arg Type) -> Bool -> ConPatternInfo -- | Information on the origin of the pattern. [conPInfo] :: ConPatternInfo -> PatternInfo -- | False if data constructor. True if record -- constructor. [conPRecord] :: ConPatternInfo -> Bool -- | Should the match block on non-canonical terms or can it proceed to the -- catch-all clause? [conPFallThrough] :: ConPatternInfo -> Bool -- | The type of the whole constructor pattern. Should be present -- (Just) if constructor pattern is is generated ordinarily by -- type-checking. Could be absent (Nothing) if pattern comes -- from some plugin (like Agsy). Needed e.g. for with-clause stripping. [conPType] :: ConPatternInfo -> Maybe (Arg Type) -- | Lazy patterns are generated by the forcing translation in the unifier -- (unifyStep) and are dropped by the clause compiler (TODO: not -- yet) (compileClauses) when the variables they bind are unused. -- The GHC backend compiles lazy matches to lazy patterns in Haskell -- (TODO: not yet). [conPLazy] :: ConPatternInfo -> Bool type DeBruijnPattern = Pattern' DBPatVar -- | Type used when numbering pattern variables. data DBPatVar DBPatVar :: PatVarName -> !Int -> DBPatVar [dbPatVarName] :: DBPatVar -> PatVarName [dbPatVarIndex] :: DBPatVar -> !Int type Pattern = Pattern' PatVarName " The @PatVarName@ is a name suggestion." -- | Patterns are variables, constructors, or wildcards. QName is -- used in ConP rather than Name since a constructor -- might come from a particular namespace. This also meshes well with the -- fact that values (i.e. the arguments we are matching with) use -- QName. data Pattern' x -- |
--   x
--   
VarP :: PatternInfo -> x -> Pattern' x -- |
--   .t
--   
DotP :: PatternInfo -> Term -> Pattern' x -- | c ps The subpatterns do not contain any projection -- copatterns. ConP :: ConHead -> ConPatternInfo -> [NamedArg (Pattern' x)] -> Pattern' x -- | E.g. 5, "hello". LitP :: PatternInfo -> Literal -> Pattern' x -- | Projection copattern. Can only appear by itself. ProjP :: ProjOrigin -> QName -> Pattern' x -- | Path elimination pattern, like VarP but keeps track of -- endpoints. IApplyP :: PatternInfo -> Term -> Term -> x -> Pattern' x -- | Used for HITs, the QName should be the one from primHComp. DefP :: PatternInfo -> QName -> [NamedArg (Pattern' x)] -> Pattern' x -- | Origin of the pattern: what did the user write in this position? data PatOrigin -- | Pattern inserted by the system PatOSystem :: PatOrigin -- | Pattern generated by case split PatOSplit :: PatOrigin -- | User wrote a variable pattern PatOVar :: Name -> PatOrigin -- | User wrote a dot pattern PatODot :: PatOrigin -- | User wrote a wildcard pattern PatOWild :: PatOrigin -- | User wrote a constructor pattern PatOCon :: PatOrigin -- | User wrote a record pattern PatORec :: PatOrigin -- | User wrote a literal pattern PatOLit :: PatOrigin -- | User wrote an absurd pattern PatOAbsurd :: PatOrigin data PatternInfo PatternInfo :: PatOrigin -> [Name] -> PatternInfo [patOrigin] :: PatternInfo -> PatOrigin [patAsNames] :: PatternInfo -> [Name] -- | Pattern variables. type PatVarName = ArgName -- | A clause is a list of patterns and the clause body. -- -- The telescope contains the types of the pattern variables and the de -- Bruijn indices say how to get from the order the variables occur in -- the patterns to the order they occur in the telescope. The body binds -- the variables in the order they appear in the telescope. -- --
--   clauseTel ~ permute clausePerm (patternVars namedClausePats)
--   
-- -- Terms in dot patterns are valid in the clause telescope. -- -- For the purpose of the permutation and the body dot patterns count as -- variables. TODO: Change this! data Clause Clause :: Range -> Range -> Telescope -> NAPs -> Maybe Term -> Maybe (Arg Type) -> Bool -> Maybe Bool -> Maybe Bool -> Maybe Bool -> ExpandedEllipsis -> Maybe ModuleName -> Clause [clauseLHSRange] :: Clause -> Range [clauseFullRange] :: Clause -> Range -- | Δ: The types of the pattern variables in dependency order. [clauseTel] :: Clause -> Telescope -- | Δ ⊢ ps. The de Bruijn indices refer to Δ. [namedClausePats] :: Clause -> NAPs -- | Just v with Δ ⊢ v for a regular clause, or -- Nothing for an absurd one. [clauseBody] :: Clause -> Maybe Term -- | Δ ⊢ t. The type of the rhs under clauseTel. Used, -- e.g., by TermCheck. Can be Irrelevant if we -- encountered an irrelevant projection pattern on the lhs. [clauseType] :: Clause -> Maybe (Arg Type) -- | Clause has been labelled as CATCHALL. [clauseCatchall] :: Clause -> Bool -- | Pattern matching of this clause is exact, no catch-all case. Computed -- by the coverage checker. Nothing means coverage checker has -- not run yet (clause may be inexact). Just False means clause -- is not exact. Just True means clause is exact. [clauseExact] :: Clause -> Maybe Bool -- | clauseBody contains recursive calls; computed by termination -- checker. Nothing means that termination checker has not run -- yet, or that clauseBody contains meta-variables; these could -- be filled with recursive calls later! Just False means -- definitely no recursive call. Just True means definitely a -- recursive call. [clauseRecursive] :: Clause -> Maybe Bool -- | Clause has been labelled as unreachable by the coverage checker. -- Nothing means coverage checker has not run yet (clause may be -- unreachable). Just False means clause is not unreachable. -- Just True means clause is unreachable. [clauseUnreachable] :: Clause -> Maybe Bool -- | Was this clause created by expansion of an ellipsis? [clauseEllipsis] :: Clause -> ExpandedEllipsis -- | Keeps track of the module name associate with the clause's where -- clause. [clauseWhereModule] :: Clause -> Maybe ModuleName -- | Named pattern arguments. type NAPs = [NamedArg DeBruijnPattern] -- | 'Blocked a without the a. type Blocked_ = Blocked () type NotBlocked = NotBlocked' Term type Blocked = Blocked' Term -- | Newtypes for terms that produce a dummy, rather than crash, when -- applied to incompatible eliminations. newtype BraveTerm BraveTerm :: Term -> BraveTerm [unBrave] :: BraveTerm -> Term type LevelAtom = Term type PlusLevel = PlusLevel' Term data PlusLevel' t Plus :: !Integer -> t -> PlusLevel' t type Level = Level' Term -- | A level is a maximum expression of a closed level and 0..n -- PlusLevel expressions each of which is an atom plus a number. data Level' t Max :: !Integer -> [PlusLevel' t] -> Level' t type Sort = Sort' Term -- | Sorts. data Sort' t -- | Set ℓ. Type :: Level' t -> Sort' t -- | Prop ℓ. Prop :: Level' t -> Sort' t -- | Setωᵢ. Inf :: IsFibrant -> !Integer -> Sort' t -- | SSet ℓ. SSet :: Level' t -> Sort' t -- | SizeUniv, a sort inhabited by type Size. SizeUniv :: Sort' t -- | LockUniv, a sort for locks. LockUniv :: Sort' t -- | IntervalUniv, a sort inhabited by the cubical interval. IntervalUniv :: Sort' t -- | Sort of the pi type. PiSort :: Dom' t t -> Sort' t -> Abs (Sort' t) -> Sort' t -- | Sort of a (non-dependent) function type. FunSort :: Sort' t -> Sort' t -> Sort' t -- | Sort of another sort. UnivSort :: Sort' t -> Sort' t MetaS :: {-# UNPACK #-} !MetaId -> [Elim' t] -> Sort' t -- | A postulated sort. DefS :: QName -> [Elim' t] -> Sort' t -- | A (part of a) term or type which is only used for internal purposes. -- Replaces the abuse of Prop for a dummy sort. The -- String typically describes the location where we create this -- dummy, but can contain other information as well. DummyS :: String -> Sort' t data IsFibrant IsFibrant :: IsFibrant IsStrict :: IsFibrant type Telescope = Tele (Dom Type) -- | Sequence of types. An argument of the first type is bound in later -- types and so on. data Tele a EmptyTel :: Tele a -- | Abs is never NoAbs. ExtendTel :: a -> Abs (Tele a) -> Tele a class LensSort a lensSort :: LensSort a => Lens' Sort a getSort :: LensSort a => a -> Sort type Type = Type' Term type Type' a = Type'' Term a -- | Types are terms with a sort annotation. data Type'' t a El :: Sort' t -> a -> Type'' t a [_getSort] :: Type'' t a -> Sort' t [unEl] :: Type'' t a -> a -- | Binder. -- -- Abs: The bound variable might appear in the body. NoAbs -- is pseudo-binder, it does not introduce a fresh variable, similar to -- the const of Haskell. data Abs a -- | The body has (at least) one free variable. Danger: unAbs -- doesn't shift variables properly Abs :: ArgName -> a -> Abs a [absName] :: Abs a -> ArgName [unAbs] :: Abs a -> a NoAbs :: ArgName -> a -> Abs a [absName] :: Abs a -> ArgName [unAbs] :: Abs a -> a type Elims = [Elim] " eliminations ordered left-to-right." type Elim = Elim' Term type ConInfo = ConOrigin -- | Raw values. -- -- Def is used for both defined and undefined constants. Assume -- there is a type declaration and a definition for every constant, even -- if the definition is an empty list of clauses. data Term -- | x es neutral Var :: {-# UNPACK #-} !Int -> Elims -> Term -- | Terms are beta normal. Relevance is ignored Lam :: ArgInfo -> Abs Term -> Term Lit :: Literal -> Term -- | f es, possibly a delta/iota-redex Def :: QName -> Elims -> Term -- | c es or record { fs = es } es allows only -- Apply and IApply eliminations, and IApply only for data constructors. Con :: ConHead -> ConInfo -> Elims -> Term -- | dependent or non-dependent function space Pi :: Dom Type -> Abs Type -> Term Sort :: Sort -> Term Level :: Level -> Term MetaV :: {-# UNPACK #-} !MetaId -> Elims -> Term -- | Irrelevant stuff in relevant position, but created in an irrelevant -- context. Basically, an internal version of the irrelevance axiom -- .irrAx : .A -> A. DontCare :: Term -> Term -- | A (part of a) term or type which is only used for internal purposes. -- Replaces the Sort Prop hack. The String typically -- describes the location where we create this dummy, but can contain -- other information as well. The second field accumulates eliminations -- in case we apply a dummy term to more of them. Dummy terms should -- never be used in places where they can affect type checking, so -- syntactic checks are free to ignore the eliminators, which are only -- there to ease debugging when a dummy term incorrectly leaks into a -- relevant position. Dummy :: String -> Elims -> Term class LensConName a getConName :: LensConName a => a -> QName setConName :: LensConName a => QName -> a -> a mapConName :: LensConName a => (QName -> QName) -> a -> a -- | Store the names of the record fields in the constructor. This allows -- reduction of projection redexes outside of TCM. For instance, during -- substitution and application. data ConHead ConHead :: QName -> DataOrRecord -> Induction -> [Arg QName] -> ConHead -- | The name of the constructor. [conName] :: ConHead -> QName -- | Data or record constructor? [conDataRecord] :: ConHead -> DataOrRecord -- | Record constructors can be coinductive. [conInductive] :: ConHead -> Induction -- | The name of the record fields. Arg is stored since the info in -- the constructor args might not be accurate because of subtyping (issue -- #2170). [conFields] :: ConHead -> [Arg QName] data DataOrRecord IsData :: DataOrRecord IsRecord :: PatternOrCopattern -> DataOrRecord type NamedArgs = [NamedArg Term] -- | Type of argument lists. type Args = [Arg Term] type Dom = Dom' Term -- | Similar to Arg, but we need to distinguish an irrelevance -- annotation in a function domain (the domain itself is not irrelevant!) -- from an irrelevant argument. -- -- Dom is used in Pi of internal syntax, in -- Context and Telescope. Arg is used for actual -- arguments (Var, Con, Def etc.) and in -- Abstract syntax and other situations. -- -- data Dom' t e Dom :: ArgInfo -> Maybe NamedName -> Bool -> Maybe t -> e -> Dom' t e [domInfo] :: Dom' t e -> ArgInfo -- | e.g. x in {x = y : A} -> B. [domName] :: Dom' t e -> Maybe NamedName -- | Is this a Π-type (False), or a partial type (True)? [domIsFinite] :: Dom' t e -> Bool -- | "@tactic e". [domTactic] :: Dom' t e -> Maybe t [unDom] :: Dom' t e -> e -- | Constant level n pattern ClosedLevel :: Integer -> Level pattern EqualityType :: Sort -> QName -> Args -> Arg Term -> Arg Term -> Arg Term -> EqualityView eqtSort :: EqualityView -> Sort eqtName :: EqualityView -> QName eqtParams :: EqualityView -> Args eqtType :: EqualityView -> Arg Term eqtLhs :: EqualityView -> Arg Term eqtRhs :: EqualityView -> Arg Term argFromDom :: Dom' t a -> Arg a namedArgFromDom :: Dom' t a -> NamedArg a domFromArg :: Arg a -> Dom a domFromNamedArg :: NamedArg a -> Dom a defaultDom :: a -> Dom a defaultArgDom :: ArgInfo -> a -> Dom a defaultNamedArgDom :: ArgInfo -> String -> a -> Dom a clausePats :: Clause -> [Arg DeBruijnPattern] patVarNameToString :: PatVarName -> String nameToPatVarName :: Name -> PatVarName defaultPatternInfo :: PatternInfo varP :: a -> Pattern' a dotP :: Term -> Pattern' a litP :: Literal -> Pattern' a namedVarP :: PatVarName -> Named_ Pattern namedDBVarP :: Int -> PatVarName -> Named_ DeBruijnPattern -- | Make an absurd pattern with the given de Bruijn index. absurdP :: Int -> DeBruijnPattern noConPatternInfo :: ConPatternInfo -- | Build partial ConPatternInfo from ConInfo toConPatternInfo :: ConInfo -> ConPatternInfo -- | Build ConInfo from ConPatternInfo. fromConPatternInfo :: ConPatternInfo -> ConInfo -- | Retrieve the PatternInfo from a pattern patternInfo :: Pattern' x -> Maybe PatternInfo -- | Retrieve the origin of a pattern patternOrigin :: Pattern' x -> Maybe PatOrigin -- | Does the pattern perform a match that could fail? properlyMatching :: Pattern' a -> Bool properlyMatching' :: Bool -> Bool -> Pattern' a -> Bool isEqualityType :: EqualityView -> Bool isPathType :: PathView -> Bool isIOne :: IntervalView -> Bool -- | Absurd lambdas are internally represented as identity with variable -- name "()". absurdBody :: Abs Term isAbsurdBody :: Abs Term -> Bool absurdPatternName :: PatVarName isAbsurdPatternName :: PatVarName -> Bool -- | An unapplied variable. var :: Nat -> Term -- | Add DontCare is it is not already a DontCare. dontCare :: Term -> Term -- | Construct a string representing the call-site that created the dummy -- thing. dummyLocName :: CallStack -> String -- | Aux: A dummy term to constitute a dummy termlevelsort/type. dummyTermWith :: DummyTermKind -> CallStack -> Term -- | A dummy level to constitute a level/sort created at location. Note: -- use macro DUMMY_LEVEL ! dummyLevel :: CallStack -> Level -- | A dummy term created at location. Note: use macro DUMMY_TERM ! dummyTerm :: CallStack -> Term __DUMMY_TERM__ :: HasCallStack => Term __DUMMY_LEVEL__ :: HasCallStack => Level -- | A dummy sort created at location. Note: use macro DUMMY_SORT ! dummySort :: CallStack -> Sort __DUMMY_SORT__ :: HasCallStack => Sort -- | A dummy type created at location. Note: use macro DUMMY_TYPE ! dummyType :: CallStack -> Type __DUMMY_TYPE__ :: HasCallStack => Type -- | Context entries without a type have this dummy type. Note: use macro -- DUMMY_DOM ! dummyDom :: CallStack -> Dom Type __DUMMY_DOM__ :: HasCallStack => Dom Type atomicLevel :: t -> Level' t varSort :: Int -> Sort tmSort :: Term -> Sort tmSSort :: Term -> Sort -- | Given a constant m and level l, compute m + -- l levelPlus :: Integer -> Level -> Level levelSuc :: Level -> Level mkType :: Integer -> Sort mkProp :: Integer -> Sort mkSSet :: Integer -> Sort isSort :: Term -> Maybe Sort impossibleTerm :: CallStack -> Term -- | A traversal for the names in a telescope. mapAbsNamesM :: Applicative m => (ArgName -> m ArgName) -> Tele a -> m (Tele a) mapAbsNames :: (ArgName -> ArgName) -> Tele a -> Tele a replaceEmptyName :: ArgName -> Tele a -> Tele a telFromList' :: (a -> ArgName) -> ListTel' a -> Telescope -- | Convert a list telescope to a telescope. telFromList :: ListTel -> Telescope -- | Convert a telescope to its list form. telToList :: Tele (Dom t) -> [Dom (ArgName, t)] -- | Lens to edit a Telescope as a list. listTel :: Lens' ListTel Telescope -- | Removing a topmost DontCare constructor. stripDontCare :: Term -> Term -- | Doesn't do any reduction. arity :: Type -> Nat suggests :: [Suggestion] -> String -- | Convert top-level postfix projections into prefix projections. unSpine :: Term -> Term -- | Convert Proj projection eliminations according to their -- ProjOrigin into Def projection applications. unSpine' :: (ProjOrigin -> Bool) -> Term -> Term -- | A view distinguishing the neutrals Var, Def, and -- MetaV which can be projected. hasElims :: Term -> Maybe (Elims -> Term, Elims) pDom :: LensHiding a => a -> Doc -> Doc prettyPrecLevelSucs :: Int -> Integer -> (Int -> Doc) -> Doc -- | Meta-variable identifiers use the same structure as NameIds. data MetaId MetaId :: {-# UNPACK #-} !Word64 -> {-# UNPACK #-} !ModuleNameHash -> MetaId [metaId] :: MetaId -> {-# UNPACK #-} !Word64 [metaModule] :: MetaId -> {-# UNPACK #-} !ModuleNameHash -- | A "problem" consists of a set of constraints and the same constraint -- can be part of multiple problems. newtype ProblemId ProblemId :: Nat -> ProblemId instance Data.Traversable.Traversable (Agda.Syntax.Internal.Dom' t) instance Data.Foldable.Foldable (Agda.Syntax.Internal.Dom' t) instance GHC.Base.Functor (Agda.Syntax.Internal.Dom' t) instance (GHC.Show.Show t, GHC.Show.Show e) => GHC.Show.Show (Agda.Syntax.Internal.Dom' t e) instance GHC.Generics.Generic Agda.Syntax.Internal.DataOrRecord instance GHC.Classes.Eq Agda.Syntax.Internal.DataOrRecord instance GHC.Show.Show Agda.Syntax.Internal.DataOrRecord instance GHC.Generics.Generic Agda.Syntax.Internal.ConHead instance GHC.Show.Show Agda.Syntax.Internal.ConHead instance GHC.Generics.Generic (Agda.Syntax.Internal.Abs a) instance Data.Traversable.Traversable Agda.Syntax.Internal.Abs instance Data.Foldable.Foldable Agda.Syntax.Internal.Abs instance GHC.Base.Functor Agda.Syntax.Internal.Abs instance GHC.Generics.Generic (Agda.Syntax.Internal.Tele a) instance Data.Traversable.Traversable Agda.Syntax.Internal.Tele instance Data.Foldable.Foldable Agda.Syntax.Internal.Tele instance GHC.Base.Functor Agda.Syntax.Internal.Tele instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Internal.Tele a) instance GHC.Generics.Generic Agda.Syntax.Internal.IsFibrant instance GHC.Classes.Ord Agda.Syntax.Internal.IsFibrant instance GHC.Classes.Eq Agda.Syntax.Internal.IsFibrant instance GHC.Show.Show Agda.Syntax.Internal.IsFibrant instance Data.Traversable.Traversable Agda.Syntax.Internal.PlusLevel' instance Data.Foldable.Foldable Agda.Syntax.Internal.PlusLevel' instance GHC.Base.Functor Agda.Syntax.Internal.PlusLevel' instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Internal.PlusLevel' t) instance Data.Traversable.Traversable Agda.Syntax.Internal.Level' instance Data.Foldable.Foldable Agda.Syntax.Internal.Level' instance GHC.Base.Functor Agda.Syntax.Internal.Level' instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Internal.Level' t) instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Internal.Sort' t) instance Data.Traversable.Traversable (Agda.Syntax.Internal.Type'' t) instance Data.Foldable.Foldable (Agda.Syntax.Internal.Type'' t) instance GHC.Base.Functor (Agda.Syntax.Internal.Type'' t) instance (GHC.Show.Show t, GHC.Show.Show a) => GHC.Show.Show (Agda.Syntax.Internal.Type'' t a) instance GHC.Show.Show Agda.Syntax.Internal.Term instance GHC.Show.Show Agda.Syntax.Internal.BraveTerm instance GHC.Generics.Generic Agda.Syntax.Internal.PatOrigin instance GHC.Classes.Eq Agda.Syntax.Internal.PatOrigin instance GHC.Show.Show Agda.Syntax.Internal.PatOrigin instance GHC.Generics.Generic Agda.Syntax.Internal.PatternInfo instance GHC.Classes.Eq Agda.Syntax.Internal.PatternInfo instance GHC.Show.Show Agda.Syntax.Internal.PatternInfo instance GHC.Generics.Generic Agda.Syntax.Internal.DBPatVar instance GHC.Classes.Eq Agda.Syntax.Internal.DBPatVar instance GHC.Show.Show Agda.Syntax.Internal.DBPatVar instance GHC.Generics.Generic Agda.Syntax.Internal.ConPatternInfo instance GHC.Show.Show Agda.Syntax.Internal.ConPatternInfo instance GHC.Generics.Generic (Agda.Syntax.Internal.Pattern' x) instance Data.Traversable.Traversable Agda.Syntax.Internal.Pattern' instance Data.Foldable.Foldable Agda.Syntax.Internal.Pattern' instance GHC.Base.Functor Agda.Syntax.Internal.Pattern' instance GHC.Show.Show x => GHC.Show.Show (Agda.Syntax.Internal.Pattern' x) instance GHC.Generics.Generic Agda.Syntax.Internal.Clause instance GHC.Show.Show Agda.Syntax.Internal.Clause instance GHC.Generics.Generic (Agda.Syntax.Internal.Substitution' a) instance Data.Traversable.Traversable Agda.Syntax.Internal.Substitution' instance Data.Foldable.Foldable Agda.Syntax.Internal.Substitution' instance GHC.Base.Functor Agda.Syntax.Internal.Substitution' instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Internal.Substitution' a) instance GHC.Show.Show Agda.Syntax.Internal.IntervalView instance (Data.Foldable.Foldable t, Agda.Syntax.Internal.TermSize a) => Agda.Syntax.Internal.TermSize (t a) instance Agda.Syntax.Internal.TermSize Agda.Syntax.Internal.Term instance Agda.Syntax.Internal.TermSize Agda.Syntax.Internal.Sort instance Agda.Syntax.Internal.TermSize Agda.Syntax.Internal.Level instance Agda.Syntax.Internal.TermSize Agda.Syntax.Internal.PlusLevel instance Agda.Syntax.Internal.TermSize a => Agda.Syntax.Internal.TermSize (Agda.Syntax.Internal.Substitution' a) instance Agda.Syntax.Internal.Suggest GHC.Base.String instance Agda.Syntax.Internal.Suggest (Agda.Syntax.Internal.Abs b) instance Agda.Syntax.Internal.Suggest Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Internal.Suggest Agda.Syntax.Internal.Term instance Agda.Syntax.Internal.SgTel (Agda.Syntax.Common.ArgName, Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.Syntax.Internal.SgTel (Agda.Syntax.Internal.Dom (Agda.Syntax.Common.ArgName, Agda.Syntax.Internal.Type)) instance Agda.Syntax.Internal.SgTel (Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.Syntax.Internal.TelToArgs Agda.Syntax.Internal.ListTel instance Agda.Syntax.Internal.TelToArgs Agda.Syntax.Internal.Telescope instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Substitution instance Agda.Utils.Null.Null (Agda.Syntax.Internal.Substitution' a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Substitution' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Internal.Substitution' a) instance Agda.Syntax.Internal.PatternVars (Agda.Syntax.Common.Arg (Agda.Syntax.Internal.Pattern' a)) instance Agda.Syntax.Internal.PatternVars (Agda.Syntax.Common.NamedArg (Agda.Syntax.Internal.Pattern' a)) instance Agda.Syntax.Internal.PatternVars a => Agda.Syntax.Internal.PatternVars [a] instance Agda.Syntax.Position.HasRange Agda.Syntax.Internal.Clause instance Agda.Utils.Null.Null Agda.Syntax.Internal.Clause instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Clause instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Clause instance Control.DeepSeq.NFData Agda.Syntax.Internal.Clause instance Agda.Syntax.Abstract.Name.IsProjP (Agda.Syntax.Internal.Pattern' a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Pattern' a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Pattern' a) instance Control.DeepSeq.NFData x => Control.DeepSeq.NFData (Agda.Syntax.Internal.Pattern' x) instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.ConPatternInfo instance Control.DeepSeq.NFData Agda.Syntax.Internal.ConPatternInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.DBPatVar instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.DBPatVar instance Control.DeepSeq.NFData Agda.Syntax.Internal.DBPatVar instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.PatternInfo instance Control.DeepSeq.NFData Agda.Syntax.Internal.PatternInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.PatOrigin instance Control.DeepSeq.NFData Agda.Syntax.Internal.PatOrigin instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Blocked a) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Blocked a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.PlusLevel instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.PlusLevel instance Control.DeepSeq.NFData Agda.Syntax.Internal.PlusLevel instance Agda.Syntax.Internal.LensSort Agda.Syntax.Internal.Sort instance Agda.Syntax.Internal.LensSort (Agda.Syntax.Internal.Type' a) instance Agda.Syntax.Internal.LensSort a => Agda.Syntax.Internal.LensSort (Agda.Syntax.Internal.Dom a) instance Agda.Syntax.Internal.LensSort a => Agda.Syntax.Internal.LensSort (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Term instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Level instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Type' a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Sort instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Term instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Tele (Agda.Syntax.Internal.Dom a)) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Level instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Sort instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Type instance Control.DeepSeq.NFData Agda.Syntax.Internal.Term instance Control.DeepSeq.NFData Agda.Syntax.Internal.Type instance Control.DeepSeq.NFData Agda.Syntax.Internal.Sort instance Control.DeepSeq.NFData Agda.Syntax.Internal.Level instance Control.DeepSeq.NFData e => Control.DeepSeq.NFData (Agda.Syntax.Internal.Dom e) instance Agda.Utils.Functor.Decoration (Agda.Syntax.Internal.Type'' t) instance Control.DeepSeq.NFData Agda.Syntax.Internal.IsFibrant instance Agda.Utils.Null.Null (Agda.Syntax.Internal.Tele a) instance Agda.Utils.Size.Sized (Agda.Syntax.Internal.Tele a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Tele a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Internal.Tele a) instance Agda.Utils.Functor.Decoration Agda.Syntax.Internal.Abs instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Internal.Abs a) instance Agda.Utils.Size.Sized a => Agda.Utils.Size.Sized (Agda.Syntax.Internal.Abs a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Abs a) instance Agda.Utils.Pretty.Pretty t => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Abs t) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Internal.Abs a) instance Agda.Syntax.Position.SetRange Agda.Syntax.Internal.ConHead instance Agda.Syntax.Internal.LensConName Agda.Syntax.Internal.ConHead instance GHC.Classes.Eq Agda.Syntax.Internal.ConHead instance GHC.Classes.Ord Agda.Syntax.Internal.ConHead instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.ConHead instance Agda.Syntax.Position.HasRange Agda.Syntax.Internal.ConHead instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.ConHead instance Control.DeepSeq.NFData Agda.Syntax.Internal.ConHead instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.DataOrRecord instance Control.DeepSeq.NFData Agda.Syntax.Internal.DataOrRecord instance Agda.Utils.Functor.Decoration (Agda.Syntax.Internal.Dom' t) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Internal.Dom' t a) instance (Agda.Syntax.Position.KillRange t, Agda.Syntax.Position.KillRange a) => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Dom' t a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Internal.Dom' t a) instance Agda.Syntax.Common.LensNamed (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensArgInfo (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensHiding (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensModality (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensOrigin (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensFreeVariables (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensAnnotation (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensRelevance (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensQuantity (Agda.Syntax.Internal.Dom' t e) instance Agda.Syntax.Common.LensCohesion (Agda.Syntax.Internal.Dom' t e) instance (Agda.Utils.Pretty.Pretty t, Agda.Utils.Pretty.Pretty e) => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Dom' t e) module Agda.TypeChecking.Substitute.DeBruijn -- | Things we can substitute for a variable. Needs to be able to represent -- variables, e.g. for substituting under binders. class DeBruijn a -- | Produce a variable without name suggestion. deBruijnVar :: DeBruijn a => Int -> a -- | Produce a variable with name suggestion. debruijnNamedVar :: DeBruijn a => String -> Int -> a -- | Are we dealing with a variable? If yes, what is its index? deBruijnView :: DeBruijn a => a -> Maybe Int instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Internal.Term instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Internal.Level instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Internal.DBPatVar instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn a => Agda.TypeChecking.Substitute.DeBruijn.DeBruijn (Agda.Syntax.Common.Named_ a) -- | Precompute free variables in a term (and store in ArgInfo). module Agda.TypeChecking.Free.Precompute class PrecomputeFreeVars a precomputeFreeVars :: PrecomputeFreeVars a => a -> FV a precomputedFreeVars :: PrecomputeFreeVars a => a -> IntSet precomputeFreeVars_ :: PrecomputeFreeVars a => a -> a instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars Agda.Syntax.Internal.Term instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars Agda.Syntax.Internal.Level instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars Agda.Syntax.Internal.Type instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars [a] instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (GHC.Maybe.Maybe a) instance (Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a, Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars b) => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (a, b) -- | Computing the free variables of a term lazily. -- -- We implement a reduce (traversal into monoid) over internal syntax for -- a generic collection (monoid with singletons). This should allow a -- more efficient test for the presence of a particular variable. -- -- Worst-case complexity does not change (i.e. the case when a variable -- does not occur), but best case-complexity does matter. For instance, -- see mkAbs: each time we construct a dependent function type, we -- check whether it is actually dependent. -- -- The distinction between rigid and strongly rigid occurrences comes -- from: Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP -- 2009 paper) -- -- The main idea is that x = t(x) is unsolvable if x occurs strongly -- rigidly in t. It might have a solution if the occurrence is not -- strongly rigid, e.g. -- -- x = f -> suc (f (x ( y -> k))) has x = f -> suc (f (suc k)) -- -- -- -- Under coinductive constructors, occurrences are never strongly rigid. -- Also, function types and lambdas do not establish strong rigidity. -- Only inductive constructors do so. (See issue 1271). -- -- For further reading on semirings and semimodules for variable -- occurrence, see e.g. Conor McBrides "I got plenty of nuttin'" -- (Wadlerfest 2016). There, he treats the "quantity" dimension of -- variable occurrences. -- -- The semiring has an additive operation for combining occurrences of -- subterms, and a multiplicative operation of representing function -- composition. E.g. if variable x appears o in term -- u, but u appears in context q in term -- t then occurrence of variable x coming from -- u is accounted for as q o in t. -- -- Consider example (λ{ x → (x,x)}) y: -- -- -- -- If , is a record constructor, then we stay unguarded. -- -- -- -- It is not a given that the context can be described in the same way as -- the variable occurrence. However, for quantity it is the case and we -- obtain a semiring of occurrences with 0, 1, and even ω, which is an -- absorptive element for addition. module Agda.TypeChecking.Free.Lazy -- | A set of meta variables. Forms a monoid under union. newtype MetaSet MetaSet :: HashSet MetaId -> MetaSet [theMetaSet] :: MetaSet -> HashSet MetaId insertMetaSet :: MetaId -> MetaSet -> MetaSet foldrMetaSet :: (MetaId -> a -> a) -> a -> MetaSet -> a metaSetToBlocker :: MetaSet -> Blocker -- | Depending on the surrounding context of a variable, it's occurrence -- can be classified as flexible or rigid, with finer distinctions. -- -- The constructors are listed in increasing order (wrt. information -- content). data FlexRig' a -- | In arguments of metas. The set of metas is used by -- 'NonLinMatch' to generate the right blocking information. The -- semantics is that the status of a variable occurrence may change if -- one of the metas in the set gets solved. We may say the occurrence is -- tainted by the meta variables in the set. Flexible :: a -> FlexRig' a -- | In arguments to variables and definitions. WeaklyRigid :: FlexRig' a -- | In top position, or only under inductive record constructors (unit). Unguarded :: FlexRig' a -- | Under at least one and only inductive constructors. StronglyRigid :: FlexRig' a type FlexRig = FlexRig' MetaSet class LensFlexRig a o | o -> a lensFlexRig :: LensFlexRig a o => Lens' (FlexRig' a) o isFlexible :: LensFlexRig a o => o -> Bool isUnguarded :: LensFlexRig a o => o -> Bool isWeaklyRigid :: LensFlexRig a o => o -> Bool isStronglyRigid :: LensFlexRig a o => o -> Bool -- | FlexRig aggregation (additive operation of the semiring). For -- combining occurrences of the same variable in subterms. This is a -- refinement of the max operation for FlexRig which would -- work if Flexible did not have the MetaSet as an -- argument. Now, to aggregate two Flexible occurrences, we union -- the involved MetaSets. addFlexRig :: Semigroup a => FlexRig' a -> FlexRig' a -> FlexRig' a -- | Unit for addFlexRig. zeroFlexRig :: Monoid a => FlexRig' a -- | Absorptive for addFlexRig. omegaFlexRig :: FlexRig' a -- | FlexRig composition (multiplicative operation of the semiring). -- For accumulating the context of a variable. -- -- Flexible is dominant. Once we are under a meta, we are flexible -- regardless what else comes. We taint all variable occurrences under a -- meta by this meta. -- -- WeaklyRigid is next in strength. Destroys strong rigidity. -- -- StronglyRigid is still dominant over Unguarded. -- -- Unguarded is the unit. It is the top (identity) context. composeFlexRig :: Semigroup a => FlexRig' a -> FlexRig' a -> FlexRig' a -- | Unit for composeFlexRig. oneFlexRig :: FlexRig' a -- | Occurrence of free variables is classified by several dimensions. -- Currently, we have FlexRig and Modality. data VarOcc' a VarOcc :: FlexRig' a -> Modality -> VarOcc' a [varFlexRig] :: VarOcc' a -> FlexRig' a [varModality] :: VarOcc' a -> Modality type VarOcc = VarOcc' MetaSet -- | The absorptive element of variable occurrence under aggregation: -- strongly rigid, relevant. topVarOcc :: VarOcc' a -- | First argument is the outer occurrence (context) and second is the -- inner. This multiplicative operation is to modify an occurrence under -- a context. composeVarOcc :: Semigroup a => VarOcc' a -> VarOcc' a -> VarOcc' a oneVarOcc :: VarOcc' a -- | Any representation c of a set of variables need to be able to -- be modified by a variable occurrence. This is to ensure that free -- variable analysis is compositional. For instance, it should be -- possible to compute `fv (v [u/x])` from `fv v` and `fv u`. -- -- In algebraic terminology, a variable set a needs to be -- (almost) a left semimodule to the semiring VarOcc'. class (Singleton MetaId a, Semigroup a, Monoid a, Semigroup c, Monoid c) => IsVarSet a c | c -> a -- | Laws * Respects monoid operations: ``` withVarOcc o mempty == mempty -- withVarOcc o (x <> y) == withVarOcc o x <> withVarOcc o y -- ``` * Respects VarOcc composition: ``` withVarOcc oneVarOcc = id -- withVarOcc (composeVarOcc o1 o2) = withVarOcc o1 . withVarOcc o2 ``` * -- Respects VarOcc aggregation: ``` withVarOcc (o1 <> o2) x = -- withVarOcc o1 x <> withVarOcc o2 x ``` Since the corresponding -- unit law may fail, ``` withVarOcc mempty x = mempty ``` it is not -- quite a semimodule. withVarOcc :: IsVarSet a c => VarOcc' a -> c -> c -- | Representation of a variable set as map from de Bruijn indices to -- VarOcc'. type TheVarMap' a = IntMap (VarOcc' a) newtype VarMap' a VarMap :: TheVarMap' a -> VarMap' a [theVarMap] :: VarMap' a -> TheVarMap' a type TheVarMap = TheVarMap' MetaSet type VarMap = VarMap' MetaSet mapVarMap :: (TheVarMap' a -> TheVarMap' b) -> VarMap' a -> VarMap' b lookupVarMap :: Variable -> VarMap' a -> Maybe (VarOcc' a) -- | Keep track of FlexRig for every variable, but forget the -- involved meta vars. type TheFlexRigMap = IntMap (FlexRig' ()) newtype FlexRigMap FlexRigMap :: TheFlexRigMap -> FlexRigMap [theFlexRigMap] :: FlexRigMap -> TheFlexRigMap mapFlexRigMap :: (TheFlexRigMap -> TheFlexRigMap) -> FlexRigMap -> FlexRigMap -- | Where should we skip sorts in free variable analysis? data IgnoreSorts -- | Do not skip. IgnoreNot :: IgnoreSorts -- | Skip when annotation to a type. IgnoreInAnnotations :: IgnoreSorts -- | Skip unconditionally. IgnoreAll :: IgnoreSorts -- | The current context. data FreeEnv' a b c FreeEnv :: !b -> !FlexRig' a -> !Modality -> (Maybe Variable -> c) -> FreeEnv' a b c -- | Additional context, e.g., whether to ignore free variables in sorts. [feExtra] :: FreeEnv' a b c -> !b -- | Are we flexible or rigid? [feFlexRig] :: FreeEnv' a b c -> !FlexRig' a -- | What is the current relevance and quantity? [feModality] :: FreeEnv' a b c -> !Modality -- | Method to return a single variable. [feSingleton] :: FreeEnv' a b c -> Maybe Variable -> c type Variable = Int type SingleVar c = Variable -> c type FreeEnv c = FreeEnv' MetaSet IgnoreSorts c -- | Ignore free variables in sorts. feIgnoreSorts :: FreeEnv' a IgnoreSorts c -> IgnoreSorts -- | The initial context. initFreeEnv :: Monoid c => b -> SingleVar c -> FreeEnv' a b c type FreeT a b m c = ReaderT (FreeEnv' a b c) m c type FreeM a c = Reader (FreeEnv' a IgnoreSorts c) c -- | Run function for FreeM. runFreeM :: IsVarSet a c => SingleVar c -> IgnoreSorts -> FreeM a c -> c -- | Base case: a variable. variable :: (Monad m, IsVarSet a c) => Int -> FreeT a b m c -- | Subtract, but return Nothing if result is negative. subVar :: Int -> Maybe Variable -> Maybe Variable -- | Going under a binder. underBinder :: MonadReader (FreeEnv' a b c) m => m z -> m z -- | Going under n binders. underBinder' :: MonadReader (FreeEnv' a b c) m => Nat -> m z -> m z -- | Changing the Modality. underModality :: (MonadReader r m, LensModality r, LensModality o) => o -> m z -> m z -- | Changing the Relevance. underRelevance :: (MonadReader r m, LensRelevance r, LensRelevance o) => o -> m z -> m z -- | Changing the FlexRig context. underFlexRig :: (MonadReader r m, LensFlexRig a r, Semigroup a, LensFlexRig a o) => o -> m z -> m z -- | What happens to the variables occurring under a constructor? underConstructor :: (MonadReader r m, LensFlexRig a r, Semigroup a) => ConHead -> Elims -> m z -> m z -- | Gather free variables in a collection. class Free t freeVars' :: (Free t, IsVarSet a c) => t -> FreeM a c freeVars' :: (Free t, t ~ f b, Foldable f, Free b) => IsVarSet a c => t -> FreeM a c instance GHC.Base.Monoid Agda.TypeChecking.Free.Lazy.MetaSet instance GHC.Base.Semigroup Agda.TypeChecking.Free.Lazy.MetaSet instance Agda.Utils.Null.Null Agda.TypeChecking.Free.Lazy.MetaSet instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.MetaSet instance GHC.Classes.Eq Agda.TypeChecking.Free.Lazy.MetaSet instance Data.Foldable.Foldable Agda.TypeChecking.Free.Lazy.FlexRig' instance GHC.Base.Functor Agda.TypeChecking.Free.Lazy.FlexRig' instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Free.Lazy.FlexRig' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Free.Lazy.FlexRig' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Free.Lazy.VarMap' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Free.Lazy.VarMap' a) instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.IgnoreSorts instance GHC.Classes.Eq Agda.TypeChecking.Free.Lazy.IgnoreSorts instance Agda.Utils.Singleton.Singleton (Agda.TypeChecking.Free.Lazy.Variable, Agda.TypeChecking.Free.Lazy.FlexRig' ()) Agda.TypeChecking.Free.Lazy.FlexRigMap instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.FlexRigMap instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.Term instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Type' t) instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.Level instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.PlusLevel' t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free [t] instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Common.WithHiding t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Common.Named nm t) instance (Agda.TypeChecking.Free.Lazy.Free t, Agda.TypeChecking.Free.Lazy.Free u) => Agda.TypeChecking.Free.Lazy.Free (t, u) instance (Agda.TypeChecking.Free.Lazy.Free t, Agda.TypeChecking.Free.Lazy.Free u, Agda.TypeChecking.Free.Lazy.Free v) => Agda.TypeChecking.Free.Lazy.Free (t, u, v) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Elim.Elim' t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Dom t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Abs t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Tele t) instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.EqualityView instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.Monad m, GHC.Base.Semigroup c, GHC.Base.Monoid c) => GHC.Base.Monoid (Agda.TypeChecking.Free.Lazy.FreeT a b m c) instance GHC.Base.Semigroup Agda.TypeChecking.Free.Lazy.FlexRigMap instance GHC.Base.Monoid Agda.TypeChecking.Free.Lazy.FlexRigMap instance Agda.TypeChecking.Free.Lazy.IsVarSet () Agda.TypeChecking.Free.Lazy.FlexRigMap instance Agda.TypeChecking.Free.Lazy.LensFlexRig a (Agda.TypeChecking.Free.Lazy.FreeEnv' a b c) instance Agda.Syntax.Common.LensModality (Agda.TypeChecking.Free.Lazy.FreeEnv' a b c) instance Agda.Syntax.Common.LensRelevance (Agda.TypeChecking.Free.Lazy.FreeEnv' a b c) instance Agda.Syntax.Common.LensQuantity (Agda.TypeChecking.Free.Lazy.FreeEnv' a b c) instance Agda.Utils.Singleton.Singleton Agda.TypeChecking.Free.Lazy.Variable (Agda.TypeChecking.Free.Lazy.VarMap' a) instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Agda.TypeChecking.Free.Lazy.VarMap' a) instance GHC.Base.Semigroup a => GHC.Base.Monoid (Agda.TypeChecking.Free.Lazy.VarMap' a) instance (Agda.Utils.Singleton.Singleton Agda.Syntax.Common.MetaId a, GHC.Base.Semigroup a, GHC.Base.Monoid a) => Agda.TypeChecking.Free.Lazy.IsVarSet a (Agda.TypeChecking.Free.Lazy.VarMap' a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance Agda.Syntax.Common.LensModality (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance Agda.Syntax.Common.LensRelevance (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance Agda.Syntax.Common.LensQuantity (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance Agda.TypeChecking.Free.Lazy.LensFlexRig a (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance (GHC.Base.Semigroup a, GHC.Base.Monoid a) => GHC.Base.Monoid (Agda.TypeChecking.Free.Lazy.VarOcc' a) instance Agda.TypeChecking.Free.Lazy.LensFlexRig a (Agda.TypeChecking.Free.Lazy.FlexRig' a) instance Agda.Utils.Singleton.Singleton Agda.Syntax.Common.MetaId Agda.TypeChecking.Free.Lazy.MetaSet instance Agda.Utils.Singleton.Singleton Agda.Syntax.Common.MetaId () -- | Computing the free variables of a term. -- -- The distinction between rigid and strongly rigid occurrences comes -- from: Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP -- 2009 paper) -- -- The main idea is that x = t(x) is unsolvable if x occurs strongly -- rigidly in t. It might have a solution if the occurrence is not -- strongly rigid, e.g. -- -- x = f -> suc (f (x ( y -> k))) has x = f -> suc (f (suc k)) -- -- -- -- Under coinductive constructors, occurrences are never strongly rigid. -- Also, function types and lambdas do not establish strong rigidity. -- Only inductive constructors do so. (See issue 1271). -- -- If you need the occurrence information for all free variables, you can -- use freeVars which has amoungst others this instance -- freeVars :: Term -> VarMap From VarMap, specific -- information can be extracted, e.g., relevantVars :: VarMap -> -- VarSet relevantVars = filterVarMap isRelevant -- -- To just check the status of a single free variable, there are more -- efficient methods, e.g., freeIn :: Nat -> Term -> Bool -- -- -- Tailored optimized variable checks can be implemented as semimodules -- to VarOcc', see, for example, VarCounts or -- SingleFlexRig. module Agda.TypeChecking.Free newtype VarCounts VarCounts :: IntMap Int -> VarCounts [varCounts] :: VarCounts -> IntMap Int -- | Gather free variables in a collection. class Free t -- | Any representation c of a set of variables need to be able to -- be modified by a variable occurrence. This is to ensure that free -- variable analysis is compositional. For instance, it should be -- possible to compute `fv (v [u/x])` from `fv v` and `fv u`. -- -- In algebraic terminology, a variable set a needs to be -- (almost) a left semimodule to the semiring VarOcc'. class (Singleton MetaId a, Semigroup a, Monoid a, Semigroup c, Monoid c) => IsVarSet a c | c -> a -- | Laws * Respects monoid operations: ``` withVarOcc o mempty == mempty -- withVarOcc o (x <> y) == withVarOcc o x <> withVarOcc o y -- ``` * Respects VarOcc composition: ``` withVarOcc oneVarOcc = id -- withVarOcc (composeVarOcc o1 o2) = withVarOcc o1 . withVarOcc o2 ``` * -- Respects VarOcc aggregation: ``` withVarOcc (o1 <> o2) x = -- withVarOcc o1 x <> withVarOcc o2 x ``` Since the corresponding -- unit law may fail, ``` withVarOcc mempty x = mempty ``` it is not -- quite a semimodule. withVarOcc :: IsVarSet a c => VarOcc' a -> c -> c -- | Where should we skip sorts in free variable analysis? data IgnoreSorts -- | Do not skip. IgnoreNot :: IgnoreSorts -- | Skip when annotation to a type. IgnoreInAnnotations :: IgnoreSorts -- | Skip unconditionally. IgnoreAll :: IgnoreSorts -- | Collect all free variables together with information about their -- occurrence. -- -- Doesn't go inside solved metas, but collects the variables from a -- metavariable application X ts as flexibleVars. freeVars :: (IsVarSet a c, Singleton Variable c, Free t) => t -> c freeVars' :: (Free t, IsVarSet a c) => t -> FreeM a c filterVarMap :: (VarOcc -> Bool) -> VarMap -> VarSet filterVarMapToList :: (VarOcc -> Bool) -> VarMap -> [Variable] -- | Compute free variables. runFree :: (IsVarSet a c, Free t) => SingleVar c -> IgnoreSorts -> t -> c -- | Rigid variables: either strongly rigid, unguarded, or weakly rigid. rigidVars :: VarMap -> VarSet -- | Variables under only and at least one inductive constructor(s). stronglyRigidVars :: VarMap -> VarSet -- | Variables at top or only under inductive record constructors λs and -- Πs. The purpose of recording these separately is that they can still -- become strongly rigid if put under a constructor whereas weakly rigid -- ones stay weakly rigid. unguardedVars :: VarMap -> VarSet allVars :: VarMap -> VarSet -- | Variables occuring in arguments of metas. These are only potentially -- free, depending how the meta variable is instantiated. The set -- contains the id's of the meta variables that this variable is an -- argument to. flexibleVars :: VarMap -> IntMap MetaSet -- | Collect all free variables. allFreeVars :: Free t => t -> VarSet -- | Collect all relevant free variables, excluding the "unused" ones. allRelevantVars :: Free t => t -> VarSet -- | Collect all relevant free variables, possibly ignoring sorts. allRelevantVarsIgnoring :: Free t => IgnoreSorts -> t -> VarSet freeVarsIgnore :: (IsVarSet a c, Singleton Variable c, Free t) => IgnoreSorts -> t -> c freeIn :: Free a => Nat -> a -> Bool freeInIgnoringSorts :: Free a => Nat -> a -> Bool -- | Is the variable bound by the abstraction actually used? isBinderUsed :: Free a => Abs a -> Bool relevantIn :: Free t => Nat -> t -> Bool relevantInIgnoringSortAnn :: Free t => Nat -> t -> Bool -- | Depending on the surrounding context of a variable, it's occurrence -- can be classified as flexible or rigid, with finer distinctions. -- -- The constructors are listed in increasing order (wrt. information -- content). data FlexRig' a -- | In arguments of metas. The set of metas is used by -- 'NonLinMatch' to generate the right blocking information. The -- semantics is that the status of a variable occurrence may change if -- one of the metas in the set gets solved. We may say the occurrence is -- tainted by the meta variables in the set. Flexible :: a -> FlexRig' a -- | In arguments to variables and definitions. WeaklyRigid :: FlexRig' a -- | In top position, or only under inductive record constructors (unit). Unguarded :: FlexRig' a -- | Under at least one and only inductive constructors. StronglyRigid :: FlexRig' a type FlexRig = FlexRig' MetaSet class LensFlexRig a o | o -> a lensFlexRig :: LensFlexRig a o => Lens' (FlexRig' a) o isFlexible :: LensFlexRig a o => o -> Bool isUnguarded :: LensFlexRig a o => o -> Bool isStronglyRigid :: LensFlexRig a o => o -> Bool isWeaklyRigid :: LensFlexRig a o => o -> Bool -- | Occurrence of free variables is classified by several dimensions. -- Currently, we have FlexRig and Modality. data VarOcc' a VarOcc :: FlexRig' a -> Modality -> VarOcc' a [varFlexRig] :: VarOcc' a -> FlexRig' a [varModality] :: VarOcc' a -> Modality type VarOcc = VarOcc' MetaSet -- | Get the full occurrence information of a free variable. varOccurrenceIn :: Free a => Nat -> a -> Maybe VarOcc -- | Get the full occurrence information of a free variable. flexRigOccurrenceIn :: Free a => Nat -> a -> Maybe FlexRig -- | Is the term entirely closed (no free variables)? closed :: Free t => t -> Bool -- | A set of meta variables. Forms a monoid under union. data MetaSet insertMetaSet :: MetaId -> MetaSet -> MetaSet foldrMetaSet :: (MetaId -> a -> a) -> a -> MetaSet -> a metaSetToBlocker :: MetaSet -> Blocker instance GHC.Base.Monoid c => GHC.Base.Monoid (Agda.TypeChecking.Free.RelevantIn c) instance GHC.Base.Semigroup c => GHC.Base.Semigroup (Agda.TypeChecking.Free.RelevantIn c) instance Agda.TypeChecking.Free.Lazy.IsVarSet a c => Agda.TypeChecking.Free.Lazy.IsVarSet a (Agda.TypeChecking.Free.RelevantIn c) instance GHC.Base.Semigroup Agda.TypeChecking.Free.SingleFlexRig instance GHC.Base.Monoid Agda.TypeChecking.Free.SingleFlexRig instance Agda.TypeChecking.Free.Lazy.IsVarSet Agda.TypeChecking.Free.Lazy.MetaSet Agda.TypeChecking.Free.SingleFlexRig instance GHC.Base.Semigroup Agda.TypeChecking.Free.SingleVarOcc instance GHC.Base.Monoid Agda.TypeChecking.Free.SingleVarOcc instance Agda.TypeChecking.Free.Lazy.IsVarSet Agda.TypeChecking.Free.Lazy.MetaSet Agda.TypeChecking.Free.SingleVarOcc instance GHC.Base.Semigroup Agda.TypeChecking.Free.VarCounts instance GHC.Base.Monoid Agda.TypeChecking.Free.VarCounts instance Agda.TypeChecking.Free.Lazy.IsVarSet () Agda.TypeChecking.Free.VarCounts instance Agda.Utils.Singleton.Singleton Agda.TypeChecking.Free.Lazy.Variable Agda.TypeChecking.Free.VarCounts instance Agda.TypeChecking.Free.Lazy.IsVarSet () Agda.TypeChecking.Free.VarSet instance Agda.TypeChecking.Free.Lazy.IsVarSet () [GHC.Types.Int] instance Agda.TypeChecking.Free.Lazy.IsVarSet () Data.Semigroup.Internal.Any instance Agda.TypeChecking.Free.Lazy.IsVarSet () Data.Semigroup.Internal.All module Agda.TypeChecking.Substitute.Class -- | Apply something to a bunch of arguments. Preserves blocking tags -- (application can never resolve blocking). class Apply t apply :: Apply t => t -> Args -> t applyE :: Apply t => t -> Elims -> t -- | Apply to some default arguments. applys :: Apply t => t -> [Term] -> t -- | Apply to a single default argument. apply1 :: Apply t => t -> Term -> t -- | (abstract args v) apply args --> v[args]. class Abstract t abstract :: Abstract t => Telescope -> t -> t -- | Apply a substitution. class DeBruijn (SubstArg a) => Subst a where { type SubstArg a; } applySubst :: Subst a => Substitution' (SubstArg a) -> a -> a applySubst :: (Subst a, a ~ f b, Functor f, Subst b, SubstArg a ~ SubstArg b) => Substitution' (SubstArg a) -> a -> a -- | Simple constraint alias for a Subst instance a with -- arg type t. type SubstWith t a = (Subst a, SubstArg a ~ t) -- | Subst instance whose agument type is itself type EndoSubst a = SubstWith a a -- | Subst instance whose argument type is Term type TermSubst a = SubstWith Term a -- | Raise de Bruijn index, i.e. weakening raise :: Subst a => Nat -> a -> a raiseFrom :: Subst a => Nat -> Nat -> a -> a -- | Replace de Bruijn index i by a Term in something. subst :: Subst a => Int -> SubstArg a -> a -> a strengthen :: Subst a => Impossible -> a -> a -- | Replace what is now de Bruijn index 0, but go under n binders. -- substUnder n u == subst n (raise n u). substUnder :: Subst a => Nat -> SubstArg a -> a -> a idS :: Substitution' a wkS :: Int -> Substitution' a -> Substitution' a raiseS :: Int -> Substitution' a consS :: DeBruijn a => a -> Substitution' a -> Substitution' a -- | To replace index n by term u, do applySubst -- (singletonS n u). Γ, Δ ⊢ u : A -- --------------------------------- Γ, Δ ⊢ singletonS |Δ| u : Γ, A, Δ -- singletonS :: DeBruijn a => Int -> a -> Substitution' a -- | Single substitution without disturbing any deBruijn indices. Γ, -- A, Δ ⊢ u : A --------------------------------- Γ, A, Δ ⊢ inplace |Δ| u -- : Γ, A, Δ inplaceS :: EndoSubst a => Int -> a -> Substitution' a -- | Lift a substitution under k binders. liftS :: Int -> Substitution' a -> Substitution' a -- |
--      Γ ⊢ ρ : Δ, Ψ
--   -------------------
--   Γ ⊢ dropS |Ψ| ρ : Δ
--   
--   
dropS :: Int -> Substitution' a -> Substitution' a -- |
--   applySubst (ρ composeS σ) v == applySubst ρ (applySubst σ v)
--   
composeS :: EndoSubst a => Substitution' a -> Substitution' a -> Substitution' a splitS :: Int -> Substitution' a -> (Substitution' a, Substitution' a) (++#) :: DeBruijn a => [a] -> Substitution' a -> Substitution' a infixr 4 ++# -- |
--   Γ ⊢ ρ : Δ  Γ ⊢ reverse vs : Θ
--   ----------------------------- (treating Nothing as having any type)
--     Γ ⊢ prependS vs ρ : Δ, Θ
--   
--   
prependS :: DeBruijn a => Impossible -> [Maybe a] -> Substitution' a -> Substitution' a -- |
--     Γ ⊢ reverse vs : Δ
--   -----------------------------
--     Γ ⊢ parallelS vs ρ : Γ, Δ
--   
--   
-- -- Note the Γ in Γ, Δ. parallelS :: DeBruijn a => [a] -> Substitution' a -- | Γ ⊢ (strengthenS ⊥ |Δ|) : Γ,Δ strengthenS :: Impossible -> Int -> Substitution' a -- | A "smart" variant of Strengthen. If strengthenS is -- applied to a substitution with an outermost Strengthen -- constructor, then the "error message" of that constructor is discarded -- in favour of the Impossible argument of this function. strengthenS' :: Impossible -> Int -> Substitution' a -> Substitution' a lookupS :: EndoSubst a => Substitution' a -> Nat -> a -- | lookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < -- xn. listS :: EndoSubst a => [(Int, a)] -> Substitution' a -- |
--   Γ, Ξ, Δ ⊢ raiseFromS |Δ| |Ξ| : Γ, Δ
--   
raiseFromS :: Nat -> Nat -> Substitution' a -- | Instantiate an abstraction. Strict in the term. absApp :: Subst a => Abs a -> SubstArg a -> a -- | Instantiate an abstraction. Lazy in the term, which allow it to be -- IMPOSSIBLE in the case where the variable shouldn't be used but -- we cannot use noabsApp. Used in Apply. lazyAbsApp :: Subst a => Abs a -> SubstArg a -> a -- | Instantiate an abstraction that doesn't use its argument. noabsApp :: Subst a => Impossible -> Abs a -> a absBody :: Subst a => Abs a -> a mkAbs :: (Subst a, Free a) => ArgName -> a -> Abs a reAbs :: (Subst a, Free a) => Abs a -> Abs a -- | underAbs k a b applies k to a and the -- content of abstraction b and puts the abstraction back. -- a is raised if abstraction was proper such that at point of -- application of k and the content of b are at the -- same context. Precondition: a and b are at the same -- context at call time. underAbs :: Subst a => (a -> b -> b) -> a -> Abs b -> Abs b -- | underLambdas n k a b drops n initial Lams -- from b, performs operation k on a and the -- body of b, and puts the Lams back. a is -- raised correctly according to the number of abstractions. underLambdas :: TermSubst a => Int -> (a -> Term -> Term) -> a -> Term -> Term instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Abstract.Name.QName module Agda.Syntax.Reflected type Args = [Arg Term] data Elim' a Apply :: Arg a -> Elim' a type Elim = Elim' Term type Elims = [Elim] argsToElims :: Args -> Elims data Abs a Abs :: String -> a -> Abs a data Term Var :: Int -> Elims -> Term Con :: QName -> Elims -> Term Def :: QName -> Elims -> Term Meta :: MetaId -> Elims -> Term Lam :: Hiding -> Abs Term -> Term ExtLam :: List1 Clause -> Elims -> Term Pi :: Dom Type -> Abs Type -> Term Sort :: Sort -> Term Lit :: Literal -> Term Unknown :: Term type Type = Term data Sort SetS :: Term -> Sort LitS :: Integer -> Sort PropS :: Term -> Sort PropLitS :: Integer -> Sort InfS :: Integer -> Sort UnknownS :: Sort data Pattern ConP :: QName -> [Arg Pattern] -> Pattern DotP :: Term -> Pattern VarP :: Int -> Pattern LitP :: Literal -> Pattern AbsurdP :: Int -> Pattern ProjP :: QName -> Pattern data Clause Clause :: [(Text, Arg Type)] -> [Arg Pattern] -> Term -> Clause [clauseTel] :: Clause -> [(Text, Arg Type)] [clausePats] :: Clause -> [Arg Pattern] [clauseRHS] :: Clause -> Term AbsurdClause :: [(Text, Arg Type)] -> [Arg Pattern] -> Clause [clauseTel] :: Clause -> [(Text, Arg Type)] [clausePats] :: Clause -> [Arg Pattern] data Definition FunDef :: Type -> [Clause] -> Definition DataDef :: Definition RecordDef :: Definition DataConstructor :: Definition Axiom :: Definition Primitive :: Definition instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Reflected.Elim' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Reflected.Abs a) instance GHC.Show.Show Agda.Syntax.Reflected.Sort instance GHC.Show.Show Agda.Syntax.Reflected.Term instance GHC.Show.Show Agda.Syntax.Reflected.Pattern instance GHC.Show.Show Agda.Syntax.Reflected.Clause instance GHC.Show.Show Agda.Syntax.Reflected.Definition module Agda.Syntax.Internal.Pattern -- | Translate the clause patterns to terms with free variables bound by -- the clause telescope. -- -- Precondition: no projection patterns. clauseArgs :: Clause -> Args -- | Translate the clause patterns to an elimination spine with free -- variables bound by the clause telescope. clauseElims :: Clause -> Elims -- | Arity of a function, computed from clauses. class FunArity a funArity :: FunArity a => a -> Int -- | Label the pattern variables from left to right using one label for -- each variable pattern and one for each dot pattern. class LabelPatVars a b where { type PatVarLabel b; } labelPatVars :: LabelPatVars a b => a -> State [PatVarLabel b] b -- | Intended, but unpractical due to the absence of type-level lambda, is: -- labelPatVars :: f (Pattern' x) -> State [i] (f (Pattern' -- (i,x))) unlabelPatVars :: LabelPatVars a b => b -> a labelPatVars :: (LabelPatVars a b, Traversable f, LabelPatVars a' b', PatVarLabel b ~ PatVarLabel b', f a' ~ a, f b' ~ b) => a -> State [PatVarLabel b] b -- | Intended, but unpractical due to the absence of type-level lambda, is: -- labelPatVars :: f (Pattern' x) -> State [i] (f (Pattern' -- (i,x))) unlabelPatVars :: (LabelPatVars a b, Traversable f, LabelPatVars a' b', f a' ~ a, f b' ~ b) => b -> a -- | Augment pattern variables with their de Bruijn index. numberPatVars :: (LabelPatVars a b, PatVarLabel b ~ Int) => Int -> Permutation -> a -> b unnumberPatVars :: LabelPatVars a b => b -> a dbPatPerm :: [NamedArg DeBruijnPattern] -> Maybe Permutation -- | Computes the permutation from the clause telescope to the pattern -- variables. -- -- Use as fromMaybe IMPOSSIBLE . dbPatPerm to crash in a -- controlled way if a de Bruijn index is out of scope here. -- -- The first argument controls whether dot patterns counts as variables -- or not. dbPatPerm' :: Bool -> [NamedArg DeBruijnPattern] -> Maybe Permutation -- | Computes the permutation from the clause telescope to the pattern -- variables. -- -- Use as fromMaybe IMPOSSIBLE . clausePerm to crash in a -- controlled way if a de Bruijn index is out of scope here. clausePerm :: Clause -> Maybe Permutation -- | Turn a pattern into a term. Projection patterns are turned into -- projection eliminations, other patterns into apply elimination. patternToElim :: Arg DeBruijnPattern -> Elim patternsToElims :: [NamedArg DeBruijnPattern] -> [Elim] patternToTerm :: DeBruijnPattern -> Term class MapNamedArgPattern a p mapNamedArgPattern :: MapNamedArgPattern a p => (NamedArg (Pattern' a) -> NamedArg (Pattern' a)) -> p -> p mapNamedArgPattern :: (MapNamedArgPattern a p, Functor f, MapNamedArgPattern a p', p ~ f p') => (NamedArg (Pattern' a) -> NamedArg (Pattern' a)) -> p -> p -- | Generic pattern traversal. -- -- Pre-applies a pattern modification, recurses, and post-applies another -- one. class PatternLike a b -- | Fold pattern. foldrPattern :: (PatternLike a b, Monoid m) => (Pattern' a -> m -> m) -> b -> m -- | Fold pattern. foldrPattern :: (PatternLike a b, Monoid m, Foldable f, PatternLike a p, f p ~ b) => (Pattern' a -> m -> m) -> b -> m -- | Traverse pattern. traversePatternM :: (PatternLike a b, Monad m) => (Pattern' a -> m (Pattern' a)) -> (Pattern' a -> m (Pattern' a)) -> b -> m b -- | Traverse pattern. traversePatternM :: (PatternLike a b, Traversable f, PatternLike a p, f p ~ b, Monad m) => (Pattern' a -> m (Pattern' a)) -> (Pattern' a -> m (Pattern' a)) -> b -> m b -- | Compute from each subpattern a value and collect them all in a monoid. foldPattern :: (PatternLike a b, Monoid m) => (Pattern' a -> m) -> b -> m -- | Traverse pattern(s) with a modification before the recursive descent. preTraversePatternM :: (PatternLike a b, Monad m) => (Pattern' a -> m (Pattern' a)) -> b -> m b -- | Traverse pattern(s) with a modification after the recursive descent. postTraversePatternM :: (PatternLike a b, Monad m) => (Pattern' a -> m (Pattern' a)) -> b -> m b class CountPatternVars a countPatternVars :: CountPatternVars a => a -> Int countPatternVars :: (CountPatternVars a, Foldable f, CountPatternVars b, f b ~ a) => a -> Int class PatternVarModalities p where { type PatVar p; } -- | Get the list of pattern variables annotated with modalities. patternVarModalities :: PatternVarModalities p => p -> [(PatVar p, Modality)] hasDefP :: [NamedArg DeBruijnPattern] -> Bool instance Agda.Syntax.Internal.Pattern.PatternVarModalities a => Agda.Syntax.Internal.Pattern.PatternVarModalities [a] instance Agda.Syntax.Internal.Pattern.PatternVarModalities a => Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Common.Named s a) instance Agda.Syntax.Internal.Pattern.PatternVarModalities a => Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Internal.Pattern' x) instance Agda.Syntax.Internal.Pattern.CountPatternVars a => Agda.Syntax.Internal.Pattern.CountPatternVars [a] instance Agda.Syntax.Internal.Pattern.CountPatternVars a => Agda.Syntax.Internal.Pattern.CountPatternVars (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Internal.Pattern.CountPatternVars a => Agda.Syntax.Internal.Pattern.CountPatternVars (Agda.Syntax.Common.Named x a) instance Agda.Syntax.Internal.Pattern.CountPatternVars (Agda.Syntax.Internal.Pattern' x) instance Agda.Syntax.Internal.Pattern.PatternLike a (Agda.Syntax.Internal.Pattern' a) instance Agda.Syntax.Internal.Pattern.PatternLike a b => Agda.Syntax.Internal.Pattern.PatternLike a [b] instance Agda.Syntax.Internal.Pattern.PatternLike a b => Agda.Syntax.Internal.Pattern.PatternLike a (Agda.Syntax.Common.Arg b) instance Agda.Syntax.Internal.Pattern.PatternLike a b => Agda.Syntax.Internal.Pattern.PatternLike a (Agda.Syntax.Common.Named x b) instance Agda.Syntax.Internal.Pattern.MapNamedArgPattern a (Agda.Syntax.Common.NamedArg (Agda.Syntax.Internal.Pattern' a)) instance Agda.Syntax.Internal.Pattern.MapNamedArgPattern a p => Agda.Syntax.Internal.Pattern.MapNamedArgPattern a [p] instance Agda.Syntax.Internal.Pattern.LabelPatVars a b => Agda.Syntax.Internal.Pattern.LabelPatVars (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b) instance Agda.Syntax.Internal.Pattern.LabelPatVars a b => Agda.Syntax.Internal.Pattern.LabelPatVars (Agda.Syntax.Common.Named x a) (Agda.Syntax.Common.Named x b) instance Agda.Syntax.Internal.Pattern.LabelPatVars a b => Agda.Syntax.Internal.Pattern.LabelPatVars [a] [b] instance Agda.Syntax.Internal.Pattern.LabelPatVars Agda.Syntax.Internal.Pattern Agda.Syntax.Internal.DeBruijnPattern instance Agda.Syntax.Abstract.Name.IsProjP p => Agda.Syntax.Internal.Pattern.FunArity [p] instance Agda.Syntax.Internal.Pattern.FunArity Agda.Syntax.Internal.Clause instance Agda.Syntax.Internal.Pattern.FunArity [Agda.Syntax.Internal.Clause] -- | Tree traversal for internal syntax. module Agda.Syntax.Internal.Generic -- | Generic term traversal. -- -- Note: ignores sorts in terms! (Does not traverse into or collect from -- them.) class TermLike a -- | Generic traversal with post-traversal action. Ignores sorts. traverseTermM :: (TermLike a, Monad m) => (Term -> m Term) -> a -> m a -- | Generic traversal with post-traversal action. Ignores sorts. traverseTermM :: (TermLike a, Monad m, Traversable f, TermLike b, f b ~ a) => (Term -> m Term) -> a -> m a -- | Generic fold, ignoring sorts. foldTerm :: (TermLike a, Monoid m) => (Term -> m) -> a -> m -- | Generic fold, ignoring sorts. foldTerm :: (TermLike a, Monoid m, Foldable f, TermLike b, f b ~ a) => (Term -> m) -> a -> m -- | Put it in a monad to make it possible to do strictly. copyTerm :: (TermLike a, Monad m) => a -> m a instance Agda.Syntax.Internal.Generic.TermLike GHC.Types.Bool instance Agda.Syntax.Internal.Generic.TermLike GHC.Types.Int instance Agda.Syntax.Internal.Generic.TermLike GHC.Num.Integer.Integer instance Agda.Syntax.Internal.Generic.TermLike GHC.Types.Char instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Internal.Dom a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike [a] instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (GHC.Maybe.Maybe a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Internal.Blocked a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Internal.Abs a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Internal.Tele a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.Syntax.Common.WithHiding a) instance (Agda.Syntax.Internal.Generic.TermLike a, Agda.Syntax.Internal.Generic.TermLike b) => Agda.Syntax.Internal.Generic.TermLike (a, b) instance (Agda.Syntax.Internal.Generic.TermLike a, Agda.Syntax.Internal.Generic.TermLike b, Agda.Syntax.Internal.Generic.TermLike c) => Agda.Syntax.Internal.Generic.TermLike (a, b, c) instance (Agda.Syntax.Internal.Generic.TermLike a, Agda.Syntax.Internal.Generic.TermLike b, Agda.Syntax.Internal.Generic.TermLike c, Agda.Syntax.Internal.Generic.TermLike d) => Agda.Syntax.Internal.Generic.TermLike (a, b, c, d) instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Internal.Term instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Internal.Level instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Internal.PlusLevel instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Internal.Type instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Internal.Sort instance Agda.Syntax.Internal.Generic.TermLike Agda.Syntax.Internal.EqualityView -- | Case trees. -- -- After coverage checking, pattern matching is translated to case trees, -- i.e., a tree of successive case splits on one variable at a time. module Agda.TypeChecking.CompiledClause data WithArity c WithArity :: Int -> c -> WithArity c [arity] :: WithArity c -> Int [content] :: WithArity c -> c -- | Branches in a case tree. data Case c Branches :: Bool -> Map QName (WithArity c) -> Maybe (ConHead, WithArity c) -> Map Literal c -> Maybe c -> Maybe Bool -> Bool -> Case c -- | We are constructing a record here (copatterns). conBranches -- lists projections. [projPatterns] :: Case c -> Bool -- | Map from constructor (or projection) names to their arity and the case -- subtree. (Projections have arity 0.) [conBranches] :: Case c -> Map QName (WithArity c) -- | Eta-expand with the given (eta record) constructor. If this is -- present, there should not be any conBranches or litBranches. [etaBranch] :: Case c -> Maybe (ConHead, WithArity c) -- | Map from literal to case subtree. [litBranches] :: Case c -> Map Literal c -- | (Possibly additional) catch-all clause. [catchAllBranch] :: Case c -> Maybe c -- | (if True) In case of non-canonical argument use catchAllBranch. [fallThrough] :: Case c -> Maybe Bool -- | Lazy pattern match. Requires single (non-copattern) branch with no lit -- branches and no catch-all. [lazyMatch] :: Case c -> Bool -- | Case tree with bodies. data CompiledClauses' a -- | Case n bs stands for a match on the n-th argument -- (counting from zero) with bs as the case branches. If the -- n-th argument is a projection, we have only -- conBranches with arity 0. Case :: Arg Int -> Case (CompiledClauses' a) -> CompiledClauses' a -- | Done xs b stands for the body b where the -- xs contains hiding and name suggestions for the free -- variables. This is needed to build lambdas on the right hand side for -- partial applications which can still reduce. Done :: [Arg ArgName] -> a -> CompiledClauses' a -- | Absurd case. Add the free variables here as well so we can build -- correct number of lambdas for strict backends. (#4280) Fail :: [Arg ArgName] -> CompiledClauses' a type CompiledClauses = CompiledClauses' Term litCase :: Literal -> c -> Case c conCase :: QName -> Bool -> WithArity c -> Case c etaCase :: ConHead -> WithArity c -> Case c projCase :: QName -> c -> Case c catchAll :: c -> Case c -- | Check that the requirements on lazy matching (single inductive case) -- are met, and set lazy to False otherwise. checkLazyMatch :: Case c -> Case c -- | Check whether a case tree has a catch-all clause. hasCatchAll :: CompiledClauses -> Bool -- | Check whether a case tree has any projection patterns hasProjectionPatterns :: CompiledClauses -> Bool prettyMap_ :: (Pretty k, Pretty v) => Map k v -> [Doc] instance GHC.Generics.Generic (Agda.TypeChecking.CompiledClause.WithArity c) instance GHC.Show.Show c => GHC.Show.Show (Agda.TypeChecking.CompiledClause.WithArity c) instance Data.Traversable.Traversable Agda.TypeChecking.CompiledClause.WithArity instance Data.Foldable.Foldable Agda.TypeChecking.CompiledClause.WithArity instance GHC.Base.Functor Agda.TypeChecking.CompiledClause.WithArity instance GHC.Generics.Generic (Agda.TypeChecking.CompiledClause.Case c) instance GHC.Show.Show c => GHC.Show.Show (Agda.TypeChecking.CompiledClause.Case c) instance Data.Traversable.Traversable Agda.TypeChecking.CompiledClause.Case instance Data.Foldable.Foldable Agda.TypeChecking.CompiledClause.Case instance GHC.Base.Functor Agda.TypeChecking.CompiledClause.Case instance GHC.Generics.Generic (Agda.TypeChecking.CompiledClause.CompiledClauses' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.CompiledClause.CompiledClauses' a) instance Data.Foldable.Foldable Agda.TypeChecking.CompiledClause.CompiledClauses' instance Data.Traversable.Traversable Agda.TypeChecking.CompiledClause.CompiledClauses' instance GHC.Base.Functor Agda.TypeChecking.CompiledClause.CompiledClauses' instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.Syntax.Position.KillRange Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.TypeChecking.CompiledClause.CompiledClauses' a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.TypeChecking.CompiledClause.CompiledClauses' a) instance GHC.Base.Semigroup m => GHC.Base.Semigroup (Agda.TypeChecking.CompiledClause.Case m) instance (GHC.Base.Semigroup m, GHC.Base.Monoid m) => GHC.Base.Monoid (Agda.TypeChecking.CompiledClause.Case m) instance Agda.Utils.Null.Null (Agda.TypeChecking.CompiledClause.Case m) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.CompiledClause.Case a) instance Agda.Syntax.Position.KillRange c => Agda.Syntax.Position.KillRange (Agda.TypeChecking.CompiledClause.Case c) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.TypeChecking.CompiledClause.Case a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.TypeChecking.CompiledClause.Case a) instance GHC.Base.Semigroup c => GHC.Base.Semigroup (Agda.TypeChecking.CompiledClause.WithArity c) instance (GHC.Base.Semigroup c, GHC.Base.Monoid c) => GHC.Base.Monoid (Agda.TypeChecking.CompiledClause.WithArity c) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.CompiledClause.WithArity a) instance Agda.Syntax.Position.KillRange c => Agda.Syntax.Position.KillRange (Agda.TypeChecking.CompiledClause.WithArity c) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.Generic.TermLike (Agda.TypeChecking.CompiledClause.WithArity a) instance Control.DeepSeq.NFData c => Control.DeepSeq.NFData (Agda.TypeChecking.CompiledClause.WithArity c) module Agda.Syntax.Internal.MetaVars -- | Returns every meta-variable occurrence in the given type, except for -- those in sort annotations on types. class AllMetas t allMetas :: (AllMetas t, Monoid m) => (MetaId -> m) -> t -> m allMetas :: (AllMetas t, TermLike t, Monoid m) => (MetaId -> m) -> t -> m allMetas' :: (TermLike a, Monoid m) => (MetaId -> m) -> a -> m -- | Returns allMetas in a list. allMetasList = allMetas -- (:[]). -- -- Note: this resulting list is computed via difference lists. Thus, use -- this function if you actually need the whole list of metas. Otherwise, -- use allMetas with a suitable monoid. allMetasList :: AllMetas a => a -> [MetaId] -- | True if thing contains no metas. noMetas = null . -- allMetasList. noMetas :: AllMetas a => a -> Bool -- | Returns the first meta it find in the thing, if any. firstMeta == -- listToMaybe . allMetasList. firstMeta :: AllMetas a => a -> Maybe MetaId -- | A blocker that unblocks if any of the metas in a term are solved. unblockOnAnyMetaIn :: AllMetas t => t -> Blocker -- | A blocker that unblocks if any of the metas in a term are solved. unblockOnAllMetasIn :: AllMetas t => t -> Blocker instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.Syntax.Internal.Term instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.Syntax.Internal.Type instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.MetaVars.AllMetas (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Internal.Generic.TermLike a => Agda.Syntax.Internal.MetaVars.AllMetas (Agda.Syntax.Internal.Tele a) instance (Agda.Syntax.Internal.MetaVars.AllMetas a, Agda.Syntax.Internal.MetaVars.AllMetas b) => Agda.Syntax.Internal.MetaVars.AllMetas (Agda.Syntax.Internal.Dom' a b) instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.Syntax.Internal.Sort instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.Syntax.Internal.Level instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.Syntax.Internal.PlusLevel instance Agda.Syntax.Internal.MetaVars.AllMetas GHC.Base.String instance (Agda.Syntax.Internal.MetaVars.AllMetas a, Agda.Syntax.Internal.MetaVars.AllMetas b) => Agda.Syntax.Internal.MetaVars.AllMetas (a, b) instance (Agda.Syntax.Internal.MetaVars.AllMetas a, Agda.Syntax.Internal.MetaVars.AllMetas b, Agda.Syntax.Internal.MetaVars.AllMetas c) => Agda.Syntax.Internal.MetaVars.AllMetas (a, b, c) instance (Agda.Syntax.Internal.MetaVars.AllMetas a, Agda.Syntax.Internal.MetaVars.AllMetas b, Agda.Syntax.Internal.MetaVars.AllMetas c, Agda.Syntax.Internal.MetaVars.AllMetas d) => Agda.Syntax.Internal.MetaVars.AllMetas (a, b, c, d) instance Agda.Syntax.Internal.MetaVars.AllMetas a => Agda.Syntax.Internal.MetaVars.AllMetas [a] instance Agda.Syntax.Internal.MetaVars.AllMetas a => Agda.Syntax.Internal.MetaVars.AllMetas (GHC.Maybe.Maybe a) instance Agda.Syntax.Internal.MetaVars.AllMetas a => Agda.Syntax.Internal.MetaVars.AllMetas (Agda.Syntax.Common.Arg a) -- | Extract used definitions from terms. module Agda.Syntax.Internal.Defs -- | getDefs' lookup emb a extracts all used definitions -- (functions, data/record types) from a, embedded into a monoid -- via emb. Instantiations of meta variables are obtained via -- lookup. -- -- Typical monoid instances would be [QName] or Set -- QName. Note that emb can also choose to discard a used -- definition by mapping to the unit of the monoid. getDefs' :: (GetDefs a, Monoid b) => (MetaId -> Maybe Term) -> (QName -> b) -> a -> b -- | Inputs to and outputs of getDefs' are organized as a monad. type GetDefsM b = ReaderT (GetDefsEnv b) (Writer b) data GetDefsEnv b GetDefsEnv :: (MetaId -> Maybe Term) -> (QName -> b) -> GetDefsEnv b [lookupMeta] :: GetDefsEnv b -> MetaId -> Maybe Term [embDef] :: GetDefsEnv b -> QName -> b -- | What it takes to get the used definitions. class Monad m => MonadGetDefs m doDef :: MonadGetDefs m => QName -> m () doMeta :: MonadGetDefs m => MetaId -> m () -- | Getting the used definitions. -- -- Note: in contrast to foldTerm getDefs also collects -- from sorts in terms. Thus, this is not an instance of -- foldTerm. class GetDefs a getDefs :: (GetDefs a, MonadGetDefs m) => a -> m () getDefs :: (GetDefs a, MonadGetDefs m, Foldable f, GetDefs b, f b ~ a) => a -> m () instance GHC.Base.Monoid b => Agda.Syntax.Internal.Defs.MonadGetDefs (Agda.Syntax.Internal.Defs.GetDefsM b) instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.Clause instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.Term instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Common.MetaId instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.Type instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.Sort instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.Level instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.PlusLevel instance Agda.Syntax.Internal.Defs.GetDefs a => Agda.Syntax.Internal.Defs.GetDefs (GHC.Maybe.Maybe a) instance Agda.Syntax.Internal.Defs.GetDefs a => Agda.Syntax.Internal.Defs.GetDefs [a] instance Agda.Syntax.Internal.Defs.GetDefs a => Agda.Syntax.Internal.Defs.GetDefs (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Internal.Defs.GetDefs a => Agda.Syntax.Internal.Defs.GetDefs (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Internal.Defs.GetDefs a => Agda.Syntax.Internal.Defs.GetDefs (Agda.Syntax.Internal.Dom a) instance Agda.Syntax.Internal.Defs.GetDefs a => Agda.Syntax.Internal.Defs.GetDefs (Agda.Syntax.Internal.Abs a) instance (Agda.Syntax.Internal.Defs.GetDefs a, Agda.Syntax.Internal.Defs.GetDefs b) => Agda.Syntax.Internal.Defs.GetDefs (a, b) instance Agda.Syntax.Internal.Defs.GetDefs Agda.Syntax.Internal.Telescope instance Agda.Syntax.Internal.Defs.GetDefs GHC.Base.String -- | The abstract syntax. This is what you get after desugaring and scope -- analysis of the concrete syntax. The type checker works on abstract -- syntax, producing internal syntax (Agda.Syntax.Internal). module Agda.Syntax.Abstract -- | Spines corresponding to WhereDeclarations values. data WhereDeclarationsSpine WhereDeclsS :: Maybe DeclarationSpine -> WhereDeclarationsSpine -- | Right-hand side spines. data RHSSpine RHSS :: RHSSpine AbsurdRHSS :: RHSSpine WithRHSS :: [ClauseSpine] -> RHSSpine RewriteRHSS :: RHSSpine -> WhereDeclarationsSpine -> RHSSpine -- | Clause spines. data ClauseSpine ClauseS :: RHSSpine -> WhereDeclarationsSpine -> ClauseSpine -- | Declaration spines. Used in debugging to make it easy to see where -- constructors such as ScopedDecl and Mutual are placed. data DeclarationSpine AxiomS :: DeclarationSpine GeneralizeS :: DeclarationSpine FieldS :: DeclarationSpine PrimitiveS :: DeclarationSpine MutualS :: [DeclarationSpine] -> DeclarationSpine SectionS :: [DeclarationSpine] -> DeclarationSpine ApplyS :: DeclarationSpine ImportS :: DeclarationSpine PragmaS :: DeclarationSpine OpenS :: DeclarationSpine FunDefS :: [ClauseSpine] -> DeclarationSpine DataSigS :: DeclarationSpine DataDefS :: DeclarationSpine RecSigS :: DeclarationSpine RecDefS :: [DeclarationSpine] -> DeclarationSpine PatternSynDefS :: DeclarationSpine UnquoteDeclS :: DeclarationSpine UnquoteDefS :: DeclarationSpine UnquoteDataS :: DeclarationSpine ScopedDeclS :: [DeclarationSpine] -> DeclarationSpine class SubstExpr a substExpr :: SubstExpr a => [(Name, Expr)] -> a -> a substExpr :: (SubstExpr a, Functor t, SubstExpr b, t b ~ a) => [(Name, Expr)] -> a -> a type PatternSynDefns = Map QName PatternSynDefn type PatternSynDefn = ([Arg Name], Pattern' Void) -- | Turn a name into an expression. class NameToExpr a nameToExpr :: NameToExpr a => a -> Expr -- | Are we in an abstract block? -- -- In that case some definition is abstract. class AnyAbstract a anyAbstract :: AnyAbstract a => a -> Bool type HoleContent = HoleContent' () BindName Pattern Expr type Patterns = [NamedArg Pattern] type Pattern = Pattern' Expr type NAPs1 e = List1 (NamedArg (Pattern' e)) type NAPs e = [NamedArg (Pattern' e)] -- | Parameterised over the type of dot patterns. data Pattern' e VarP :: BindName -> Pattern' e ConP :: ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e -- | Destructor pattern d. ProjP :: PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e -- | Defined pattern: function definition f ps. It is also abused -- to convert destructor patterns into concrete syntax thus, we put -- AmbiguousQName here as well. DefP :: PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e -- | Underscore pattern entered by user. Or generated at type checking for -- implicit arguments. WildP :: PatInfo -> Pattern' e AsP :: PatInfo -> BindName -> Pattern' e -> Pattern' e -- | Dot pattern .e DotP :: PatInfo -> e -> Pattern' e AbsurdP :: PatInfo -> Pattern' e LitP :: PatInfo -> Literal -> Pattern' e PatternSynP :: PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e RecP :: PatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e EqualP :: PatInfo -> [(e, e)] -> Pattern' e -- | | p, for with-patterns. WithP :: PatInfo -> Pattern' e -> Pattern' e -- | Pattern with type annotation AnnP :: PatInfo -> e -> Pattern' e -> Pattern' e type LHSCore = LHSCore' Expr -- | The lhs in projection-application and with-pattern view. Parameterised -- over the type e of dot patterns. data LHSCore' e -- | The head applied to ordinary patterns. LHSHead :: QName -> [NamedArg (Pattern' e)] -> LHSCore' e -- | Head f. [lhsDefName] :: LHSCore' e -> QName -- | Applied to patterns ps. [lhsPats] :: LHSCore' e -> [NamedArg (Pattern' e)] -- | Projection. LHSProj :: AmbiguousQName -> NamedArg (LHSCore' e) -> [NamedArg (Pattern' e)] -> LHSCore' e -- | Record projection identifier. [lhsDestructor] :: LHSCore' e -> AmbiguousQName -- | Main argument of projection. [lhsFocus] :: LHSCore' e -> NamedArg (LHSCore' e) -- | Applied to patterns ps. [lhsPats] :: LHSCore' e -> [NamedArg (Pattern' e)] -- | With patterns. LHSWith :: LHSCore' e -> [Arg (Pattern' e)] -> [NamedArg (Pattern' e)] -> LHSCore' e -- | E.g. the LHSHead. [lhsHead] :: LHSCore' e -> LHSCore' e -- | Applied to with patterns | p1 | ... | pn. These patterns are -- not prefixed with WithP! [lhsWithPatterns] :: LHSCore' e -> [Arg (Pattern' e)] -- | Applied to patterns ps. [lhsPats] :: LHSCore' e -> [NamedArg (Pattern' e)] -- | The lhs of a clause in focused (projection-application) view -- (outside-in). Projection patters are represented as LHSProjs. data LHS LHS :: LHSInfo -> LHSCore -> LHS -- | Range. [lhsInfo] :: LHS -> LHSInfo -- | Copatterns. [lhsCore] :: LHS -> LHSCore -- | The lhs of a clause in spine view (inside-out). Projection patterns -- are contained in spLhsPats, represented as ProjP d. data SpineLHS SpineLHS :: LHSInfo -> QName -> [NamedArg Pattern] -> SpineLHS -- | Range. [spLhsInfo] :: SpineLHS -> LHSInfo -- | Name of function we are defining. [spLhsDefName] :: SpineLHS -> QName -- | Elimination by pattern, projections, with-patterns. [spLhsPats] :: SpineLHS -> [NamedArg Pattern] data RHS RHS :: Expr -> Maybe Expr -> RHS [rhsExpr] :: RHS -> Expr -- | We store the original concrete expression in case we have to reproduce -- it during interactive case splitting. Nothing for internally -- generated rhss. [rhsConcrete] :: RHS -> Maybe Expr AbsurdRHS :: RHS -- | The QName is the name of the with function. WithRHS :: QName -> [WithExpr] -> [Clause] -> RHS RewriteRHS :: [RewriteEqn] -> [ProblemEq] -> RHS -> WhereDeclarations -> RHS -- | The QNames are the names of the generated with functions, one -- for each Expr. [rewriteExprs] :: RHS -> [RewriteEqn] -- | The patterns stripped by with-desugaring. These are only present if -- this rewrite follows a with. [rewriteStrippedPats] :: RHS -> [ProblemEq] -- | The RHS should not be another RewriteRHS. [rewriteRHS] :: RHS -> RHS -- | The where clauses are attached to the RewriteRHS by [rewriteWhereDecls] :: RHS -> WhereDeclarations type WithExpr = WithExpr' Expr type WithExpr' e = Named BindName (Arg e) type RewriteEqn = RewriteEqn' QName BindName Pattern Expr type SpineClause = Clause' SpineLHS type Clause = Clause' LHS data WhereDeclarations WhereDecls :: Maybe ModuleName -> Bool -> Maybe Declaration -> WhereDeclarations [whereModule] :: WhereDeclarations -> Maybe ModuleName -- | is it an ordinary unnamed where? [whereAnywhere] :: WhereDeclarations -> Bool -- | The declaration is a Section. [whereDecls] :: WhereDeclarations -> Maybe Declaration -- | We could throw away where clauses at this point and translate -- them to let. It's not obvious how to remember that the -- let was really a where clause though, so for the -- time being we keep it here. data Clause' lhs Clause :: lhs -> [ProblemEq] -> RHS -> WhereDeclarations -> Bool -> Clause' lhs [clauseLHS] :: Clause' lhs -> lhs -- | Only in with-clauses where we inherit some already checked patterns -- from the parent. These live in the context of the parent clause -- left-hand side. [clauseStrippedPats] :: Clause' lhs -> [ProblemEq] [clauseRHS] :: Clause' lhs -> RHS [clauseWhereDecls] :: Clause' lhs -> WhereDeclarations [clauseCatchall] :: Clause' lhs -> Bool -- | A user pattern together with an internal term that it should be equal -- to after splitting is complete. Special cases: * User pattern is a -- variable but internal term isn't: this will be turned into an as -- pattern. * User pattern is a dot pattern: this pattern won't trigger -- any splitting but will be checked for equality after all splitting is -- complete and as patterns have been bound. * User pattern is an absurd -- pattern: emptiness of the type will be checked after splitting is -- complete. * User pattern is an annotated wildcard: type annotation -- will be checked after splitting is complete. data ProblemEq ProblemEq :: Pattern -> Term -> Dom Type -> ProblemEq [problemInPat] :: ProblemEq -> Pattern [problemInst] :: ProblemEq -> Term [problemType] :: ProblemEq -> Dom Type data DataDefParams DataDefParams :: Set Name -> [LamBinding] -> DataDefParams -- | We don't yet know the position of generalized parameters from the data -- sig, so we keep these in a set on the side. [dataDefGeneralizedParams] :: DataDefParams -> Set Name [dataDefParams] :: DataDefParams -> [LamBinding] data GeneralizeTelescope GeneralizeTel :: Map QName Name -> Telescope -> GeneralizeTelescope -- | Maps generalize variables to the corresponding bound variable (to be -- introduced by the generalisation). [generalizeTelVars] :: GeneralizeTelescope -> Map QName Name [generalizeTel] :: GeneralizeTelescope -> Telescope type Telescope = [TypedBinding] type Telescope1 = List1 TypedBinding -- | A typed binding. Appears in dependent function spaces, typed lambdas, -- and telescopes. It might be tempting to simplify this to only bind a -- single name at a time, and translate, say, (x y : A) to -- (x : A)(y : A) before type-checking. However, this would be -- slightly problematic: -- --
    --
  1. We would have to typecheck the type A several times.
  2. --
  3. If A contains a meta variable or hole, it would be -- duplicated by such a translation.
  4. --
-- -- While 1. is only slightly inefficient, 2. would be an outright bug. -- Duplicating A could not be done naively, we would have to -- make sure that the metas of the copy are aliases of the metas of the -- original. data TypedBinding -- | As in telescope (x y z : A) or type (x y z : A) -> -- B. TBind :: Range -> TypedBindingInfo -> List1 (NamedArg Binder) -> Type -> TypedBinding -- | E.g. (let x = e) or (let open M). TLet :: Range -> List1 LetBinding -> TypedBinding -- | Extra information that is attached to a typed binding, that plays a -- role during type checking but strictly speaking is not part of the -- name : type" relation which a makes up a binding. data TypedBindingInfo TypedBindingInfo :: TacticAttr -> Bool -> TypedBindingInfo -- | Does this binding have a tactic annotation? [tbTacticAttr] :: TypedBindingInfo -> TacticAttr -- | Does this binding correspond to a Partial binder, rather than to a Pi -- binder? Must be present here to be reflected into abstract syntax -- later (and to be printed to the user later). [tbFinite] :: TypedBindingInfo -> Bool -- | A lambda binding is either domain free or typed. data LamBinding -- | . x or {x} or .x or {x = y} or -- x@p or (p) DomainFree :: TacticAttr -> NamedArg Binder -> LamBinding -- | . (xs:e) or {xs:e} or (let Ds) DomainFull :: TypedBinding -> LamBinding type Binder = Binder' BindName data Binder' a Binder :: Maybe Pattern -> a -> Binder' a [binderPattern] :: Binder' a -> Maybe Pattern [binderName] :: Binder' a -> a type TacticAttr = Maybe Expr type Field = TypeSignature type Constructor = TypeSignature -- | Only Axioms. type TypeSignature = Declaration -- | Bindings that are valid in a let. data LetBinding -- |
--   LetBind info rel name type defn
--   
LetBind :: LetInfo -> ArgInfo -> BindName -> Type -> Expr -> LetBinding -- | Irrefutable pattern binding. LetPatBind :: LetInfo -> Pattern -> Expr -> LetBinding -- | LetApply mi newM (oldM args) renamings dir. The -- ImportDirective is for highlighting purposes. LetApply :: ModuleInfo -> ModuleName -> ModuleApplication -> ScopeCopyInfo -> ImportDirective -> LetBinding -- | only for highlighting and abstractToConcrete LetOpen :: ModuleInfo -> ModuleName -> ImportDirective -> LetBinding -- | Only used for highlighting. Refers to the first occurrence of -- x in let x : A; x = e. LetDeclaredVariable :: BindName -> LetBinding data Pragma OptionsPragma :: [String] -> Pragma -- | ResolvedName is not UnknownName. Name can be ambiguous -- e.g. for built-in constructors. BuiltinPragma :: RString -> ResolvedName -> Pragma -- | Builtins that do not come with a definition, but declare a name for an -- Agda concept. BuiltinNoDefPragma :: RString -> KindOfName -> QName -> Pragma -- | Range is range of REWRITE keyword. RewritePragma :: Range -> [QName] -> Pragma CompilePragma :: RString -> QName -> String -> Pragma StaticPragma :: QName -> Pragma -- | For coinductive records, use pragma instead of regular -- eta-equality definition (as it is might make Agda loop). EtaPragma :: QName -> Pragma InjectivePragma :: QName -> Pragma InlinePragma :: Bool -> QName -> Pragma NotProjectionLikePragma :: QName -> Pragma DisplayPragma :: QName -> [NamedArg Pattern] -> Expr -> Pragma data ModuleApplication -- | tel. M args: applies M to args and -- abstracts tel. SectionApp :: Telescope -> ModuleName -> [NamedArg Expr] -> ModuleApplication -- |
--   M {{...}}
--   
RecordModuleInstance :: ModuleName -> ModuleApplication type ImportedName = ImportedName' QName ModuleName type Renaming = Renaming' QName ModuleName type ImportDirective = ImportDirective' QName ModuleName type DefInfo = DefInfo' Expr data Declaration -- | Type signature (can be irrelevant, but not hidden). -- -- The fourth argument contains an optional assignment of polarities to -- arguments. Axiom :: KindOfName -> DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> Type -> Declaration -- | First argument is set of generalizable variables used in the type. Generalize :: Set QName -> DefInfo -> ArgInfo -> QName -> Type -> Declaration -- | record field Field :: DefInfo -> QName -> Arg Type -> Declaration -- | primitive function Primitive :: DefInfo -> QName -> Arg Type -> Declaration -- | a bunch of mutually recursive definitions Mutual :: MutualInfo -> [Declaration] -> Declaration Section :: Range -> ModuleName -> GeneralizeTelescope -> [Declaration] -> Declaration -- | The ImportDirective is for highlighting purposes. Apply :: ModuleInfo -> ModuleName -> ModuleApplication -> ScopeCopyInfo -> ImportDirective -> Declaration -- | The ImportDirective is for highlighting purposes. Import :: ModuleInfo -> ModuleName -> ImportDirective -> Declaration Pragma :: Range -> Pragma -> Declaration -- | only retained for highlighting purposes Open :: ModuleInfo -> ModuleName -> ImportDirective -> Declaration -- | sequence of function clauses FunDef :: DefInfo -> QName -> Delayed -> [Clause] -> Declaration -- | lone data signature DataSig :: DefInfo -> QName -> GeneralizeTelescope -> Type -> Declaration DataDef :: DefInfo -> QName -> UniverseCheck -> DataDefParams -> [Constructor] -> Declaration -- | lone record signature RecSig :: DefInfo -> QName -> GeneralizeTelescope -> Type -> Declaration -- | The Type gives the constructor type telescope, (x1 : -- A1)..(xn : An) -> Prop, and the optional name is the -- constructor's name. The optional Range' is for the -- pattern attribute. RecDef :: DefInfo -> QName -> UniverseCheck -> RecordDirectives -> DataDefParams -> Type -> [Declaration] -> Declaration -- | Only for highlighting purposes PatternSynDef :: QName -> [Arg BindName] -> Pattern' Void -> Declaration UnquoteDecl :: MutualInfo -> [DefInfo] -> [QName] -> Expr -> Declaration UnquoteDef :: [DefInfo] -> [QName] -> Expr -> Declaration UnquoteData :: [DefInfo] -> QName -> UniverseCheck -> [DefInfo] -> [QName] -> Expr -> Declaration -- | scope annotation ScopedDecl :: ScopeInfo -> [Declaration] -> Declaration type RecordDirectives = RecordDirectives' QName data ScopeCopyInfo ScopeCopyInfo :: Ren ModuleName -> Ren QName -> ScopeCopyInfo [renModules] :: ScopeCopyInfo -> Ren ModuleName [renNames] :: ScopeCopyInfo -> Ren QName -- | Renaming (generic). type Ren a = Map a (List1 a) type RecordAssigns = [RecordAssign] type RecordAssign = Either Assign ModuleName type Assigns = [Assign] -- | Record field assignment f = e. type Assign = FieldAssignment' Expr -- | Expressions after scope checking (operators parsed, names resolved). data Expr -- | Bound variable. Var :: Name -> Expr -- | Constant: axiom, function, data or record type, with a possible -- suffix. Def' :: QName -> Suffix -> Expr -- | Projection (overloaded). Proj :: ProjOrigin -> AmbiguousQName -> Expr -- | Constructor (overloaded). Con :: AmbiguousQName -> Expr -- | Pattern synonym. PatternSyn :: AmbiguousQName -> Expr -- | Macro. Macro :: QName -> Expr -- | Literal. Lit :: ExprInfo -> Literal -> Expr -- | Meta variable for interaction. The InteractionId is usually -- identical with the metaNumber of MetaInfo. However, if -- you want to print an interaction meta as just ? instead of -- ?n, you should set the metaNumber to Nothing -- while keeping the InteractionId. QuestionMark :: MetaInfo -> InteractionId -> Expr -- | Meta variable for hidden argument (must be inferred locally). Underscore :: MetaInfo -> Expr -- | .e, for postfix projection. Dot :: ExprInfo -> Expr -> Expr -- | Ordinary (binary) application. App :: AppInfo -> Expr -> NamedArg Expr -> Expr -- | With application. WithApp :: ExprInfo -> Expr -> [Expr] -> Expr -- | λ bs → e. Lam :: ExprInfo -> LamBinding -> Expr -> Expr -- | λ() or λ{}. AbsurdLam :: ExprInfo -> Hiding -> Expr ExtendedLam :: ExprInfo -> DefInfo -> Erased -> QName -> List1 Clause -> Expr -- | Dependent function space Γ → A. Pi :: ExprInfo -> Telescope1 -> Type -> Expr -- | Like a Pi, but the ordering is not known Generalized :: Set QName -> Type -> Expr -- | Non-dependent function space. Fun :: ExprInfo -> Arg Type -> Type -> Expr -- | let bs in e. Let :: ExprInfo -> List1 LetBinding -> Expr -> Expr -- | Record construction. Rec :: ExprInfo -> RecordAssigns -> Expr -- | Record update. RecUpdate :: ExprInfo -> Expr -> Assigns -> Expr -- | Scope annotation. ScopedExpr :: ScopeInfo -> Expr -> Expr -- | Quote an identifier QName. Quote :: ExprInfo -> Expr -- | Quote a term. QuoteTerm :: ExprInfo -> Expr -- | The splicing construct: unquote ... Unquote :: ExprInfo -> Expr -- | For printing DontCare from Syntax.Internal. DontCare :: Expr -> Expr -- | Types are just expressions. Use this type synonym for hinting that an -- expression should be a type. type Type = Expr type Args = [NamedArg Expr] -- | A name in a binding position: we also compare the nameConcrete when -- comparing the binders for equality. -- -- With --caching on we compare abstract syntax to determine if -- we can reuse previous typechecking results: during that comparison two -- names can have the same nameId but be semantically different, e.g. in -- {_ : A} -> .. vs. {r : A} -> ... newtype BindName BindName :: Name -> BindName [unBind] :: BindName -> Name -- | Pattern synonym for regular Def. pattern Def :: QName -> Expr mkBindName :: Name -> BindName -- | Smart constructor for Generalized. generalized :: Set QName -> Type -> Type initCopyInfo :: ScopeCopyInfo mkBinder :: a -> Binder' a mkBinder_ :: Name -> Binder extractPattern :: Binder' a -> Maybe (Pattern, a) mkDomainFree :: NamedArg Binder -> LamBinding defaultTbInfo :: TypedBindingInfo mkTBind :: Range -> List1 (NamedArg Binder) -> Type -> TypedBinding mkTLet :: Range -> [LetBinding] -> Maybe TypedBinding mkPi :: ExprInfo -> Telescope -> Type -> Type noDataDefParams :: DataDefParams noWhereDecls :: WhereDeclarations -- | The name defined by the given axiom. -- -- Precondition: The declaration has to be a (scoped) Axiom. axiomName :: Declaration -> QName app :: Expr -> [NamedArg Expr] -> Expr mkLet :: ExprInfo -> [LetBinding] -> Expr -> Expr patternToExpr :: Pattern -> Expr lambdaLiftExpr :: [Name] -> Expr -> Expr insertImplicitPatSynArgs :: HasRange a => (Range -> a) -> Range -> [Arg Name] -> [NamedArg a] -> Maybe ([(Name, a)], [Arg Name]) -- | The declaration spine corresponding to a declaration. declarationSpine :: Declaration -> DeclarationSpine -- | The clause spine corresponding to a clause. clauseSpine :: Clause -> ClauseSpine -- | The right-hand side spine corresponding to a right-hand side. rhsSpine :: RHS -> RHSSpine -- | The spine corresponding to a WhereDeclarations value. whereDeclarationsSpine :: WhereDeclarations -> WhereDeclarationsSpine instance Control.DeepSeq.NFData Agda.Syntax.Abstract.BindName instance Agda.Syntax.Position.SetRange Agda.Syntax.Abstract.BindName instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.BindName instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.BindName instance GHC.Show.Show Agda.Syntax.Abstract.BindName instance GHC.Generics.Generic Agda.Syntax.Abstract.ScopeCopyInfo instance GHC.Show.Show Agda.Syntax.Abstract.ScopeCopyInfo instance GHC.Classes.Eq Agda.Syntax.Abstract.ScopeCopyInfo instance GHC.Generics.Generic (Agda.Syntax.Abstract.Pattern' e) instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Abstract.Pattern' e) instance Data.Traversable.Traversable Agda.Syntax.Abstract.Pattern' instance Data.Foldable.Foldable Agda.Syntax.Abstract.Pattern' instance GHC.Base.Functor Agda.Syntax.Abstract.Pattern' instance GHC.Show.Show e => GHC.Show.Show (Agda.Syntax.Abstract.Pattern' e) instance GHC.Generics.Generic (Agda.Syntax.Abstract.LHSCore' e) instance GHC.Classes.Eq e => GHC.Classes.Eq (Agda.Syntax.Abstract.LHSCore' e) instance Data.Traversable.Traversable Agda.Syntax.Abstract.LHSCore' instance Data.Foldable.Foldable Agda.Syntax.Abstract.LHSCore' instance GHC.Base.Functor Agda.Syntax.Abstract.LHSCore' instance GHC.Show.Show e => GHC.Show.Show (Agda.Syntax.Abstract.LHSCore' e) instance GHC.Generics.Generic Agda.Syntax.Abstract.ProblemEq instance GHC.Show.Show Agda.Syntax.Abstract.ProblemEq instance GHC.Generics.Generic Agda.Syntax.Abstract.Pragma instance GHC.Classes.Eq Agda.Syntax.Abstract.Pragma instance GHC.Show.Show Agda.Syntax.Abstract.Pragma instance GHC.Generics.Generic Agda.Syntax.Abstract.GeneralizeTelescope instance GHC.Classes.Eq Agda.Syntax.Abstract.GeneralizeTelescope instance GHC.Show.Show Agda.Syntax.Abstract.GeneralizeTelescope instance GHC.Generics.Generic Agda.Syntax.Abstract.ModuleApplication instance GHC.Classes.Eq Agda.Syntax.Abstract.ModuleApplication instance GHC.Show.Show Agda.Syntax.Abstract.ModuleApplication instance GHC.Generics.Generic Agda.Syntax.Abstract.LetBinding instance GHC.Classes.Eq Agda.Syntax.Abstract.LetBinding instance GHC.Show.Show Agda.Syntax.Abstract.LetBinding instance GHC.Generics.Generic (Agda.Syntax.Abstract.Binder' a) instance Data.Traversable.Traversable Agda.Syntax.Abstract.Binder' instance Data.Foldable.Foldable Agda.Syntax.Abstract.Binder' instance GHC.Base.Functor Agda.Syntax.Abstract.Binder' instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Abstract.Binder' a) instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Abstract.Binder' a) instance GHC.Generics.Generic Agda.Syntax.Abstract.TypedBindingInfo instance GHC.Classes.Eq Agda.Syntax.Abstract.TypedBindingInfo instance GHC.Show.Show Agda.Syntax.Abstract.TypedBindingInfo instance GHC.Generics.Generic Agda.Syntax.Abstract.TypedBinding instance GHC.Classes.Eq Agda.Syntax.Abstract.TypedBinding instance GHC.Show.Show Agda.Syntax.Abstract.TypedBinding instance GHC.Generics.Generic Agda.Syntax.Abstract.LamBinding instance GHC.Classes.Eq Agda.Syntax.Abstract.LamBinding instance GHC.Show.Show Agda.Syntax.Abstract.LamBinding instance GHC.Generics.Generic Agda.Syntax.Abstract.DataDefParams instance GHC.Classes.Eq Agda.Syntax.Abstract.DataDefParams instance GHC.Show.Show Agda.Syntax.Abstract.DataDefParams instance GHC.Generics.Generic Agda.Syntax.Abstract.Declaration instance GHC.Show.Show Agda.Syntax.Abstract.Declaration instance GHC.Generics.Generic Agda.Syntax.Abstract.WhereDeclarations instance GHC.Classes.Eq Agda.Syntax.Abstract.WhereDeclarations instance GHC.Show.Show Agda.Syntax.Abstract.WhereDeclarations instance GHC.Generics.Generic Agda.Syntax.Abstract.RHS instance GHC.Show.Show Agda.Syntax.Abstract.RHS instance GHC.Generics.Generic (Agda.Syntax.Abstract.Clause' lhs) instance GHC.Classes.Eq lhs => GHC.Classes.Eq (Agda.Syntax.Abstract.Clause' lhs) instance Data.Traversable.Traversable Agda.Syntax.Abstract.Clause' instance Data.Foldable.Foldable Agda.Syntax.Abstract.Clause' instance GHC.Base.Functor Agda.Syntax.Abstract.Clause' instance GHC.Show.Show lhs => GHC.Show.Show (Agda.Syntax.Abstract.Clause' lhs) instance GHC.Generics.Generic Agda.Syntax.Abstract.LHS instance GHC.Show.Show Agda.Syntax.Abstract.LHS instance GHC.Generics.Generic Agda.Syntax.Abstract.Expr instance GHC.Show.Show Agda.Syntax.Abstract.Expr instance GHC.Generics.Generic Agda.Syntax.Abstract.SpineLHS instance GHC.Classes.Eq Agda.Syntax.Abstract.SpineLHS instance GHC.Show.Show Agda.Syntax.Abstract.SpineLHS instance GHC.Show.Show Agda.Syntax.Abstract.RHSSpine instance GHC.Show.Show Agda.Syntax.Abstract.ClauseSpine instance GHC.Show.Show Agda.Syntax.Abstract.DeclarationSpine instance GHC.Show.Show Agda.Syntax.Abstract.WhereDeclarationsSpine instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr (GHC.Maybe.Maybe a) instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr [a] instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr (Agda.Utils.List1.List1 a) instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Syntax.Abstract.SubstExpr a, Agda.Syntax.Abstract.SubstExpr b) => Agda.Syntax.Abstract.SubstExpr (a, b) instance (Agda.Syntax.Abstract.SubstExpr a, Agda.Syntax.Abstract.SubstExpr b) => Agda.Syntax.Abstract.SubstExpr (Data.Either.Either a b) instance Agda.Syntax.Abstract.SubstExpr Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Abstract.SubstExpr Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Abstract.SubstExpr Agda.Syntax.Abstract.Expr instance Agda.Syntax.Abstract.NameToExpr Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Abstract.NameToExpr Agda.Syntax.Scope.Base.ResolvedName instance Agda.Syntax.Abstract.AnyAbstract a => Agda.Syntax.Abstract.AnyAbstract [a] instance Agda.Syntax.Abstract.AnyAbstract Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.SpineLHS instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.SpineLHS instance Control.DeepSeq.NFData Agda.Syntax.Abstract.SpineLHS instance GHC.Classes.Eq Agda.Syntax.Abstract.ProblemEq instance Agda.Utils.Null.Null Agda.Syntax.Abstract.WhereDeclarations instance GHC.Classes.Eq Agda.Syntax.Abstract.RHS instance GHC.Classes.Eq Agda.Syntax.Abstract.LHS instance Agda.Syntax.Abstract.Name.IsProjP Agda.Syntax.Abstract.Expr instance GHC.Classes.Eq Agda.Syntax.Abstract.Expr instance GHC.Classes.Eq Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Common.Underscore Agda.Syntax.Abstract.Expr instance Agda.Syntax.Common.LensHiding Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Common.LensHiding Agda.Syntax.Abstract.TypedBinding instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Abstract.Binder' a) instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.TypedBinding instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Expr instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.LHS instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Abstract.Clause' a) instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.RHS instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.WhereDeclarations instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.LetBinding instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Abstract.Binder' a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.GeneralizeTelescope instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.DataDefParams instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.TypedBindingInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.TypedBinding instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Expr instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.ModuleApplication instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.LHS instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Abstract.Clause' a) instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.ProblemEq instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.RHS instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.WhereDeclarations instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.LetBinding instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Expr instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Declaration instance Control.DeepSeq.NFData Agda.Syntax.Abstract.ModuleApplication instance Control.DeepSeq.NFData Agda.Syntax.Abstract.Pragma instance Control.DeepSeq.NFData Agda.Syntax.Abstract.LetBinding instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Abstract.Binder' a) instance Control.DeepSeq.NFData Agda.Syntax.Abstract.LamBinding instance Control.DeepSeq.NFData Agda.Syntax.Abstract.TypedBinding instance Control.DeepSeq.NFData Agda.Syntax.Abstract.TypedBindingInfo instance Control.DeepSeq.NFData Agda.Syntax.Abstract.GeneralizeTelescope instance Control.DeepSeq.NFData Agda.Syntax.Abstract.DataDefParams instance Control.DeepSeq.NFData Agda.Syntax.Abstract.ProblemEq instance Control.DeepSeq.NFData lhs => Control.DeepSeq.NFData (Agda.Syntax.Abstract.Clause' lhs) instance Control.DeepSeq.NFData Agda.Syntax.Abstract.WhereDeclarations instance Control.DeepSeq.NFData Agda.Syntax.Abstract.RHS instance Control.DeepSeq.NFData Agda.Syntax.Abstract.LHS instance Agda.Syntax.Position.HasRange (Agda.Syntax.Abstract.LHSCore' e) instance Agda.Syntax.Position.KillRange e => Agda.Syntax.Position.KillRange (Agda.Syntax.Abstract.LHSCore' e) instance Control.DeepSeq.NFData e => Control.DeepSeq.NFData (Agda.Syntax.Abstract.LHSCore' e) instance Agda.Syntax.Abstract.Name.IsProjP (Agda.Syntax.Abstract.Pattern' e) instance Agda.Syntax.Position.HasRange (Agda.Syntax.Abstract.Pattern' e) instance Agda.Syntax.Position.SetRange (Agda.Syntax.Abstract.Pattern' a) instance Agda.Syntax.Position.KillRange e => Agda.Syntax.Position.KillRange (Agda.Syntax.Abstract.Pattern' e) instance Control.DeepSeq.NFData e => Control.DeepSeq.NFData (Agda.Syntax.Abstract.Pattern' e) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.ScopeCopyInfo instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.ScopeCopyInfo instance Control.DeepSeq.NFData Agda.Syntax.Abstract.ScopeCopyInfo instance GHC.Classes.Eq Agda.Syntax.Abstract.BindName instance GHC.Classes.Ord Agda.Syntax.Abstract.BindName instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.Name.Suffix module Agda.Syntax.Abstract.Views data AppView' arg Application :: Expr -> [NamedArg arg] -> AppView' arg type AppView = AppView' Expr -- | Gather applications to expose head and spine. -- -- Note: everything is an application, possibly of itself to 0 arguments appView :: Expr -> AppView appView' :: Expr -> AppView' (AppInfo, Expr) maybeProjTurnPostfix :: Expr -> Maybe Expr unAppView :: AppView -> Expr -- | Collects plain lambdas. data LamView LamView :: [LamBinding] -> Expr -> LamView lamView :: Expr -> LamView -- | Collect A.Pis. data PiView PiView :: [(ExprInfo, Telescope1)] -> Type -> PiView piView :: Expr -> PiView unPiView :: PiView -> Expr -- | Gather top-level AsPatterns and AnnPatterns to expose -- underlying pattern. asView :: Pattern -> ([Name], [Expr], Pattern) -- | Remove top ScopedExpr wrappers. unScope :: Expr -> Expr -- | Remove ScopedExpr wrappers everywhere. -- -- NB: Unless the implementation of ExprLike for clauses has been -- finished, this does not work for clauses yet. deepUnscope :: ExprLike a => a -> a deepUnscopeDecls :: [Declaration] -> [Declaration] deepUnscopeDecl :: Declaration -> [Declaration] type RecurseExprFn m a = Applicative m => (Expr -> m Expr -> m Expr) -> a -> m a type RecurseExprRecFn m = forall a. ExprLike a => a -> m a type FoldExprFn m a = Monoid m => (Expr -> m) -> a -> m type FoldExprRecFn m = forall a. ExprLike a => a -> m type TraverseExprFn m a = (Applicative m, Monad m) => (Expr -> m Expr) -> a -> m a type TraverseExprRecFn m = forall a. ExprLike a => a -> m a -- | Apply an expression rewriting to every subexpression, inside-out. See -- Agda.Syntax.Internal.Generic. class ExprLike a -- | The first expression is pre-traversal, the second one post-traversal. recurseExpr :: ExprLike a => RecurseExprFn m a -- | The first expression is pre-traversal, the second one post-traversal. recurseExpr :: (ExprLike a, Traversable f, ExprLike a', a ~ f a', Applicative m) => (Expr -> m Expr -> m Expr) -> a -> m a foldExpr :: ExprLike a => FoldExprFn m a traverseExpr :: ExprLike a => TraverseExprFn m a mapExpr :: ExprLike a => (Expr -> Expr) -> a -> a type KName = WithKind QName -- | Extracts "all" names which are declared in a Declaration. -- -- Includes: local modules and where clauses. Excludes: open -- public, let, with function names, extended -- lambdas. class DeclaredNames a declaredNames :: (DeclaredNames a, Collection KName m) => a -> m declaredNames :: (DeclaredNames a, Foldable t, DeclaredNames b, t b ~ a) => Collection KName m => a -> m instance GHC.Base.Functor Agda.Syntax.Abstract.Views.AppView' instance Agda.Syntax.Abstract.Views.DeclaredNames a => Agda.Syntax.Abstract.Views.DeclaredNames [a] instance Agda.Syntax.Abstract.Views.DeclaredNames a => Agda.Syntax.Abstract.Views.DeclaredNames (Agda.Utils.List1.List1 a) instance Agda.Syntax.Abstract.Views.DeclaredNames a => Agda.Syntax.Abstract.Views.DeclaredNames (GHC.Maybe.Maybe a) instance Agda.Syntax.Abstract.Views.DeclaredNames a => Agda.Syntax.Abstract.Views.DeclaredNames (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Abstract.Views.DeclaredNames a => Agda.Syntax.Abstract.Views.DeclaredNames (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Abstract.Views.DeclaredNames a => Agda.Syntax.Abstract.Views.DeclaredNames (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Syntax.Abstract.Views.DeclaredNames a, Agda.Syntax.Abstract.Views.DeclaredNames b) => Agda.Syntax.Abstract.Views.DeclaredNames (Data.Either.Either a b) instance (Agda.Syntax.Abstract.Views.DeclaredNames a, Agda.Syntax.Abstract.Views.DeclaredNames b) => Agda.Syntax.Abstract.Views.DeclaredNames (a, b) instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.Views.KName instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.RecordDirectives instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.Pragma instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.Clause instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.WhereDeclarations instance Agda.Syntax.Abstract.Views.DeclaredNames Agda.Syntax.Abstract.RHS instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Expr instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.LetBinding instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Abstract.Clause' a) instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.RHS instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.ModuleApplication instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Pragma instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (GHC.Maybe.Maybe a) instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Common.Named x a) instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike [a] instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Utils.List1.List1 a) instance (Agda.Syntax.Abstract.Views.ExprLike a, Agda.Syntax.Abstract.Views.ExprLike b) => Agda.Syntax.Abstract.Views.ExprLike (a, b) instance Agda.Syntax.Abstract.Views.ExprLike Data.Void.Void instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Syntax.Abstract.Views.ExprLike a, Agda.Syntax.Abstract.Views.ExprLike b) => Agda.Syntax.Abstract.Views.ExprLike (Data.Either.Either a b) instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.BindName instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.GeneralizeTelescope instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.DataDefParams instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.TypedBindingInfo instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.TypedBinding instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Abstract.Pattern' a) instance (Agda.Syntax.Abstract.Views.ExprLike qn, Agda.Syntax.Abstract.Views.ExprLike nm, Agda.Syntax.Abstract.Views.ExprLike p, Agda.Syntax.Abstract.Views.ExprLike e) => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Common.RewriteEqn' qn nm p e) instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.WhereDeclarations instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.LHS instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Abstract.LHSCore' a) instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Common.WithHiding a) instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.SpineLHS -- | Pattern synonym utilities: folding pattern synonym definitions for -- printing and merging pattern synonym definitions to handle overloaded -- pattern synonyms. module Agda.Syntax.Abstract.PatternSynonyms -- | Match an expression against a pattern synonym. matchPatternSyn :: PatternSynDefn -> Expr -> Maybe [Arg Expr] -- | Match a pattern against a pattern synonym. matchPatternSynP :: PatternSynDefn -> Pattern' e -> Maybe [Arg (Pattern' e)] -- | Merge a list of pattern synonym definitions. Fails unless all -- definitions have the same shape (i.e. equal up to renaming of -- variables and constructor names). mergePatternSynDefs :: List1 PatternSynDefn -> Maybe PatternSynDefn -- | Auxiliary functions to handle patterns in the abstract syntax. -- -- Generic and specific traversals. module Agda.Syntax.Abstract.Pattern type NAP = NamedArg Pattern class MapNamedArgPattern a mapNamedArgPattern :: MapNamedArgPattern a => (NAP -> NAP) -> a -> a mapNamedArgPattern :: (MapNamedArgPattern a, Functor f, MapNamedArgPattern a', a ~ f a') => (NAP -> NAP) -> a -> a -- | Generic pattern traversal. class APatternLike p where { type ADotT p; } -- | Fold pattern. foldrAPattern :: (APatternLike p, Monoid m) => (Pattern' (ADotT p) -> m -> m) -> p -> m -- | Fold pattern. foldrAPattern :: (APatternLike p, Monoid m, Foldable f, APatternLike b, ADotT p ~ ADotT b, f b ~ p) => (Pattern' (ADotT p) -> m -> m) -> p -> m -- | Traverse pattern. traverseAPatternM :: (APatternLike p, Monad m) => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -> (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -> p -> m p -- | Traverse pattern. traverseAPatternM :: (APatternLike p, Traversable f, APatternLike q, ADotT p ~ ADotT q, f q ~ p, Monad m) => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -> (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -> p -> m p -- | Compute from each subpattern a value and collect them all in a monoid. foldAPattern :: (APatternLike p, Monoid m) => (Pattern' (ADotT p) -> m) -> p -> m -- | Traverse pattern(s) with a modification before the recursive descent. preTraverseAPatternM :: (APatternLike p, Monad m) => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -> p -> m p -- | Traverse pattern(s) with a modification after the recursive descent. postTraverseAPatternM :: (APatternLike p, Monad m) => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -> p -> m p -- | Map pattern(s) with a modification after the recursive descent. mapAPattern :: APatternLike p => (Pattern' (ADotT p) -> Pattern' (ADotT p)) -> p -> p -- | Collect pattern variables in left-to-right textual order. patternVars :: APatternLike p => p -> [Name] -- | Check if a pattern contains a specific (sub)pattern. containsAPattern :: APatternLike p => (Pattern' (ADotT p) -> Bool) -> p -> Bool -- | Check if a pattern contains an absurd pattern. For instance, suc -- (), does so. -- -- Precondition: contains no pattern synonyms. containsAbsurdPattern :: APatternLike p => p -> Bool -- | Check if a pattern contains an @-pattern. containsAsPattern :: APatternLike p => p -> Bool -- | Check if any user-written pattern variables occur more than once, and -- throw the given error if they do. checkPatternLinearity :: (Monad m, APatternLike p) => p -> ([Name] -> m ()) -> m () -- | Pattern substitution. -- -- For the embedded expression, the given pattern substitution is turned -- into an expression substitution. substPattern :: [(Name, Pattern)] -> Pattern -> Pattern -- | Pattern substitution, parametrized by substitution function for -- embedded expressions. substPattern' :: (e -> e) -> [(Name, Pattern' e)] -> Pattern' e -> Pattern' e -- | Split patterns into (patterns, trailing with-patterns). splitOffTrailingWithPatterns :: Patterns -> (Patterns, Patterns) -- | Get the tail of with-patterns of a pattern spine. trailingWithPatterns :: Patterns -> Patterns -- | The next patterns are ... -- -- (This view discards PatInfo.) data LHSPatternView e -- | Application patterns (non-empty list). LHSAppP :: NAPs e -> LHSPatternView e -- | A projection pattern. Is also stored unmodified here. LHSProjP :: ProjOrigin -> AmbiguousQName -> NamedArg (Pattern' e) -> LHSPatternView e -- | With patterns (non-empty list). These patterns are not prefixed with -- WithP. LHSWithP :: [Pattern' e] -> LHSPatternView e -- | Construct the LHSPatternView of the given list (if not empty). -- -- Return the view and the remaining patterns. lhsPatternView :: IsProjP e => NAPs e -> Maybe (LHSPatternView e, NAPs e) -- | Convert a focused lhs to spine view and back. class LHSToSpine a b lhsToSpine :: LHSToSpine a b => a -> b spineToLhs :: LHSToSpine a b => b -> a lhsCoreToSpine :: LHSCore' e -> QNamed [NamedArg (Pattern' e)] spineToLhsCore :: IsProjP e => QNamed [NamedArg (Pattern' e)] -> LHSCore' e -- | Add applicative patterns (non-projection / non-with patterns) to the -- right. lhsCoreApp :: LHSCore' e -> [NamedArg (Pattern' e)] -> LHSCore' e -- | Add with-patterns to the right. lhsCoreWith :: LHSCore' e -> [Arg (Pattern' e)] -> LHSCore' e lhsCoreAddChunk :: IsProjP e => LHSCore' e -> LHSPatternView e -> LHSCore' e -- | Add projection, with, and applicative patterns to the right. lhsCoreAddSpine :: IsProjP e => LHSCore' e -> [NamedArg (Pattern' e)] -> LHSCore' e -- | Used for checking pattern linearity. lhsCoreAllPatterns :: LHSCore' e -> [Pattern' e] -- | Used in 'AbstractToConcrete'. Returns a DefP. lhsCoreToPattern :: LHSCore -> Pattern mapLHSHead :: (QName -> [NamedArg Pattern] -> LHSCore) -> LHSCore -> LHSCore instance GHC.Show.Show e => GHC.Show.Show (Agda.Syntax.Abstract.Pattern.LHSPatternView e) instance Agda.Syntax.Abstract.Pattern.LHSToSpine Agda.Syntax.Abstract.Clause Agda.Syntax.Abstract.SpineClause instance Agda.Syntax.Abstract.Pattern.LHSToSpine a b => Agda.Syntax.Abstract.Pattern.LHSToSpine [a] [b] instance Agda.Syntax.Abstract.Pattern.LHSToSpine Agda.Syntax.Abstract.LHS Agda.Syntax.Abstract.SpineLHS instance Agda.Syntax.Abstract.Pattern.APatternLike (Agda.Syntax.Abstract.Pattern' a) instance Agda.Syntax.Abstract.Pattern.APatternLike a => Agda.Syntax.Abstract.Pattern.APatternLike (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Abstract.Pattern.APatternLike a => Agda.Syntax.Abstract.Pattern.APatternLike (Agda.Syntax.Common.Named n a) instance Agda.Syntax.Abstract.Pattern.APatternLike a => Agda.Syntax.Abstract.Pattern.APatternLike [a] instance Agda.Syntax.Abstract.Pattern.APatternLike a => Agda.Syntax.Abstract.Pattern.APatternLike (GHC.Maybe.Maybe a) instance Agda.Syntax.Abstract.Pattern.APatternLike a => Agda.Syntax.Abstract.Pattern.APatternLike (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Syntax.Abstract.Pattern.APatternLike a, Agda.Syntax.Abstract.Pattern.APatternLike b, Agda.Syntax.Abstract.Pattern.ADotT a GHC.Types.~ Agda.Syntax.Abstract.Pattern.ADotT b) => Agda.Syntax.Abstract.Pattern.APatternLike (a, b) instance Agda.Syntax.Abstract.Pattern.MapNamedArgPattern Agda.Syntax.Abstract.Pattern.NAP instance Agda.Syntax.Abstract.Pattern.MapNamedArgPattern a => Agda.Syntax.Abstract.Pattern.MapNamedArgPattern [a] instance Agda.Syntax.Abstract.Pattern.MapNamedArgPattern a => Agda.Syntax.Abstract.Pattern.MapNamedArgPattern (Agda.Syntax.Concrete.FieldAssignment' a) instance Agda.Syntax.Abstract.Pattern.MapNamedArgPattern a => Agda.Syntax.Abstract.Pattern.MapNamedArgPattern (GHC.Maybe.Maybe a) instance (Agda.Syntax.Abstract.Pattern.MapNamedArgPattern a, Agda.Syntax.Abstract.Pattern.MapNamedArgPattern b) => Agda.Syntax.Abstract.Pattern.MapNamedArgPattern (a, b) instance Agda.Syntax.Concrete.Pattern.IsWithP (Agda.Syntax.Abstract.Pattern' e) module Agda.Utils.TypeLevel -- | All p as ensures that the constraint p is satisfied -- by all the types in as. (Types is between -- scare-quotes here because the code is actually kind polymorphic) type family All (p :: k -> Constraint) (as :: [k]) :: Constraint -- | On Booleans type family If (b :: Bool) (l :: k) (r :: k) :: k -- | On Lists type family Foldr (c :: k -> l -> l) (n :: l) (as :: [k]) :: l -- | Version of Foldr taking a defunctionalised argument so that -- we can use partially applied functions. type family Foldr' (c :: Function k (Function l l -> Type) -> Type) (n :: l) (as :: [k]) :: l type family Map (f :: Function k l -> Type) (as :: [k]) :: [l] data ConsMap0 :: (Function k l -> Type) -> Function k (Function [l] [l] -> Type) -> Type data ConsMap1 :: (Function k l -> Type) -> k -> Function [l] [l] -> Type type family Constant (b :: l) (as :: [k]) :: [l] -- | Arrows [a1,..,an] r corresponds to a1 -> .. -> an -- -> r | Products [a1,..,an] corresponds to (a1, -- (..,( an, ())..)) type Arrows (as :: [Type]) (r :: Type) = Foldr (->) r as type Products (as :: [Type]) = Foldr (,) () as -- | IsBase t is 'True whenever t is *not* a -- function space. type family IsBase (t :: Type) :: Bool -- | Using IsBase we can define notions of Domains and -- CoDomains which *reduce* under positive information -- IsBase t ~ 'True even though the shape of t is not -- formally exposed type family Domains (t :: Type) :: [Type] type family Domains' (t :: Type) :: [Type] type family CoDomain (t :: Type) :: Type type family CoDomain' (t :: Type) :: Type -- | Currying as b witnesses the isomorphism between Arrows as -- b and Products as -> b. It is defined as a type class -- rather than by recursion on a singleton for as so all of that -- these conversions are inlined at compile time for concrete arguments. class Currying as b uncurrys :: Currying as b => Proxy as -> Proxy b -> Arrows as b -> Products as -> b currys :: Currying as b => Proxy as -> Proxy b -> (Products as -> b) -> Arrows as b data Function :: Type -> Type -> Type data Constant0 :: Function a (Function b a -> Type) -> Type data Constant1 :: Type -> Function b a -> Type type family Apply (t :: Function k l -> Type) (u :: k) :: l instance Agda.Utils.TypeLevel.Currying '[] b instance Agda.Utils.TypeLevel.Currying as b => Agda.Utils.TypeLevel.Currying (a : as) b -- | Type level literals, inspired by GHC.TypeLits. module Agda.Utils.TypeLits -- | Singleton for type level booleans. data SBool (b :: Bool) [STrue] :: SBool 'True [SFalse] :: SBool 'False eraseSBool :: SBool b -> Bool -- | A known boolean is one we can obtain a singleton for. Concrete values -- are trivially known. class KnownBool (b :: Bool) boolSing :: KnownBool b => SBool b boolVal :: forall proxy b. KnownBool b => proxy b -> Bool instance Agda.Utils.TypeLits.KnownBool 'GHC.Types.True instance Agda.Utils.TypeLits.KnownBool 'GHC.Types.False module Agda.Utils.Update -- | The ChangeT monad transformer. data ChangeT m a -- | Run a ChangeT computation, returning result plus change flag. runChangeT :: Functor m => ChangeT m a -> m (a, Bool) -- | Map a ChangeT computation (monad transformer action). mapChangeT :: (m (a, Any) -> n (b, Any)) -> ChangeT m a -> ChangeT n b type UpdaterT m a = a -> ChangeT m a -- | Blindly run an updater. runUpdaterT :: Functor m => UpdaterT m a -> a -> m (a, Bool) type Change a = ChangeT Identity a -- | The class of change monads. class Monad m => MonadChange m tellDirty :: MonadChange m => m () listenDirty :: MonadChange m => m a -> m (a, Bool) -- | Run a Change computation, returning result plus change flag. runChange :: Change a -> (a, Bool) type Updater a = UpdaterT Identity a -- | Replace result of updating with original input if nothing has changed. sharing :: Monad m => UpdaterT m a -> UpdaterT m a -- | Blindly run an updater. runUpdater :: Updater a -> a -> (a, Bool) -- | Mark a computation as dirty. dirty :: Monad m => UpdaterT m a ifDirty :: (Monad m, MonadChange m) => m a -> (a -> m b) -> (a -> m b) -> m b -- | Like Functor, but preserving sharing. class Traversable f => Updater1 f updater1 :: Updater1 f => Updater a -> Updater (f a) updates1 :: Updater1 f => Updater a -> Updater (f a) update1 :: Updater1 f => Updater a -> EndoFun (f a) -- | Like Bifunctor, but preserving sharing. class Updater2 f updater2 :: Updater2 f => Updater a -> Updater b -> Updater (f a b) updates2 :: Updater2 f => Updater a -> Updater b -> Updater (f a b) update2 :: Updater2 f => Updater a -> Updater b -> EndoFun (f a b) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Agda.Utils.Update.ChangeT m) instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Agda.Utils.Update.ChangeT m) instance Control.Monad.Trans.Class.MonadTrans Agda.Utils.Update.ChangeT instance GHC.Base.Monad m => GHC.Base.Monad (Agda.Utils.Update.ChangeT m) instance GHC.Base.Applicative m => GHC.Base.Applicative (Agda.Utils.Update.ChangeT m) instance GHC.Base.Functor m => GHC.Base.Functor (Agda.Utils.Update.ChangeT m) instance Agda.Utils.Update.Updater2 (,) instance Agda.Utils.Update.Updater2 Data.Either.Either instance Agda.Utils.Update.Updater1 GHC.Maybe.Maybe instance Agda.Utils.Update.Updater1 [] instance Control.Monad.Trans.Control.MonadTransControl Agda.Utils.Update.ChangeT instance GHC.Base.Monad m => Agda.Utils.Update.MonadChange (Agda.Utils.Update.ChangeT m) instance Agda.Utils.Update.MonadChange Data.Functor.Identity.Identity instance GHC.Base.Monad m => Agda.Utils.Update.MonadChange (Control.Monad.Trans.Identity.IdentityT m) -- | Preprocess Declarations, producing NiceDeclarations. -- -- module Agda.Syntax.Concrete.Definitions -- | The nice declarations. No fixity declarations and function definitions -- are contained in a single constructor instead of spread out between -- type signatures and clauses. The private, postulate, -- abstract and instance modifiers have been -- distributed to the individual declarations. -- -- Observe the order of components: -- -- Range Fixity' Access IsAbstract IsInstance TerminationCheck -- PositivityCheck -- -- further attributes -- -- (Q)Name -- -- content (Expr, Declaration ...) data NiceDeclaration -- | IsAbstract argument: We record whether a declaration was made -- in an abstract block. -- -- ArgInfo argument: Axioms and functions can be declared -- irrelevant. (Hiding should be NotHidden.) Axiom :: Range -> Access -> IsAbstract -> IsInstance -> ArgInfo -> Name -> Expr -> NiceDeclaration NiceField :: Range -> Access -> IsAbstract -> IsInstance -> TacticAttribute -> Name -> Arg Expr -> NiceDeclaration PrimitiveFunction :: Range -> Access -> IsAbstract -> Name -> Arg Expr -> NiceDeclaration NiceMutual :: Range -> TerminationCheck -> CoverageCheck -> PositivityCheck -> [NiceDeclaration] -> NiceDeclaration NiceModule :: Range -> Access -> IsAbstract -> QName -> Telescope -> [Declaration] -> NiceDeclaration NiceModuleMacro :: Range -> Access -> Name -> ModuleApplication -> OpenShortHand -> ImportDirective -> NiceDeclaration NiceOpen :: Range -> QName -> ImportDirective -> NiceDeclaration NiceImport :: Range -> QName -> Maybe AsName -> OpenShortHand -> ImportDirective -> NiceDeclaration NicePragma :: Range -> Pragma -> NiceDeclaration NiceRecSig :: Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> Expr -> NiceDeclaration NiceDataSig :: Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> Expr -> NiceDeclaration -- | An uncategorized function clause, could be a function clause without -- type signature or a pattern lhs (e.g. for irrefutable let). The -- Declaration is the actual FunClause. NiceFunClause :: Range -> Access -> IsAbstract -> TerminationCheck -> CoverageCheck -> Catchall -> Declaration -> NiceDeclaration FunSig :: Range -> Access -> IsAbstract -> IsInstance -> IsMacro -> ArgInfo -> TerminationCheck -> CoverageCheck -> Name -> Expr -> NiceDeclaration -- | Block of function clauses (we have seen the type signature before). -- The Declarations are the original declarations that were -- processed into this FunDef and are only used in -- notSoNiceDeclaration. Andreas, 2017-01-01: Because of issue -- #2372, we add IsInstance here. An alias should know that it is -- an instance. FunDef :: Range -> [Declaration] -> IsAbstract -> IsInstance -> TerminationCheck -> CoverageCheck -> Name -> [Clause] -> NiceDeclaration NiceDataDef :: Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> [NiceConstructor] -> NiceDeclaration NiceLoneConstructor :: Range -> [NiceConstructor] -> NiceDeclaration -- | (Maybe Range) gives range of the 'pattern' declaration. NiceRecDef :: Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> RecordDirectives -> [LamBinding] -> [Declaration] -> NiceDeclaration NicePatternSyn :: Range -> Access -> Name -> [Arg Name] -> Pattern -> NiceDeclaration NiceGeneralize :: Range -> Access -> ArgInfo -> TacticAttribute -> Name -> Expr -> NiceDeclaration NiceUnquoteDecl :: Range -> Access -> IsAbstract -> IsInstance -> TerminationCheck -> CoverageCheck -> [Name] -> Expr -> NiceDeclaration NiceUnquoteDef :: Range -> Access -> IsAbstract -> TerminationCheck -> CoverageCheck -> [Name] -> Expr -> NiceDeclaration NiceUnquoteData :: Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [Name] -> Expr -> NiceDeclaration -- | Only Axioms. type NiceConstructor = NiceTypeSignature -- | Only Axioms. type NiceTypeSignature = NiceDeclaration -- | One clause in a function definition. There is no guarantee that the -- LHS actually declares the Name. We will have to check -- that later. data Clause Clause :: Name -> Catchall -> LHS -> RHS -> WhereClause -> [Clause] -> Clause -- | Exception with internal source code callstack data DeclarationException DeclarationException :: CallStack -> DeclarationException' -> DeclarationException [deLocation] :: DeclarationException -> CallStack [deException] :: DeclarationException -> DeclarationException' data DeclarationWarning DeclarationWarning :: CallStack -> DeclarationWarning' -> DeclarationWarning [dwLocation] :: DeclarationWarning -> CallStack [dwWarning] :: DeclarationWarning -> DeclarationWarning' -- | Non-fatal errors encountered in the Nicifier. data DeclarationWarning' -- | Empty abstract block. EmptyAbstract :: Range -> DeclarationWarning' -- | Empty constructor block. EmptyConstructor :: Range -> DeclarationWarning' -- | Empty field block. EmptyField :: Range -> DeclarationWarning' -- | Empty variable block. EmptyGeneralize :: Range -> DeclarationWarning' -- | Empty instance block EmptyInstance :: Range -> DeclarationWarning' -- | Empty macro block. EmptyMacro :: Range -> DeclarationWarning' -- | Empty mutual block. EmptyMutual :: Range -> DeclarationWarning' -- | Empty postulate block. EmptyPostulate :: Range -> DeclarationWarning' -- | Empty private block. EmptyPrivate :: Range -> DeclarationWarning' -- | Empty primitive block. EmptyPrimitive :: Range -> DeclarationWarning' -- | A Hidden identifier in a variable declaration. -- Hiding has no effect there as generalized variables are always hidden -- (or instance variables). HiddenGeneralize :: Range -> DeclarationWarning' -- | A {-# CATCHALL #-} pragma that does not precede a function clause. InvalidCatchallPragma :: Range -> DeclarationWarning' -- | Invalid definition in a constructor block InvalidConstructor :: Range -> DeclarationWarning' -- | Invalid constructor block (not inside an interleaved mutual block) InvalidConstructorBlock :: Range -> DeclarationWarning' -- | A {-# NON_COVERING #-} pragma that does not apply to any function. InvalidCoverageCheckPragma :: Range -> DeclarationWarning' -- | A {-# NO_POSITIVITY_CHECK #-} pragma that does not apply to any data -- or record type. InvalidNoPositivityCheckPragma :: Range -> DeclarationWarning' -- | A {-# NO_UNIVERSE_CHECK #-} pragma that does not apply to a data or -- record type. InvalidNoUniverseCheckPragma :: Range -> DeclarationWarning' -- | A record directive outside of a record / below existing fields. InvalidRecordDirective :: Range -> DeclarationWarning' -- | A {-# TERMINATING #-} and {-# NON_TERMINATING #-} pragma that does not -- apply to any function. InvalidTerminationCheckPragma :: Range -> DeclarationWarning' -- | Definitions (e.g. constructors or functions) without a declaration. MissingDeclarations :: [(Name, Range)] -> DeclarationWarning' -- | Declarations (e.g. type signatures) without a definition. MissingDefinitions :: [(Name, Range)] -> DeclarationWarning' NotAllowedInMutual :: Range -> String -> DeclarationWarning' -- | private has no effect on open public. (But the user -- might think so.) OpenPublicPrivate :: Range -> DeclarationWarning' -- | abstract has no effect on open public. (But the user -- might think so.) OpenPublicAbstract :: Range -> DeclarationWarning' PolarityPragmasButNotPostulates :: [Name] -> DeclarationWarning' -- | Pragma {-# NO_TERMINATION_CHECK #-} has been replaced by -- {-# TERMINATING #-} and {-# NON_TERMINATING #-}. PragmaNoTerminationCheck :: Range -> DeclarationWarning' -- | COMPILE pragmas are not allowed in safe mode PragmaCompiled :: Range -> DeclarationWarning' ShadowingInTelescope :: List1 (Name, List2 Range) -> DeclarationWarning' UnknownFixityInMixfixDecl :: [Name] -> DeclarationWarning' UnknownNamesInFixityDecl :: [Name] -> DeclarationWarning' UnknownNamesInPolarityPragmas :: [Name] -> DeclarationWarning' -- | abstract block with nothing that can (newly) be made -- abstract. UselessAbstract :: Range -> DeclarationWarning' -- | instance block with nothing that can (newly) become an -- instance. UselessInstance :: Range -> DeclarationWarning' -- | private block with nothing that can (newly) be made private. UselessPrivate :: Range -> DeclarationWarning' -- | Nicifier warnings turned into errors in --safe mode. unsafeDeclarationWarning :: DeclarationWarning -> Bool -- | Nicifier monad. Preserve the state when throwing an exception. data Nice a -- | Run a Nicifier computation, return result and warnings (in -- chronological order). runNice :: Nice a -> (Either DeclarationException a, NiceWarnings) -- | Main. Fixities (or more precisely syntax declarations) are needed when -- grouping function clauses. niceDeclarations :: Fixities -> [Declaration] -> Nice [NiceDeclaration] -- | (Approximately) convert a NiceDeclaration back to a list of -- Declarations. notSoNiceDeclarations :: NiceDeclaration -> [Declaration] -- | Has the NiceDeclaration a field of type IsAbstract? niceHasAbstract :: NiceDeclaration -> Maybe IsAbstract -- | Termination measure is, for now, a variable name. type Measure = Name declarationWarningName :: DeclarationWarning -> WarningName instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.DeclKind instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.DeclKind instance Agda.Syntax.Concrete.Definitions.MakePrivate a => Agda.Syntax.Concrete.Definitions.MakePrivate [a] instance Agda.Syntax.Concrete.Definitions.MakePrivate Agda.Syntax.Common.Access instance Agda.Syntax.Concrete.Definitions.MakePrivate Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance Agda.Syntax.Concrete.Definitions.MakePrivate Agda.Syntax.Concrete.Definitions.Types.Clause instance Agda.Syntax.Concrete.Definitions.MakePrivate Agda.Syntax.Concrete.WhereClause instance Agda.Syntax.Concrete.Definitions.MakeAbstract a => Agda.Syntax.Concrete.Definitions.MakeAbstract [a] instance Agda.Syntax.Concrete.Definitions.MakeAbstract Agda.Syntax.Common.IsAbstract instance Agda.Syntax.Concrete.Definitions.MakeAbstract Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance Agda.Syntax.Concrete.Definitions.MakeAbstract Agda.Syntax.Concrete.Definitions.Types.Clause instance Agda.Syntax.Concrete.Definitions.MakeAbstract Agda.Syntax.Concrete.WhereClause -- | Var field implementation of sets of (small) natural numbers. module Agda.Utils.VarSet type VarSet = IntSet -- | O(n+m). The union of two sets. union :: IntSet -> IntSet -> IntSet -- | The union of a list of sets. unions :: Foldable f => f IntSet -> IntSet -- | O(min(n,W)). Is the value a member of the set? member :: Key -> IntSet -> Bool -- | O(1). The empty set. empty :: IntSet -- | O(min(n,W)). Delete a value in the set. Returns the original -- set when the value was not present. delete :: Key -> IntSet -> IntSet -- | O(1). A set of one element. singleton :: Key -> IntSet -- | O(n*min(n,W)). Create a set from a list of integers. fromList :: [Key] -> IntSet -- | O(n). Convert the set to a list of elements. Subject to list -- fusion. toList :: IntSet -> [Key] -- | O(n). Convert the set to a descending list of elements. Subject -- to list fusion. toDescList :: IntSet -> [Key] -- | O(n+m). Is this a subset? (s1 `isSubsetOf` s2) tells -- whether s1 is a subset of s2. isSubsetOf :: IntSet -> IntSet -> Bool -- | O(1). Is the set empty? null :: IntSet -> Bool -- | O(n+m). The intersection of two sets. intersection :: IntSet -> IntSet -> IntSet -- | O(n+m). Difference between two sets. difference :: IntSet -> IntSet -> IntSet subtract :: Int -> VarSet -> VarSet -- | Construct a graph from constraints x + n y becomes x -- ---(-n)--- y x n + y becomes x ---(+n)--- y the -- default edge (= no edge) is labelled with infinity. -- -- Building the graph involves keeping track of the node names. We do -- this in a finite map, assigning consecutive numbers to nodes. module Agda.Utils.Warshall type Matrix a = Array (Int, Int) a warshall :: SemiRing a => Matrix a -> Matrix a type AdjList node edge = Map node [(node, edge)] -- | Warshall's algorithm on a graph represented as an adjacency list. warshallG :: (SemiRing edge, Ord node) => AdjList node edge -> AdjList node edge -- | Edge weight in the graph, forming a semi ring. data Weight Finite :: Int -> Weight Infinite :: Weight inc :: Weight -> Int -> Weight -- | Nodes of the graph are either - flexible variables (with identifiers -- drawn from Int), - rigid variables (also identified by -- Ints), or - constants (like 0, infinity, or anything -- between). data Node Rigid :: Rigid -> Node Flex :: FlexId -> Node data Rigid RConst :: Weight -> Rigid RVar :: RigidId -> Rigid type NodeId = Int type RigidId = Int type FlexId = Int -- | Which rigid variables a flex may be instatiated to. type Scope = RigidId -> Bool infinite :: Rigid -> Bool -- | isBelow r w r' checks, if r and r' are -- connected by w (meaning w not infinite), whether -- r + w <= r'. Precondition: not the same rigid variable. isBelow :: Rigid -> Weight -> Rigid -> Bool -- | A constraint is an edge in the graph. data Constraint NewFlex :: FlexId -> Scope -> Constraint -- | For Arc v1 k v2 at least one of v1 or v2 is -- a MetaV (Flex), the other a MetaV or a Var -- (Rigid). If k <= 0 this means suc^(-k) v1 <= -- v2 otherwise v1 <= suc^k v3. Arc :: Node -> Int -> Node -> Constraint type Constraints = [Constraint] emptyConstraints :: Constraints data Graph Graph :: Map FlexId Scope -> Map Node NodeId -> Map NodeId Node -> NodeId -> (NodeId -> NodeId -> Weight) -> Graph -- | Scope for each flexible var. [flexScope] :: Graph -> Map FlexId Scope -- | Node labels to node numbers. [nodeMap] :: Graph -> Map Node NodeId -- | Node numbers to node labels. [intMap] :: Graph -> Map NodeId Node -- | Number of nodes n. [nextNode] :: Graph -> NodeId -- | The edges (restrict to [0..n[). [graph] :: Graph -> NodeId -> NodeId -> Weight -- | The empty graph: no nodes, edges are all undefined (infinity weight). initGraph :: Graph -- | The Graph Monad, for constructing a graph iteratively. type GM = State Graph -- | Add a size meta node. addFlex :: FlexId -> Scope -> GM () -- | Lookup identifier of a node. If not present, it is added first. addNode :: Node -> GM Int -- | addEdge n1 k n2 improves the weight of egde -- n1->n2 to be at most k. Also adds nodes if not -- yet present. addEdge :: Node -> Int -> Node -> GM () addConstraint :: Constraint -> GM () buildGraph :: Constraints -> Graph mkMatrix :: Int -> (Int -> Int -> Weight) -> Matrix Weight -- | A matrix with row descriptions in b and column descriptions -- in c. data LegendMatrix a b c LegendMatrix :: Matrix a -> (Int -> b) -> (Int -> c) -> LegendMatrix a b c [matrix] :: LegendMatrix a b c -> Matrix a [rowdescr] :: LegendMatrix a b c -> Int -> b [coldescr] :: LegendMatrix a b c -> Int -> c -- | A solution assigns to each flexible variable a size expression which -- is either a constant or a v + n for a rigid variable -- v. type Solution = Map Int SizeExpr emptySolution :: Solution extendSolution :: Solution -> Int -> SizeExpr -> Solution data SizeExpr -- | e.g. x + 5 SizeVar :: RigidId -> Int -> SizeExpr -- | a number or infinity SizeConst :: Weight -> SizeExpr -- | sizeRigid r n returns the size expression corresponding to -- r + n sizeRigid :: Rigid -> Int -> SizeExpr solve :: Constraints -> Maybe Solution instance GHC.Show.Show Agda.Utils.Warshall.Weight instance GHC.Classes.Eq Agda.Utils.Warshall.Weight instance GHC.Classes.Ord Agda.Utils.Warshall.Rigid instance GHC.Classes.Eq Agda.Utils.Warshall.Rigid instance GHC.Classes.Ord Agda.Utils.Warshall.Node instance GHC.Classes.Eq Agda.Utils.Warshall.Node instance Agda.Utils.Pretty.Pretty Agda.Utils.Warshall.SizeExpr instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b, Agda.Utils.Pretty.Pretty c) => Agda.Utils.Pretty.Pretty (Agda.Utils.Warshall.LegendMatrix a b c) instance Agda.Utils.Pretty.Pretty Agda.Utils.Warshall.Constraint instance Agda.Utils.Pretty.Pretty Agda.Utils.Warshall.Node instance Agda.Utils.Pretty.Pretty Agda.Utils.Warshall.Weight instance GHC.Classes.Ord Agda.Utils.Warshall.Weight instance Agda.Utils.SemiRing.SemiRing Agda.Utils.Warshall.Weight -- | Potentially uninitialised Booleans module Agda.Utils.WithDefault data WithDefault (b :: Bool) Default :: WithDefault (b :: Bool) Value :: !Bool -> WithDefault (b :: Bool) setDefault :: Bool -> WithDefault b -> WithDefault b collapseDefault :: KnownBool b => WithDefault b -> Bool instance GHC.Show.Show (Agda.Utils.WithDefault.WithDefault b) instance GHC.Classes.Eq (Agda.Utils.WithDefault.WithDefault b) instance Control.DeepSeq.NFData (Agda.Utils.WithDefault.WithDefault b) module Agda.Utils.Zipper class Zipper z where { type Carrier z; type Element z; } firstHole :: Zipper z => Carrier z -> Maybe (Element z, z) plugHole :: Zipper z => Element z -> z -> Carrier z nextHole :: Zipper z => Element z -> z -> Either (Carrier z) (Element z, z) data ListZipper a ListZip :: [a] -> [a] -> ListZipper a data ComposeZipper f g ComposeZip :: f -> g -> ComposeZipper f g instance Data.Traversable.Traversable Agda.Utils.Zipper.ListZipper instance Data.Foldable.Foldable Agda.Utils.Zipper.ListZipper instance GHC.Base.Functor Agda.Utils.Zipper.ListZipper instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.Zipper.ListZipper a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Utils.Zipper.ListZipper a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.Zipper.ListZipper a) instance (Agda.Utils.Zipper.Zipper f, Agda.Utils.Zipper.Zipper g, Agda.Utils.Zipper.Element f GHC.Types.~ Agda.Utils.Zipper.Carrier g) => Agda.Utils.Zipper.Zipper (Agda.Utils.Zipper.ComposeZipper f g) instance Agda.Utils.Zipper.Zipper (Agda.Utils.Zipper.ListZipper a) module Agda.Version -- | The version of Agda. version :: String -- | This package name. This is mainly intended for use in the test suites -- to filter ephemeral hash-fingerprinted package names like -- Agda-2.6.2-5ceeWeguf1QFMaHLput4zw. package :: String -- | Returns a URL corresponding to the given section in the documentation -- for the current version. docsUrl :: String -> String instance GHC.Generics.Generic Agda.Version.AnArbitrarySymbolInThisPackage module Agda.VersionCommit versionWithCommitInfo :: String -- | Information about current git commit, generated at compile time commitInfo :: Maybe String -- | Library management. -- -- Sample use: -- --
--   -- Get libraries as listed in .agda/libraries file.
--   libs <- getInstalledLibraries Nothing
--   
--   -- Get the libraries (and immediate paths) relevant for projectRoot.
--   -- This involves locating and processing the .agda-lib file for the project.
--   (libNames, includePaths) <-  getDefaultLibraries projectRoot True
--   
--   -- Get include paths of depended-on libraries.
--   resolvedPaths <- libraryIncludePaths Nothing libs libNames
--   
--   let allPaths = includePaths ++ resolvedPaths
--   
--   
module Agda.Interaction.Library -- | Get project root findProjectRoot :: FilePath -> LibM (Maybe FilePath) -- | Get dependencies and include paths for given project root: -- -- Look for .agda-lib files according to -- findAgdaLibFiles. If none are found, use default dependencies -- (according to defaults file) and current directory (project -- root). getDefaultLibraries :: FilePath -> Bool -> LibM ([LibName], [FilePath]) -- | Parse the descriptions of the libraries Agda knows about. -- -- Returns none if there is no libraries file. getInstalledLibraries :: Maybe FilePath -> LibM [AgdaLibFile] -- | Return the trusted executables Agda knows about. -- -- Returns none if there is no executables file. getTrustedExecutables :: LibM (Map ExeName FilePath) -- | Get all include pathes for a list of libraries to use. libraryIncludePaths :: Maybe FilePath -> [AgdaLibFile] -> [LibName] -> LibM [FilePath] -- | Get the contents of .agda-lib files in the given project -- root. getAgdaLibFiles' :: FilePath -> LibErrorIO [AgdaLibFile] -- | Returns the absolute default lib dir. This directory is used to store -- the Primitive.agda file. getPrimitiveLibDir :: IO FilePath -- | A symbolic library name. type LibName = String -- | Content of a .agda-lib file. data AgdaLibFile AgdaLibFile :: LibName -> FilePath -> [FilePath] -> [LibName] -> [String] -> AgdaLibFile -- | The symbolic name of the library. [_libName] :: AgdaLibFile -> LibName -- | Path to this .agda-lib file (not content of the file). [_libFile] :: AgdaLibFile -> FilePath -- | Roots where to look for the modules of the library. [_libIncludes] :: AgdaLibFile -> [FilePath] -- | Dependencies. [_libDepends] :: AgdaLibFile -> [LibName] -- | Default pragma options for all files in the library. [_libPragmas] :: AgdaLibFile -> [String] -- | A symbolic executable name. type ExeName = Text -- | Throws Doc exceptions, still collects LibWarnings. type LibM = ExceptT Doc (WriterT [LibWarning] (StateT LibState IO)) -- | Raise collected LibErrors as exception. mkLibM :: [AgdaLibFile] -> LibErrorIO a -> LibM a data LibWarning LibWarning :: Maybe LibPositionInfo -> LibWarning' -> LibWarning -- | Information about which .agda-lib file we are reading and -- from where in the libraries file it came from. data LibPositionInfo LibPositionInfo :: Maybe FilePath -> LineNumber -> FilePath -> LibPositionInfo -- | Name of libraries file. [libFilePos] :: LibPositionInfo -> Maybe FilePath -- | Line number in libraries file. [lineNumPos] :: LibPositionInfo -> LineNumber -- | Library file. [filePos] :: LibPositionInfo -> FilePath libraryWarningName :: LibWarning -> WarningName -- | A file can either belong to a project located at a given root -- containing one or more .agda-lib files, or be part of the default -- project. data ProjectConfig ProjectConfig :: FilePath -> [FilePath] -> ProjectConfig [configRoot] :: ProjectConfig -> FilePath [configAgdaLibFiles] :: ProjectConfig -> [FilePath] DefaultProjectConfig :: ProjectConfig -- | Library names are structured into the base name and a suffix of -- version numbers, e.g. mylib-1.2.3. The version suffix is -- optional. data VersionView VersionView :: LibName -> [Integer] -> VersionView -- | Actual library name. [vvBase] :: VersionView -> LibName -- | Major version, minor version, subminor version, etc., all -- non-negative. Note: a priori, there is no reason why the version -- numbers should be Ints. [vvNumbers] :: VersionView -> [Integer] -- | Split a library name into basename and a list of version numbers. -- --
--   versionView "foo-1.2.3"    == VersionView "foo" [1, 2, 3]
--   versionView "foo-01.002.3" == VersionView "foo" [1, 2, 3]
--   
-- -- Note that because of leading zeros, versionView is not -- injective. (unVersionView . versionView would produce a -- normal form.) versionView :: LibName -> VersionView -- | Print a VersionView, inverse of versionView (modulo -- leading zeros). unVersionView :: VersionView -> LibName -- | Generalized version of findLib for testing. -- --
--   findLib' id "a"   [ "a-1", "a-02", "a-2", "b" ] == [ "a-02", "a-2" ]
--   
-- --
--   findLib' id "a"   [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a" ]
--   findLib' id "a-1" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a-1", "a-01" ]
--   findLib' id "a-2" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a-2" ]
--   findLib' id "c"   [ "a", "a-1", "a-01", "a-2", "b" ] == []
--   
findLib' :: (a -> LibName) -> LibName -> [a] -> [a] instance GHC.Show.Show Agda.Interaction.Library.VersionView instance GHC.Classes.Eq Agda.Interaction.Library.VersionView module Agda.Interaction.Options data CommandLineOptions Options :: String -> Maybe FilePath -> [FilePath] -> [AbsolutePath] -> [LibName] -> Maybe FilePath -> Bool -> Bool -> Map ExeName FilePath -> Bool -> Bool -> Maybe Help -> Bool -> Bool -> Bool -> !Bool -> Maybe FilePath -> Bool -> Bool -> Bool -> Bool -> PragmaOptions -> Bool -> Bool -> CommandLineOptions [optProgramName] :: CommandLineOptions -> String [optInputFile] :: CommandLineOptions -> Maybe FilePath [optIncludePaths] :: CommandLineOptions -> [FilePath] -- | The list should not contain duplicates. [optAbsoluteIncludePaths] :: CommandLineOptions -> [AbsolutePath] [optLibraries] :: CommandLineOptions -> [LibName] -- | Use this (if Just) instead of .agda/libraries [optOverrideLibrariesFile] :: CommandLineOptions -> Maybe FilePath -- | Use ~.agdadefaults [optDefaultLibs] :: CommandLineOptions -> Bool -- | look for .agda-lib files [optUseLibs] :: CommandLineOptions -> Bool -- | Map names of trusted executables to absolute paths [optTrustedExecutables] :: CommandLineOptions -> Map ExeName FilePath [optPrintAgdaDir] :: CommandLineOptions -> Bool [optPrintVersion] :: CommandLineOptions -> Bool [optPrintHelp] :: CommandLineOptions -> Maybe Help -- | Agda REPL (-I). [optInteractive] :: CommandLineOptions -> Bool [optGHCiInteraction] :: CommandLineOptions -> Bool [optJSONInteraction] :: CommandLineOptions -> Bool -- | Exit if an interactive command fails. [optExitOnError] :: CommandLineOptions -> !Bool -- | In the absence of a path the project root is used. [optCompileDir] :: CommandLineOptions -> Maybe FilePath [optGenerateVimFile] :: CommandLineOptions -> Bool [optIgnoreInterfaces] :: CommandLineOptions -> Bool [optIgnoreAllInterfaces] :: CommandLineOptions -> Bool [optLocalInterfaces] :: CommandLineOptions -> Bool [optPragmaOptions] :: CommandLineOptions -> PragmaOptions -- | Should the top-level module only be scope-checked, and not -- type-checked? [optOnlyScopeChecking] :: CommandLineOptions -> Bool -- | Should code points that are not supported by the locale be -- transliterated? [optTransliterate] :: CommandLineOptions -> Bool -- | Options which can be set in a pragma. data PragmaOptions PragmaOptions :: Bool -> Bool -> UnicodeOrAscii -> !Verbosity -> ProfileOptions -> Bool -> WithDefault 'False -> Bool -> Bool -> Bool -> Bool -> CutOff -> Bool -> Bool -> Bool -> WithDefault 'False -> WithDefault 'False -> Bool -> Bool -> Bool -> Bool -> WithDefault 'False -> WithDefault 'False -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Maybe Cubical -> Bool -> Bool -> Bool -> Bool -> Int -> Bool -> Bool -> Int -> Bool -> Bool -> !Maybe Int -> WarningMode -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Maybe ConfluenceCheck -> Bool -> WithDefault 'False -> Bool -> Bool -> Bool -> WithDefault 'False -> Bool -> Bool -> PragmaOptions [optShowImplicit] :: PragmaOptions -> Bool [optShowIrrelevant] :: PragmaOptions -> Bool [optUseUnicode] :: PragmaOptions -> UnicodeOrAscii [optVerbose] :: PragmaOptions -> !Verbosity [optProfiling] :: PragmaOptions -> ProfileOptions [optProp] :: PragmaOptions -> Bool [optTwoLevel] :: PragmaOptions -> WithDefault 'False [optAllowUnsolved] :: PragmaOptions -> Bool [optAllowIncompleteMatch] :: PragmaOptions -> Bool [optDisablePositivity] :: PragmaOptions -> Bool [optTerminationCheck] :: PragmaOptions -> Bool -- | Cut off structural order comparison at some depth in termination -- checker? [optTerminationDepth] :: PragmaOptions -> CutOff [optUniverseCheck] :: PragmaOptions -> Bool [optOmegaInOmega] :: PragmaOptions -> Bool [optCumulativity] :: PragmaOptions -> Bool [optSizedTypes] :: PragmaOptions -> WithDefault 'False [optGuardedness] :: PragmaOptions -> WithDefault 'False [optInjectiveTypeConstructors] :: PragmaOptions -> Bool [optUniversePolymorphism] :: PragmaOptions -> Bool [optIrrelevantProjections] :: PragmaOptions -> Bool -- | irrelevant levels, irrelevant data matching [optExperimentalIrrelevance] :: PragmaOptions -> Bool [optWithoutK] :: PragmaOptions -> WithDefault 'False [optCubicalCompatible] :: PragmaOptions -> WithDefault 'False -- | Allow definitions by copattern matching? [optCopatterns] :: PragmaOptions -> Bool -- | Is pattern matching allowed in the current file? [optPatternMatching] :: PragmaOptions -> Bool [optExactSplit] :: PragmaOptions -> Bool [optEta] :: PragmaOptions -> Bool -- | Perform the forcing analysis on data constructors? [optForcing] :: PragmaOptions -> Bool -- | Perform the projection-likeness analysis on functions? [optProjectionLike] :: PragmaOptions -> Bool -- | Mark parameters of record modules as erased? [optEraseRecordParameters] :: PragmaOptions -> Bool -- | Can rewrite rules be added and used? [optRewriting] :: PragmaOptions -> Bool [optCubical] :: PragmaOptions -> Maybe Cubical [optGuarded] :: PragmaOptions -> Bool -- | Should we speculatively unify function applications as if they were -- injective? [optFirstOrder] :: PragmaOptions -> Bool -- | Should system generated projections ProjSystem be printed -- postfix (True) or prefix (False). [optPostfixProjections] :: PragmaOptions -> Bool -- | Should case splitting replace variables with dot patterns (False) or -- keep them as variables (True). [optKeepPatternVariables] :: PragmaOptions -> Bool [optInstanceSearchDepth] :: PragmaOptions -> Int [optOverlappingInstances] :: PragmaOptions -> Bool -- | Should instance search consider instances with qualified names? [optQualifiedInstances] :: PragmaOptions -> Bool [optInversionMaxDepth] :: PragmaOptions -> Int [optSafe] :: PragmaOptions -> Bool [optDoubleCheck] :: PragmaOptions -> Bool -- | Should the conversion checker use the syntactic equality shortcut? -- Nothing means that it should. Just n, for a -- non-negative number n, means that syntactic equality checking -- gets n units of fuel. If the fuel becomes zero, then -- syntactic equality checking is turned off. The fuel counter is -- decreased in the failure continuation of -- checkSyntacticEquality. [optSyntacticEquality] :: PragmaOptions -> !Maybe Int [optWarningMode] :: PragmaOptions -> WarningMode [optCompileNoMain] :: PragmaOptions -> Bool [optCaching] :: PragmaOptions -> Bool -- | Count extended grapheme clusters rather than code points when -- generating LaTeX. [optCountClusters] :: PragmaOptions -> Bool -- | Automatic compile-time inlining for simple definitions (unless marked -- NOINLINE). [optAutoInline] :: PragmaOptions -> Bool [optPrintPatternSynonyms] :: PragmaOptions -> Bool -- | Use the Agda abstract machine (fastReduce)? [optFastReduce] :: PragmaOptions -> Bool -- | Use call-by-name instead of call-by-need [optCallByName] :: PragmaOptions -> Bool -- | Check confluence of rewrite rules? [optConfluenceCheck] :: PragmaOptions -> Maybe ConfluenceCheck -- | Are the cohesion modalities available? [optCohesion] :: PragmaOptions -> Bool -- | Can we split on a (@flat x : A) argument? [optFlatSplit] :: PragmaOptions -> WithDefault 'False -- | Should every top-level module start with an implicit statement -- open import Agda.Primitive using (Set; Prop)? [optImportSorts] :: PragmaOptions -> Bool -- | Should we load the primitive modules at all? This is a stronger form -- of optImportSorts. [optLoadPrimitives] :: PragmaOptions -> Bool [optAllowExec] :: PragmaOptions -> Bool -- | Save meta-variables. [optSaveMetas] :: PragmaOptions -> WithDefault 'False -- | Show identity substitutions when pretty-printing terms (i.e. always -- show all arguments of a metavariable) [optShowIdentitySubstitutions] :: PragmaOptions -> Bool -- | Do not discard clauses constructed by the coverage checker (needed for -- some external backends) [optKeepCoveringClauses] :: PragmaOptions -> Bool -- | The options from an OPTIONS pragma. -- -- In the future it might be nice to switch to a more structured -- representation. Note that, currently, there is not a one-to-one -- correspondence between list elements and options. type OptionsPragma = [String] -- | 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 type Flag opts = opts -> OptM opts type OptM = Except String runOptM :: Monad m => OptM opts -> m (Either String opts) -- | Each OptDescr describes a single option. -- -- The arguments to Option are: -- -- data OptDescr a Option :: [Char] -> [String] -> ArgDescr a -> String -> OptDescr a -- | Describes whether an option takes an argument or not, and if so how -- the argument is injected into a value of type a. data ArgDescr a -- | no argument expected NoArg :: a -> ArgDescr a -- | option requires argument ReqArg :: (String -> a) -> String -> ArgDescr a -- | optional argument OptArg :: (Maybe String -> a) -> String -> ArgDescr a -- | Nothing is used if no verbosity options have been given, thus -- making it possible to handle the default case relatively quickly. Note -- that Nothing corresponds to a trie with verbosity level 1 for -- the empty path. type Verbosity = Maybe (Trie VerboseKeyItem VerboseLevel) type VerboseKey = String type VerboseLevel = Int -- | A WarningMode has two components: a set of warnings to be -- displayed and a flag stating whether warnings should be turned into -- fatal errors. data WarningMode WarningMode :: Set WarningName -> Bool -> WarningMode [_warningSet] :: WarningMode -> Set WarningName [_warn2Error] :: WarningMode -> Bool data ConfluenceCheck LocalConfluenceCheck :: ConfluenceCheck GlobalConfluenceCheck :: ConfluenceCheck -- | We want to know whether we are allowed to insert unicode characters or -- not. data UnicodeOrAscii UnicodeOk :: UnicodeOrAscii AsciiOnly :: UnicodeOrAscii -- | Checks that the given options are consistent. checkOpts :: Flag CommandLineOptions -- | Parse options from an options pragma. parsePragmaOptions :: [String] -> CommandLineOptions -> OptM PragmaOptions -- | Parse options for a plugin. parsePluginOptions :: [String] -> [OptDescr (Flag opts)] -> Flag opts parseVerboseKey :: VerboseKey -> [VerboseKeyItem] -- | Removes RTS options from a list of options. stripRTS :: [String] -> [String] defaultOptions :: CommandLineOptions defaultInteractionOptions :: PragmaOptions -- | The default termination depth. defaultCutOff :: CutOff defaultPragmaOptions :: PragmaOptions -- | Used for printing usage info. Does not include the dead options. standardOptions_ :: [OptDescr ()] -- | Check for unsafe pragmas. Gives a list of used unsafe flags. unsafePragmaOptions :: CommandLineOptions -> PragmaOptions -> [String] -- | This function returns True if the file should be rechecked. recheckBecausePragmaOptionsChanged :: PragmaOptions -> PragmaOptions -> Bool -- | Infective or coinfective? data InfectiveCoinfective Infective :: InfectiveCoinfective Coinfective :: InfectiveCoinfective -- | Descriptions of infective and coinfective options. data InfectiveCoinfectiveOption ICOption :: (PragmaOptions -> Bool) -> String -> InfectiveCoinfective -> (PragmaOptions -> PragmaOptions -> Bool) -> (TopLevelModuleName -> Doc) -> InfectiveCoinfectiveOption -- | Is the option active? [icOptionActive] :: InfectiveCoinfectiveOption -> PragmaOptions -> Bool -- | A description of the option (typically a flag that activates the -- option). [icOptionDescription] :: InfectiveCoinfectiveOption -> String -- | Is the option (roughly speaking) infective or coinfective? [icOptionKind] :: InfectiveCoinfectiveOption -> InfectiveCoinfective -- | This function returns True exactly when, from the perspective -- of the option in question, the options in the current module (the -- first argument) are compatible with the options in a given imported -- module (the second argument). [icOptionOK] :: InfectiveCoinfectiveOption -> PragmaOptions -> PragmaOptions -> Bool -- | A warning message that should be used if this option is not used -- correctly. The given module name is the name of an imported module for -- which icOptionOK failed. [icOptionWarning] :: InfectiveCoinfectiveOption -> TopLevelModuleName -> Doc -- | Infective and coinfective options. -- -- Note that --cubical and --erased-cubical are -- "jointly infective": if one of them is used in one module, then one or -- the other must be used in all modules that depend on this module. infectiveCoinfectiveOptions :: [InfectiveCoinfectiveOption] safeFlag :: Flag PragmaOptions -- | Map a function over the long options. Also removes the short options. -- Will be used to add the plugin name to the plugin options. mapFlag :: (String -> String) -> OptDescr a -> OptDescr a -- | The usage info message. The argument is the program name (probably -- agda). usage :: [OptDescr ()] -> String -> Help -> String inputFlag :: FilePath -> Flag CommandLineOptions standardOptions :: [OptDescr (Flag CommandLineOptions)] -- | Command line options of previous versions of Agda. Should not be -- listed in the usage info, put parsed by GetOpt for good error -- messaging. deadStandardOptions :: [OptDescr (Flag CommandLineOptions)] -- | Simple interface for System.Console.GetOpt Could be moved to -- Agda.Utils.Options (does not exist yet) getOptSimple :: [String] -> [OptDescr (Flag opts)] -> (String -> Flag opts) -> Flag opts class (Functor m, Applicative m, Monad m) => HasOptions m -- | Returns the pragma options which are currently in effect. pragmaOptions :: HasOptions m => m PragmaOptions -- | Returns the command line options which are currently in effect. commandLineOptions :: HasOptions m => m CommandLineOptions -- | Returns the pragma options which are currently in effect. pragmaOptions :: (HasOptions m, HasOptions n, MonadTrans t, m ~ t n) => m PragmaOptions -- | Returns the command line options which are currently in effect. commandLineOptions :: (HasOptions m, HasOptions n, MonadTrans t, m ~ t n) => m CommandLineOptions -- | Main module for JS backend. module Agda.Compiler.JS.Compiler jsBackend :: Backend jsBackend' :: Backend' JSOptions JSOptions JSModuleEnv Module (Maybe Export) data JSOptions JSOptions :: Bool -> Bool -> Bool -> Bool -> JSOptions [optJSCompile] :: JSOptions -> Bool [optJSOptimize] :: JSOptions -> Bool -- | Remove spaces etc. See -- https://en.wikipedia.org/wiki/Minification_(programming). [optJSMinify] :: JSOptions -> Bool -- | Run generated code through interpreter. [optJSVerify] :: JSOptions -> Bool defaultJSOptions :: JSOptions jsCommandLineFlags :: [OptDescr (Flag JSOptions)] jsPreCompile :: JSOptions -> TCM JSOptions -- | After all modules have been compiled, copy RTE modules and verify -- compiled modules. jsPostCompile :: JSOptions -> IsMain -> Map TopLevelModuleName Module -> TCM () data JSModuleEnv JSModuleEnv :: Maybe CoinductionKit -> Bool -> JSModuleEnv [jsCoinductionKit] :: JSModuleEnv -> Maybe CoinductionKit -- | Should this module be compiled? [jsCompile] :: JSModuleEnv -> Bool jsPreModule :: JSOptions -> IsMain -> TopLevelModuleName -> Maybe FilePath -> TCM (Recompile JSModuleEnv Module) jsPostModule :: JSOptions -> JSModuleEnv -> IsMain -> TopLevelModuleName -> [Maybe Export] -> TCM Module jsCompileDef :: JSOptions -> JSModuleEnv -> IsMain -> Definition -> TCM (Maybe Export) prefix :: [Char] jsMod :: TopLevelModuleName -> GlobalId jsFileName :: GlobalId -> String jsMember :: Name -> MemberId global' :: QName -> TCM (Exp, JSQName) global :: QName -> TCM (Exp, JSQName) reorder :: [Export] -> [Export] reorder' :: Set JSQName -> [Export] -> [Export] isTopLevelValue :: Export -> Bool isEmptyObject :: Export -> Bool insertAfter :: Set JSQName -> Export -> [Export] -> [Export] type EnvWithOpts = (JSOptions, JSModuleEnv) definition :: EnvWithOpts -> (QName, Definition) -> TCM (Maybe Export) -- | Ensure that there is at most one pragma for a name. checkCompilerPragmas :: QName -> TCM () defJSDef :: Definition -> Maybe String definition' :: EnvWithOpts -> QName -> Definition -> Type -> JSQName -> TCM (Maybe Export) compileTerm :: EnvWithOpts -> TTerm -> TCM Exp compilePrim :: TPrim -> Exp compileAlt :: EnvWithOpts -> TAlt -> TCM ((QName, MemberId), Exp) eraseLocalVars :: [Bool] -> TTerm -> TTerm visitorName :: QName -> TCM MemberId flatName :: MemberId local :: Nat -> Exp qname :: QName -> TCM Exp literal :: Literal -> Exp litqname :: QName -> Exp writeModule :: Bool -> Module -> TCM () outFile :: GlobalId -> TCM FilePath outFile_ :: TCM FilePath -- | Primitives implemented in the JS Agda RTS. -- -- TODO: Primitives that are not part of this set, and for which -- defJSDef does not return anything, are silently compiled to -- Undefined. A better approach might be to list exactly those -- primitives which should be compiled to Undefined. primitives :: Set String instance GHC.Generics.Generic Agda.Compiler.JS.Compiler.JSOptions instance Control.DeepSeq.NFData Agda.Compiler.JS.Compiler.JSOptions module Agda.TypeChecking.Telescope -- | Flatten telescope: (Γ : Tel) -> [Type Γ] flattenTel :: TermSubst a => Tele (Dom a) -> [Dom a] -- | Order a flattened telescope in the correct dependeny order: Γ -> -- Permutation (Γ -> Γ~) -- -- Since reorderTel tel uses free variable analysis of type in -- tel, the telescope should be normalised. reorderTel :: [Dom Type] -> Maybe Permutation reorderTel_ :: [Dom Type] -> Permutation -- | Unflatten: turns a flattened telescope into a proper telescope. Must -- be properly ordered. unflattenTel :: [ArgName] -> [Dom Type] -> Telescope -- | A variant of unflattenTel which takes the size of the last -- argument as an argument. unflattenTel' :: Int -> [ArgName] -> [Dom Type] -> Telescope -- | Rename the variables in the telescope to the given names Precondition: -- size xs == size tel. renameTel :: [Maybe ArgName] -> Telescope -> Telescope -- | Get the suggested names from a telescope teleNames :: Telescope -> [ArgName] teleArgNames :: Telescope -> [Arg ArgName] teleArgs :: DeBruijn a => Tele (Dom t) -> [Arg a] teleDoms :: DeBruijn a => Tele (Dom t) -> [Dom a] teleNamedArgs :: DeBruijn a => Tele (Dom t) -> [NamedArg a] -- | A variant of teleNamedArgs which takes the argument names (and -- the argument info) from the first telescope and the variable names -- from the second telescope. -- -- Precondition: the two telescopes have the same length. tele2NamedArgs :: DeBruijn a => Telescope -> Telescope -> [NamedArg a] -- | Split the telescope at the specified position. splitTelescopeAt :: Int -> Telescope -> (Telescope, Telescope) -- | Permute telescope: permutes or drops the types in the telescope -- according to the given permutation. Assumes that the permutation -- preserves the dependencies in the telescope. -- -- For example (Andreas, 2016-12-18, issue #2344): tel = (A : Set) -- (X : _18 A) (i : Fin (_m_23 A X)) tel (de Bruijn) = 2:Set, 1:_18 -- 0, 0:Fin(_m_23 1 0) flattenTel tel = 2:Set, 1:_18 0, -- 0:Fin(_m_23 1 0) |- [ Set, _18 2, Fin (_m_23 2 -- 1) ] perm = 0,1,2 -> 0,1 (picks the first two) renaming _ perm -- = [var 0, var 1, error] -- THE WRONG RENAMING! renaming _ (flipP perm) -- = [error, var 1, var 0] -- The correct renaming! apply to flattened -- tel = ... |- [ Set, _18 1, Fin (_m_23 1 0) ] permute perm -- it = ... |- [ Set, _18 1 ] unflatten (de Bruijn) = 1:Set, 0: _18 -- 0 unflatten = (A : Set) (X : _18 A) permuteTel :: Permutation -> Telescope -> Telescope -- | Recursively computes dependencies of a set of variables in a given -- telescope. Any dependencies outside of the telescope are ignored. varDependencies :: Telescope -> IntSet -> IntSet -- | Computes the set of variables in a telescope whose type depend on one -- of the variables in the given set (including recursive dependencies). -- Any dependencies outside of the telescope are ignored. varDependents :: Telescope -> IntSet -> IntSet -- | A telescope split in two. data SplitTel SplitTel :: Telescope -> Telescope -> Permutation -> SplitTel [firstPart] :: SplitTel -> Telescope [secondPart] :: SplitTel -> Telescope -- | The permutation takes us from the original telescope to firstPart -- ++ secondPart. [splitPerm] :: SplitTel -> Permutation -- | Split a telescope into the part that defines the given variables and -- the part that doesn't. -- -- See prop_splitTelescope. splitTelescope :: VarSet -> Telescope -> SplitTel -- | As splitTelescope, but fails if any additional variables or reordering -- would be needed to make the first part well-typed. splitTelescopeExact :: [Int] -> Telescope -> Maybe SplitTel -- | Try to instantiate one variable in the telescope (given by its de -- Bruijn level) with the given value, returning the new telescope and a -- substitution to the old one. Returns Nothing if the given value -- depends (directly or indirectly) on the variable. instantiateTelescope :: Telescope -> Int -> DeBruijnPattern -> Maybe (Telescope, PatternSubstitution, Permutation) -- | Try to eta-expand one variable in the telescope (given by its de -- Bruijn level) expandTelescopeVar :: Telescope -> Int -> Telescope -> ConHead -> (Telescope, PatternSubstitution) -- | Gather leading Πs of a type in a telescope. telView :: (MonadReduce m, MonadAddContext m) => Type -> m TelView -- | telViewUpTo n t takes off the first n function types -- of t. Takes off all if n < 0. telViewUpTo :: (MonadReduce m, MonadAddContext m) => Int -> Type -> m TelView -- | telViewUpTo' n p t takes off $t$ the first n (or -- arbitrary many if n < 0) function domains as long as they -- satify p. telViewUpTo' :: (MonadReduce m, MonadAddContext m) => Int -> (Dom Type -> Bool) -> Type -> m TelView telViewPath :: PureTCM m => Type -> m TelView -- | telViewUpToPath n t takes off $t$ the first n (or -- arbitrary many if n < 0) function domains or Path types. -- --
--   telViewUpToPath n t = fst $ telViewUpToPathBoundary'n t
--   
telViewUpToPath :: PureTCM m => Int -> Type -> m TelView -- | type Boundary = Boundary' (Term, Term) type Boundary' a = [(Term, a)] -- | Like telViewUpToPath but also returns the Boundary -- expected by the Path types encountered. The boundary terms live in the -- telescope given by the TelView. Each point of the boundary -- has the type of the codomain of the Path type it got taken from, see -- fullBoundary. telViewUpToPathBoundary' :: PureTCM m => Int -> Type -> m (TelView, Boundary) fullBoundary :: Telescope -> Boundary -> Boundary -- | (TelV Γ b, [(i,t_i,u_i)]) <- telViewUpToPathBoundary n a -- Input: Δ ⊢ a Output: ΔΓ ⊢ b ΔΓ ⊢ i : I ΔΓ ⊢ [ (i=0) -> t_i; (i=1) -- -> u_i ] : b telViewUpToPathBoundary :: PureTCM m => Int -> Type -> m (TelView, Boundary) -- | (TelV Γ b, [(i,t_i,u_i)]) <- telViewUpToPathBoundaryP n a -- Input: Δ ⊢ a Output: Δ.Γ ⊢ b Δ.Γ ⊢ T is the codomain of the PathP at -- variable i Δ.Γ ⊢ i : I Δ.Γ ⊢ [ (i=0) -> t_i; (i=1) -> u_i ] : T -- Useful to reconstruct IApplyP patterns after teleNamedArgs Γ. telViewUpToPathBoundaryP :: PureTCM m => Int -> Type -> m (TelView, Boundary) telViewPathBoundaryP :: PureTCM m => Type -> m (TelView, Boundary) -- | teleElimsB args bs = es Input: Δ.Γ ⊢ args : Γ Δ.Γ ⊢ T is the -- codomain of the PathP at variable i Δ.Γ ⊢ i : I Δ.Γ ⊢ bs = [ (i=0) -- -> t_i; (i=1) -> u_i ] : T Output: Δ.Γ | PiPath Γ bs A ⊢ es : A teleElims :: DeBruijn a => Telescope -> Boundary' (a, a) -> [Elim' a] -- | Reduces Type. pathViewAsPi :: PureTCM m => Type -> m (Either (Dom Type, Abs Type) Type) -- | Reduces Type. pathViewAsPi' :: PureTCM m => Type -> m (Either ((Dom Type, Abs Type), (Term, Term)) Type) pathViewAsPi'whnf :: HasBuiltins m => m (Type -> Either ((Dom Type, Abs Type), (Term, Term)) Type) -- | Returns Left (a,b) in case the type is Pi a b or -- PathP b _ _. Assumes the Type is in whnf. piOrPath :: HasBuiltins m => Type -> m (Either (Dom Type, Abs Type) Type) -- | Assumes Type is in whnf. telView'UpToPath :: Int -> Type -> TCM TelView telView'Path :: Type -> TCM TelView isPath :: PureTCM m => Type -> m (Maybe (Dom Type, Abs Type)) telePatterns :: DeBruijn a => Telescope -> Boundary -> [NamedArg (Pattern' a)] telePatterns' :: DeBruijn a => (forall a. DeBruijn a => Telescope -> [NamedArg a]) -> Telescope -> Boundary -> [NamedArg (Pattern' a)] -- | Decomposing a function type. mustBePi :: MonadReduce m => Type -> m (Dom Type, Abs Type) -- | If the given type is a Pi, pass its parts to the first -- continuation. If not (or blocked), pass the reduced type to the second -- continuation. ifPi :: MonadReduce m => Term -> (Dom Type -> Abs Type -> m a) -> (Term -> m a) -> m a -- | If the given type is a Pi, pass its parts to the first -- continuation. If not (or blocked), pass the reduced type to the second -- continuation. ifPiType :: MonadReduce m => Type -> (Dom Type -> Abs Type -> m a) -> (Type -> m a) -> m a -- | If the given type is blocked or not a Pi, pass it reduced to -- the first continuation. If it is a Pi, pass its parts to the -- second continuation. ifNotPi :: MonadReduce m => Term -> (Term -> m a) -> (Dom Type -> Abs Type -> m a) -> m a -- | If the given type is blocked or not a Pi, pass it reduced to -- the first continuation. If it is a Pi, pass its parts to the -- second continuation. ifNotPiType :: MonadReduce m => Type -> (Type -> m a) -> (Dom Type -> Abs Type -> m a) -> m a ifNotPiOrPathType :: (MonadReduce tcm, HasBuiltins tcm) => Type -> (Type -> tcm a) -> (Dom Type -> Abs Type -> tcm a) -> tcm a -- | A safe variant of piApply. class PiApplyM a piApplyM' :: (PiApplyM a, MonadReduce m, HasBuiltins m) => m Empty -> Type -> a -> m Type piApplyM :: (PiApplyM a, MonadReduce m, HasBuiltins m) => Type -> a -> m Type -- | Compute type arity typeArity :: Type -> TCM Nat data OutputTypeName OutputTypeName :: QName -> OutputTypeName OutputTypeVar :: OutputTypeName OutputTypeVisiblePi :: OutputTypeName OutputTypeNameNotYetKnown :: Blocker -> OutputTypeName NoOutputTypeName :: OutputTypeName -- | Strips all hidden and instance Pi's and return the argument telescope -- and head definition name, if possible. getOutputTypeName :: Type -> TCM (Telescope, OutputTypeName) -- | Register the definition with the given type as an instance addTypedInstance :: QName -> Type -> TCM () resolveUnknownInstanceDefs :: TCM () -- | Try to solve the instance definitions whose type is not yet known, -- report an error if it doesn't work and return the instance table -- otherwise. getInstanceDefs :: TCM InstanceTable instance Agda.TypeChecking.Telescope.PiApplyM Agda.Syntax.Internal.Term instance Agda.TypeChecking.Telescope.PiApplyM a => Agda.TypeChecking.Telescope.PiApplyM (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Telescope.PiApplyM a => Agda.TypeChecking.Telescope.PiApplyM (Agda.Syntax.Common.Named n a) instance Agda.TypeChecking.Telescope.PiApplyM a => Agda.TypeChecking.Telescope.PiApplyM [a] module Agda.TypeChecking.Warnings class (MonadPretty m, MonadError TCErr m) => MonadWarning m -- | Store a warning and generate highlighting from it. addWarning :: MonadWarning m => TCWarning -> m () -- | Store a warning and generate highlighting from it. addWarning :: (MonadWarning m, MonadWarning n, MonadTrans t, t n ~ m) => TCWarning -> m () genericWarning :: MonadWarning m => Doc -> m () genericNonFatalError :: MonadWarning m => Doc -> m () warning'_ :: MonadWarning m => CallStack -> Warning -> m TCWarning warning_ :: (HasCallStack, MonadWarning m) => Warning -> m TCWarning warning' :: MonadWarning m => CallStack -> Warning -> m () warning :: (HasCallStack, MonadWarning m) => Warning -> m () warnings :: (HasCallStack, MonadWarning m) => [Warning] -> m () -- | Raise every WARNING_ON_USAGE connected to a name. raiseWarningsOnUsage :: (MonadWarning m, ReadTCState m) => QName -> m () isUnsolvedWarning :: Warning -> Bool isMetaWarning :: Warning -> Bool isMetaTCWarning :: TCWarning -> Bool onlyShowIfUnsolved :: Warning -> Bool -- | Classifying warnings: some are benign, others are (non-fatal) errors data WhichWarnings -- | warnings that will be turned into errors ErrorWarnings :: WhichWarnings -- | all warnings, including errors and benign ones Note: order of -- constructors is important for the derived Ord instance AllWarnings :: WhichWarnings classifyWarning :: Warning -> WhichWarnings -- | Assorted warnings and errors to be displayed to the user data WarningsAndNonFatalErrors tcWarnings :: WarningsAndNonFatalErrors -> [TCWarning] nonFatalErrors :: WarningsAndNonFatalErrors -> [TCWarning] -- | The only way to construct a empty WarningsAndNonFatalErrors emptyWarningsAndNonFatalErrors :: WarningsAndNonFatalErrors classifyWarnings :: [TCWarning] -> WarningsAndNonFatalErrors -- | running the Parse monad runPM :: PM a -> TCM a instance GHC.Classes.Ord Agda.TypeChecking.Warnings.WhichWarnings instance GHC.Classes.Eq Agda.TypeChecking.Warnings.WhichWarnings instance Agda.TypeChecking.Warnings.MonadWarning m => Agda.TypeChecking.Warnings.MonadWarning (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Warnings.MonadWarning m => Agda.TypeChecking.Warnings.MonadWarning (Control.Monad.Trans.State.Lazy.StateT s m) instance Agda.TypeChecking.Warnings.MonadWarning Agda.TypeChecking.Monad.Base.TCM module Agda.TypeChecking.Pretty.Warning prettyWarning :: MonadPretty m => Warning -> m Doc prettyRecordFieldWarning :: MonadPretty m => RecordFieldWarning -> m Doc prettyDuplicateFields :: MonadPretty m => [Name] -> m Doc prettyTooManyFields :: MonadPretty m => QName -> [Name] -> [Name] -> m Doc -- | Report a number of names that are not in scope. prettyNotInScopeNames :: (MonadPretty m, Pretty a, HasRange a) => Bool -> (a -> m Doc) -> [a] -> m Doc -- | Suggest some corrections to a misspelled name. didYouMean :: (MonadPretty m, Pretty a, Pretty b) => [QName] -> (a -> b) -> a -> Maybe (m Doc) prettyTCWarnings :: [TCWarning] -> TCM String prettyTCWarnings' :: [TCWarning] -> TCM [String] -- | If there are several warnings, remove the unsolved-constraints warning -- in case there are no interesting constraints to list. filterTCWarnings :: [TCWarning] -> [TCWarning] -- | Turns warnings, if any, into errors. tcWarningsToError :: [TCWarning] -> TCM () -- | Depending which flags are set, one may happily ignore some warnings. applyFlagsToTCWarningsPreserving :: HasOptions m => Set WarningName -> [TCWarning] -> m [TCWarning] applyFlagsToTCWarnings :: HasOptions m => [TCWarning] -> m [TCWarning] getAllUnsolvedWarnings :: (MonadFail m, ReadTCState m, MonadWarning m) => m [TCWarning] -- | Collect all warnings that have accumulated in the state. getAllWarnings :: (MonadFail m, ReadTCState m, MonadWarning m) => WhichWarnings -> m [TCWarning] getAllWarningsPreserving :: (MonadFail m, ReadTCState m, MonadWarning m) => Set WarningName -> WhichWarnings -> m [TCWarning] getAllWarningsOfTCErr :: TCErr -> TCM [TCWarning] instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.TCWarning module Agda.TypeChecking.Pretty.Constraint prettyConstraint :: MonadPretty m => ProblemConstraint -> m Doc interestingConstraint :: ProblemConstraint -> Bool prettyInterestingConstraints :: MonadPretty m => [ProblemConstraint] -> m [Doc] prettyRangeConstraint :: (MonadPretty m, Foldable f, Null (f ProblemId)) => Range -> f ProblemId -> Blocker -> Doc -> m Doc instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Constraint -- | This module contains the definition of hereditary substitution and -- application operating on internal syntax which is in β-normal form (β -- including projection reductions). -- -- Further, it contains auxiliary functions which rely on substitution -- but not on reduction. module Agda.TypeChecking.Substitute -- | A sort can either be small (Set l, Prop l, Size, ...) or large (Setω -- n). data SizeOfSort SmallSort :: IsFibrant -> SizeOfSort LargeSort :: IsFibrant -> Integer -> SizeOfSort -- | Performs void (noAbs) abstraction over telescope. class TeleNoAbs a teleNoAbs :: TeleNoAbs a => a -> Term -> Term data TelV a TelV :: Tele (Dom a) -> a -> TelV a [theTel] :: TelV a -> Tele (Dom a) [theCore] :: TelV a -> a type TelView = TelV Type -- | Apply Elims while using the given function to report -- ill-typed redexes. Recursive calls for applyE and -- applySubst happen at type t to propagate the same -- strategy to subtrees. applyTermE :: forall t. (Coercible Term t, Apply t, EndoSubst t) => (Empty -> Term -> Elims -> Term) -> t -> Elims -> t -- | If v is a record or constructed value, canProject f -- v returns its field f. canProject :: QName -> Term -> Maybe (Arg Term) -- | Eliminate a constructed term. conApp :: forall t. (Coercible t Term, Apply t) => (Empty -> Term -> Elims -> Term) -> ConHead -> ConInfo -> Elims -> Elims -> Term -- | defApp f us vs applies Def f us to further arguments -- vs, eliminating top projection redexes. If us is not -- empty, we cannot have a projection redex, since the record argument is -- the first one. defApp :: QName -> Elims -> Elims -> Term argToDontCare :: Arg Term -> Term relToDontCare :: LensRelevance a => a -> Term -> Term -- |
--   (x:A)->B(x) piApply [u] = B(u)
--   
-- -- Precondition: The type must contain the right number of pis without -- having to perform any reduction. -- -- piApply is potentially unsafe, the monadic piApplyM -- is preferable. piApply :: Type -> Args -> Type telVars :: Int -> Telescope -> [Arg DeBruijnPattern] namedTelVars :: Int -> Telescope -> [NamedArg DeBruijnPattern] abstractArgs :: Abstract a => Args -> a -> a -- | If permute π : [a]Γ -> [a]Δ, then applySubst (renaming -- _ π) : Term Γ -> Term Δ renaming :: forall a. DeBruijn a => Impossible -> Permutation -> Substitution' a -- | If permute π : [a]Γ -> [a]Δ, then applySubst -- (renamingR π) : Term Δ -> Term Γ renamingR :: DeBruijn a => Permutation -> Substitution' a -- | The permutation should permute the corresponding context. -- (right-to-left list) renameP :: Subst a => Impossible -> Permutation -> a -> a applySubstTerm :: forall t. (Coercible t Term, EndoSubst t, Apply t) => Substitution' t -> t -> t applyNLPatSubst :: TermSubst a => Substitution' NLPat -> a -> a applyNLSubstToDom :: SubstWith NLPat a => Substitution' NLPat -> Dom a -> Dom a fromPatternSubstitution :: PatternSubstitution -> Substitution applyPatSubst :: TermSubst a => PatternSubstitution -> a -> a usePatOrigin :: PatOrigin -> Pattern' a -> Pattern' a usePatternInfo :: PatternInfo -> Pattern' a -> Pattern' a -- |
--   projDropParsApply proj o args = projDropPars proj o `apply` args
--   
-- -- This function is an optimization, saving us from construction lambdas -- we immediately remove through application. projDropParsApply :: Projection -> ProjOrigin -> Relevance -> Args -> Term -- | Takes off all exposed function domains from the given type. This means -- that it does not reduce to expose Pi-types. telView' :: Type -> TelView -- | telView'UpTo n t takes off the first n exposed -- function types of t. Takes off all (exposed ones) if n -- < 0. telView'UpTo :: Int -> Type -> TelView -- | Add given binding to the front of the telescope. absV :: Dom a -> ArgName -> TelV a -> TelV a -- | Turn a typed binding (x1 .. xn : A) into a telescope. bindsToTel' :: (Name -> a) -> [Name] -> Dom Type -> ListTel' a bindsToTel :: [Name] -> Dom Type -> ListTel bindsToTel'1 :: (Name -> a) -> List1 Name -> Dom Type -> ListTel' a bindsToTel1 :: List1 Name -> Dom Type -> ListTel -- | Turn a typed binding (x1 .. xn : A) into a telescope. namedBindsToTel :: [NamedArg Name] -> Type -> Telescope namedBindsToTel1 :: List1 (NamedArg Name) -> Type -> Telescope domFromNamedArgName :: NamedArg Name -> Dom () mkPiSort :: Dom Type -> Abs Type -> Sort -- |
--   mkPi dom t = telePi (telFromList [dom]) t
--   
mkPi :: Dom (ArgName, Type) -> Type -> Type mkLam :: Arg ArgName -> Term -> Term lamView :: Term -> ([Arg ArgName], Term) unlamView :: [Arg ArgName] -> Term -> Term telePi' :: (Abs Type -> Abs Type) -> Telescope -> Type -> Type -- | Uses free variable analysis to introduce NoAbs bindings. telePi :: Telescope -> Type -> Type -- | Everything will be an Abs. telePi_ :: Telescope -> Type -> Type -- | Only abstract the visible components of the telescope, and all that -- bind variables. Everything will be an Abs! Caution: quadratic -- time! telePiVisible :: Telescope -> Type -> Type -- | Abstract over a telescope in a term, producing lambdas. Dumb -- abstraction: Always produces Abs, never NoAbs. -- -- The implementation is sound because Telescope does not use -- NoAbs. teleLam :: Telescope -> Term -> Term -- | Given arguments vs : tel (vector typing), extract their -- individual types. Returns Nothing is tel is not long -- enough. typeArgsWithTel :: Telescope -> [Term] -> Maybe [Dom Type] -- | In compiled clauses, the variables in the clause body are relative to -- the pattern variables (including dot patterns) instead of the clause -- telescope. compiledClauseBody :: Clause -> Maybe Term -- | univSort' univInf s gets the next higher sort of s, -- if it is known (i.e. it is not just UnivSort s). -- -- Precondition: s is reduced univSort' :: Sort -> Either Blocker Sort univSort :: Sort -> Sort sort :: Sort -> Type ssort :: Level -> Type -- | Returns Left blocker for unknown (blocked) sorts, and -- otherwise returns Right s where s indicates the size -- and fibrancy. sizeOfSort :: Sort -> Either Blocker SizeOfSort isSmallSort :: Sort -> Bool fibrantLub :: IsFibrant -> IsFibrant -> IsFibrant -- | Compute the sort of a function type from the sorts of its domain and -- codomain. funSort' :: Sort -> Sort -> Either Blocker Sort funSort :: Sort -> Sort -> Sort -- | Compute the sort of a pi type from the sorts of its domain and -- codomain. piSort' :: Dom Term -> Sort -> Abs Sort -> Either Blocker Sort piSort :: Dom Term -> Sort -> Abs Sort -> Sort levelMax :: Integer -> [PlusLevel] -> Level -- | Given two levels a and b, compute a ⊔ b and -- return its canonical form. levelLub :: Level -> Level -> Level levelTm :: Level -> Term -- | Substitutions. data Substitution' a -- | Identity substitution. Γ ⊢ IdS : Γ IdS :: Substitution' a -- | Empty substitution, lifts from the empty context. First argument is -- IMPOSSIBLE. Apply this to closed terms you want to use -- in a non-empty context. Γ ⊢ EmptyS : () EmptyS :: Impossible -> Substitution' a -- | Substitution extension, `cons'. Γ ⊢ u : Aρ Γ ⊢ ρ : Δ -- ---------------------- Γ ⊢ u :# ρ : Δ, A (:#) :: a -> Substitution' a -> Substitution' a -- | Strengthening substitution. First argument is -- IMPOSSIBLE. In 'Strengthen err n ρ the number -- n must be non-negative. This substitution should only be -- applied to values t for which none of the variables -- 0 up to n - 1 are free in t[ρ], and in that -- case n is subtracted from all free de Bruijn indices in -- t[ρ]. Γ ⊢ ρ : Δ |Θ| = n --------------------------- Γ ⊢ -- Strengthen n ρ : Δ, Θ @ Strengthen :: Impossible -> !Int -> Substitution' a -> Substitution' a -- | Weakening substitution, lifts to an extended context. Γ ⊢ ρ : Δ -- ------------------- Γ, Ψ ⊢ Wk |Ψ| ρ : Δ Wk :: !Int -> Substitution' a -> Substitution' a -- | Lifting substitution. Use this to go under a binder. Lift 1 ρ == -- var 0 :# Wk 1 ρ. Γ ⊢ ρ : Δ ------------------------- Γ, Ψρ ⊢ -- Lift |Ψ| ρ : Δ, Ψ Lift :: !Int -> Substitution' a -> Substitution' a infixr 4 :# type Substitution = Substitution' Term instance GHC.Base.Functor Agda.TypeChecking.Substitute.TelV instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Substitute.TelV a) instance (Agda.TypeChecking.Substitute.Class.TermSubst a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.TypeChecking.Substitute.TelV a) instance (Agda.TypeChecking.Substitute.Class.TermSubst a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.TypeChecking.Substitute.TelV a) instance GHC.Classes.Eq Agda.Syntax.Internal.Substitution instance GHC.Classes.Ord Agda.Syntax.Internal.Substitution instance GHC.Classes.Eq Agda.Syntax.Internal.Sort instance GHC.Classes.Ord Agda.Syntax.Internal.Sort instance GHC.Classes.Eq Agda.Syntax.Internal.Level instance GHC.Classes.Ord Agda.Syntax.Internal.Level instance GHC.Classes.Eq Agda.Syntax.Internal.PlusLevel instance GHC.Classes.Eq Agda.Syntax.Internal.NotBlocked instance GHC.Classes.Eq t => GHC.Classes.Eq (Agda.Syntax.Internal.Blocked t) instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CandidateKind instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Candidate instance (Agda.TypeChecking.Substitute.Class.Subst a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Internal.Tele a) instance (Agda.TypeChecking.Substitute.Class.Subst a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Internal.Tele a) instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Section instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Substitute.TeleNoAbs Agda.Syntax.Internal.ListTel instance Agda.TypeChecking.Substitute.TeleNoAbs Agda.Syntax.Internal.Telescope instance Agda.TypeChecking.Substitute.Class.Apply Agda.Syntax.Internal.Term instance Agda.TypeChecking.Substitute.Class.Apply Agda.Syntax.Internal.BraveTerm instance Agda.TypeChecking.Substitute.Class.Apply Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Substitute.Class.TermSubst a => Agda.TypeChecking.Substitute.Class.Apply (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.Definition instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.TypeChecking.Substitute.Class.Apply [Agda.TypeChecking.Positivity.Occurrence.Occurrence] instance Agda.TypeChecking.Substitute.Class.Apply [Agda.TypeChecking.Monad.Base.Polarity] instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.NumGeneralizableArgs instance Agda.TypeChecking.Substitute.Class.Apply [Agda.Syntax.Common.NamedArg (Agda.Syntax.Internal.Pattern' a)] instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.Projection instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.ProjLams instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.Defn instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.PrimFun instance Agda.TypeChecking.Substitute.Class.Apply Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.ExtLamInfo instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.System instance Agda.TypeChecking.Substitute.Class.Apply a => Agda.TypeChecking.Substitute.Class.Apply (Agda.TypeChecking.CompiledClause.WithArity a) instance Agda.TypeChecking.Substitute.Class.Apply a => Agda.TypeChecking.Substitute.Class.Apply (Agda.TypeChecking.CompiledClause.Case a) instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.FunctionInverse instance Agda.TypeChecking.Substitute.Class.Apply Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.TypeChecking.Substitute.Class.Apply t => Agda.TypeChecking.Substitute.Class.Apply [t] instance Agda.TypeChecking.Substitute.Class.Apply t => Agda.TypeChecking.Substitute.Class.Apply (Agda.Syntax.Internal.Blocked t) instance Agda.TypeChecking.Substitute.Class.Apply t => Agda.TypeChecking.Substitute.Class.Apply (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Substitute.Class.Apply t => Agda.TypeChecking.Substitute.Class.Apply (Data.Strict.Maybe.Maybe t) instance Agda.TypeChecking.Substitute.Class.Apply v => Agda.TypeChecking.Substitute.Class.Apply (Data.Map.Internal.Map k v) instance Agda.TypeChecking.Substitute.Class.Apply v => Agda.TypeChecking.Substitute.Class.Apply (Data.HashMap.Internal.HashMap k v) instance (Agda.TypeChecking.Substitute.Class.Apply a, Agda.TypeChecking.Substitute.Class.Apply b) => Agda.TypeChecking.Substitute.Class.Apply (a, b) instance (Agda.TypeChecking.Substitute.Class.Apply a, Agda.TypeChecking.Substitute.Class.Apply b, Agda.TypeChecking.Substitute.Class.Apply c) => Agda.TypeChecking.Substitute.Class.Apply (a, b, c) instance Agda.Utils.Permutation.DoDrop a => Agda.TypeChecking.Substitute.Class.Apply (Agda.Utils.Permutation.Drop a) instance Agda.Utils.Permutation.DoDrop a => Agda.TypeChecking.Substitute.Class.Abstract (Agda.Utils.Permutation.Drop a) instance Agda.TypeChecking.Substitute.Class.Apply Agda.Utils.Permutation.Permutation instance Agda.TypeChecking.Substitute.Class.Abstract Agda.Utils.Permutation.Permutation instance Agda.TypeChecking.Substitute.Class.Abstract Agda.Syntax.Internal.Term instance Agda.TypeChecking.Substitute.Class.Abstract Agda.Syntax.Internal.Type instance Agda.TypeChecking.Substitute.Class.Abstract Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Substitute.Class.Abstract Agda.Syntax.Internal.Telescope instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.Definition instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.TypeChecking.Substitute.Class.Abstract [Agda.TypeChecking.Positivity.Occurrence.Occurrence] instance Agda.TypeChecking.Substitute.Class.Abstract [Agda.TypeChecking.Monad.Base.Polarity] instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.NumGeneralizableArgs instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.Projection instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.ProjLams instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.System instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.Defn instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.PrimFun instance Agda.TypeChecking.Substitute.Class.Abstract Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.TypeChecking.Substitute.Class.Abstract a => Agda.TypeChecking.Substitute.Class.Abstract (Agda.TypeChecking.CompiledClause.WithArity a) instance Agda.TypeChecking.Substitute.Class.Abstract a => Agda.TypeChecking.Substitute.Class.Abstract (Agda.TypeChecking.CompiledClause.Case a) instance Agda.TypeChecking.Substitute.Class.Abstract Agda.TypeChecking.Monad.Base.FunctionInverse instance Agda.TypeChecking.Substitute.Class.Abstract t => Agda.TypeChecking.Substitute.Class.Abstract [t] instance Agda.TypeChecking.Substitute.Class.Abstract t => Agda.TypeChecking.Substitute.Class.Abstract (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Substitute.Class.Abstract v => Agda.TypeChecking.Substitute.Class.Abstract (Data.Map.Internal.Map k v) instance Agda.TypeChecking.Substitute.Class.Abstract v => Agda.TypeChecking.Substitute.Class.Abstract (Data.HashMap.Internal.HashMap k v) instance Agda.TypeChecking.Substitute.Class.EndoSubst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Substitution' a) instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.BraveTerm instance (GHC.Types.Coercible a Agda.Syntax.Internal.Term, Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Substitute.Class.Subst b, Agda.TypeChecking.Substitute.Class.SubstArg a GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg b) => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Type'' a b) instance (GHC.Types.Coercible a Agda.Syntax.Internal.Term, Agda.TypeChecking.Substitute.Class.Subst a) => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Sort' a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Level' a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.PlusLevel' a) instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Abstract.Name.Name instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.ConPatternInfo instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Pattern instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Abstract.ProblemEq instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Internal.BraveTerm instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Blocked a) instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Common.Named name a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Substitute.Class.Subst b, Agda.TypeChecking.Substitute.Class.SubstArg a GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg b) => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Internal.Dom' a b) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst [a] instance (GHC.Classes.Ord k, Agda.TypeChecking.Substitute.Class.Subst a) => Agda.TypeChecking.Substitute.Class.Subst (Data.Map.Internal.Map k a) instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.Syntax.Common.WithHiding a) instance Agda.TypeChecking.Substitute.Class.Subst () instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Substitute.Class.Subst b, Agda.TypeChecking.Substitute.Class.SubstArg a GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg b) => Agda.TypeChecking.Substitute.Class.Subst (a, b) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Substitute.Class.Subst b, Agda.TypeChecking.Substitute.Class.Subst c, Agda.TypeChecking.Substitute.Class.SubstArg a GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg b, Agda.TypeChecking.Substitute.Class.SubstArg b GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg c) => Agda.TypeChecking.Substitute.Class.Subst (a, b, c) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Substitute.Class.Subst b, Agda.TypeChecking.Substitute.Class.Subst c, Agda.TypeChecking.Substitute.Class.Subst d, Agda.TypeChecking.Substitute.Class.SubstArg a GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg b, Agda.TypeChecking.Substitute.Class.SubstArg b GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg c, Agda.TypeChecking.Substitute.Class.SubstArg c GHC.Types.~ Agda.TypeChecking.Substitute.Class.SubstArg d) => Agda.TypeChecking.Substitute.Class.Subst (a, b, c, d) instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.Candidate instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.EqualityTypeData instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn a => Agda.TypeChecking.Substitute.DeBruijn.DeBruijn (Agda.Syntax.Internal.Pattern' a) instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.DeBruijnPattern instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Position.Range instance GHC.Classes.Ord Agda.Syntax.Internal.PlusLevel instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Internal.Type' a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Syntax.Internal.Type' a) instance GHC.Classes.Eq Agda.Syntax.Internal.Term instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Internal.Pattern' a) instance GHC.Classes.Ord Agda.Syntax.Internal.Term instance (Agda.TypeChecking.Substitute.Class.Subst a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Internal.Abs a) instance (Agda.TypeChecking.Substitute.Class.Subst a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Internal.Abs a) instance (Agda.TypeChecking.Substitute.Class.Subst a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Internal.Elim.Elim' a) instance (Agda.TypeChecking.Substitute.Class.Subst a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Internal.Elim.Elim' a) module Agda.TypeChecking.Monad.Options -- | Sets the pragma options. setPragmaOptions :: PragmaOptions -> 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 -- then the state is reset (partly, see setIncludeDirs). -- -- An empty list of relative include directories (Left -- []) is interpreted as ["."]. setCommandLineOptions :: CommandLineOptions -> TCM () setCommandLineOptions' :: AbsolutePath -> CommandLineOptions -> TCM () libToTCM :: LibM a -> TCM a -- | Returns the library files for a given file. getAgdaLibFiles :: AbsolutePath -> TopLevelModuleName -> TCM [AgdaLibFile] -- | Returns the library options for a given file. getLibraryOptions :: AbsolutePath -> TopLevelModuleName -> TCM [OptionsPragma] setLibraryPaths :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions addDefaultLibraries :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions addTrustedExecutables :: CommandLineOptions -> TCM CommandLineOptions setOptionsFromPragma :: OptionsPragma -> TCM () -- | Disable display forms. enableDisplayForms :: MonadTCEnv m => m a -> m a -- | Disable display forms. disableDisplayForms :: MonadTCEnv m => m a -> m a -- | Check if display forms are enabled. displayFormsEnabled :: MonadTCEnv m => m Bool -- | Gets the include directories. -- -- Precondition: optAbsoluteIncludePaths must be nonempty (i.e. -- setCommandLineOptions must have run). getIncludeDirs :: HasOptions m => m [AbsolutePath] -- | Makes the given directories absolute and stores them as include -- directories. -- -- If the include directories change, then the state is reset -- (completely, except for the include directories and some other -- things). -- -- An empty list is interpreted as ["."]. setIncludeDirs :: [FilePath] -> AbsolutePath -> TCM () isPropEnabled :: HasOptions m => m Bool isTwoLevelEnabled :: HasOptions m => m Bool hasUniversePolymorphism :: HasOptions m => m Bool showImplicitArguments :: HasOptions m => m Bool showIrrelevantArguments :: HasOptions m => m Bool showIdentitySubstitutions :: HasOptions m => m Bool -- | 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 => m a -> m a withShowAllArguments' :: ReadTCState m => Bool -> m a -> m a -- | Change PragmaOptions for a computation and restore afterwards. withPragmaOptions :: ReadTCState m => (PragmaOptions -> PragmaOptions) -> m a -> m a positivityCheckEnabled :: HasOptions m => m Bool typeInType :: HasOptions m => m Bool etaEnabled :: HasOptions m => m Bool maxInstanceSearchDepth :: HasOptions m => m Int maxInversionDepth :: HasOptions m => m Int -- | Returns the Language currently in effect. getLanguage :: HasOptions m => m Language -- | Lenses for TCState and more. module Agda.TypeChecking.Monad.State -- | Resets the non-persistent part of the type checking state. resetState :: TCM () -- | Resets all of the type checking state. -- -- Keep only Benchmark and backend information. resetAllState :: TCM () -- | Restore TCState after performing subcomputation. -- -- In contrast to localState, the Benchmark info from the -- subcomputation is saved. localTCState :: TCM a -> TCM a -- | Same as localTCState but also returns the state in which we -- were just before reverting it. localTCStateSaving :: TCM a -> TCM (a, TCState) -- | Same as localTCState but keep all warnings. localTCStateSavingWarnings :: TCM a -> TCM a data SpeculateResult SpeculateAbort :: SpeculateResult SpeculateCommit :: SpeculateResult -- | Allow rolling back the state changes of a TCM computation. speculateTCState :: TCM (a, SpeculateResult) -> TCM a speculateTCState_ :: TCM SpeculateResult -> TCM () -- | 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.) freshTCM :: TCM a -> TCM (Either TCErr a) lensPersistentState :: Lens' PersistentTCState TCState updatePersistentState :: (PersistentTCState -> PersistentTCState) -> TCState -> TCState modifyPersistentState :: (PersistentTCState -> PersistentTCState) -> TCM () -- | Lens for stAccumStatistics. lensAccumStatisticsP :: Lens' Statistics PersistentTCState lensAccumStatistics :: Lens' Statistics TCState -- | Get the current scope. getScope :: ReadTCState m => m ScopeInfo -- | Set the current scope. setScope :: ScopeInfo -> TCM () -- | Modify the current scope without updating the inverse maps. modifyScope_ :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () -- | Modify the current scope. modifyScope :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () -- | Get a part of the current scope. useScope :: ReadTCState m => Lens' a ScopeInfo -> m a -- | Run a computation in a modified scope. locallyScope :: ReadTCState m => Lens' a ScopeInfo -> (a -> a) -> m b -> m b -- | Run a computation in a local scope. withScope :: ReadTCState m => ScopeInfo -> m a -> m (a, ScopeInfo) -- | Same as withScope, but discard the scope from the computation. withScope_ :: ReadTCState m => ScopeInfo -> m a -> m a -- | Discard any changes to the scope by a computation. localScope :: TCM a -> TCM a -- | Scope error. notInScopeError :: QName -> TCM a notInScopeWarning :: QName -> TCM () -- | Debug print the scope. printScope :: String -> Int -> String -> TCM () modifySignature :: MonadTCState m => (Signature -> Signature) -> m () modifyImportedSignature :: MonadTCState m => (Signature -> Signature) -> m () getSignature :: ReadTCState m => m Signature -- | 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. modifyGlobalDefinition :: MonadTCState m => QName -> (Definition -> Definition) -> m () setSignature :: MonadTCState m => Signature -> m () -- | Run some computation in a different signature, restore original -- signature. withSignature :: (ReadTCState m, MonadTCState m) => Signature -> m a -> m a addRewriteRulesFor :: QName -> RewriteRules -> [QName] -> Signature -> Signature setMatchableSymbols :: QName -> [QName] -> Signature -> Signature lookupDefinition :: QName -> Signature -> Maybe Definition updateDefinitions :: (Definitions -> Definitions) -> Signature -> Signature updateDefinition :: QName -> (Definition -> Definition) -> Signature -> Signature updateTheDef :: (Defn -> Defn) -> Definition -> Definition updateDefType :: (Type -> Type) -> Definition -> Definition updateDefArgOccurrences :: ([Occurrence] -> [Occurrence]) -> Definition -> Definition updateDefPolarity :: ([Polarity] -> [Polarity]) -> Definition -> Definition updateDefCompiledRep :: (CompiledRepresentation -> CompiledRepresentation) -> Definition -> Definition addCompilerPragma :: BackendName -> CompilerPragma -> Definition -> Definition updateFunClauses :: ([Clause] -> [Clause]) -> Defn -> Defn updateCovering :: ([Clause] -> [Clause]) -> Defn -> Defn updateCompiledClauses :: (Maybe CompiledClauses -> Maybe CompiledClauses) -> Defn -> Defn updateDefCopatternLHS :: (Bool -> Bool) -> Definition -> Definition updateDefBlocked :: (Blocked_ -> Blocked_) -> Definition -> Definition -- | Tries to convert a raw top-level module name to a top-level module -- name. topLevelModuleName :: RawTopLevelModuleName -> TCM TopLevelModuleName -- | Set the top-level module. This affects the global module id of freshly -- generated names. setTopLevelModule :: TopLevelModuleName -> TCM () -- | The name of the current top-level module, if any. currentTopLevelModule :: (MonadTCEnv m, ReadTCState m) => m (Maybe TopLevelModuleName) -- | Use a different top-level module for a computation. Used when -- generating names for imported modules. withTopLevelModule :: TopLevelModuleName -> TCM a -> TCM a currentModuleNameHash :: ReadTCState m => m ModuleNameHash addForeignCode :: BackendName -> String -> TCM () getInteractionOutputCallback :: ReadTCState m => m InteractionOutputCallback appInteractionOutputCallback :: Response -> TCM () setInteractionOutputCallback :: InteractionOutputCallback -> TCM () getPatternSyns :: ReadTCState m => m PatternSynDefns setPatternSyns :: PatternSynDefns -> TCM () -- | Lens for stPatternSyns. modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM () getPatternSynImports :: ReadTCState m => m PatternSynDefns -- | Get both local and imported pattern synonyms getAllPatternSyns :: ReadTCState m => m PatternSynDefns lookupPatternSyn :: AmbiguousQName -> TCM PatternSynDefn lookupSinglePatternSyn :: QName -> TCM PatternSynDefn -- | Lens getter for Benchmark from TCState. theBenchmark :: TCState -> Benchmark -- | Lens map for Benchmark. updateBenchmark :: (Benchmark -> Benchmark) -> TCState -> TCState -- | Lens getter for Benchmark from TCMT. getBenchmark :: TCM Benchmark -- | Lens modify for Benchmark. modifyBenchmark :: (Benchmark -> Benchmark) -> TCM () -- | Look through the signature and reconstruct the instance table. addImportedInstances :: Signature -> TCM () -- | Lens for stInstanceDefs. updateInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCState -> TCState modifyInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCM () getAllInstanceDefs :: TCM TempInstanceTable getAnonInstanceDefs :: TCM (Set QName) -- | Remove all instances whose type is still unresolved. clearAnonInstanceDefs :: TCM () -- | Add an instance whose type is still unresolved. addUnknownInstance :: QName -> TCM () -- | Add instance to some `class'. addNamedInstance :: QName -> QName -> TCM () module Agda.TypeChecking.Monad.Debug class (Functor m, Applicative m, Monad m) => MonadDebug m formatDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m String traceDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a -- | Print brackets around debug messages issued by a computation. verboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a getVerbosity :: MonadDebug m => m Verbosity getProfileOptions :: MonadDebug m => m ProfileOptions -- | Check whether we are currently debug printing. isDebugPrinting :: MonadDebug m => m Bool -- | Flag in a computation that we are currently debug printing. nowDebugPrinting :: MonadDebug m => m a -> m a formatDebugMessage :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> TCM Doc -> m String traceDebugMessage :: (MonadDebug m, MonadTransControl t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> String -> m a -> m a -- | Print brackets around debug messages issued by a computation. verboseBracket :: (MonadDebug m, MonadTransControl t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> String -> m a -> m a getVerbosity :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => m Verbosity getProfileOptions :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => m ProfileOptions -- | Check whether we are currently debug printing. isDebugPrinting :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => m Bool -- | Flag in a computation that we are currently debug printing. nowDebugPrinting :: (MonadDebug m, MonadTransControl t, MonadDebug n, m ~ t n) => m a -> m a -- | 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. class TraceS a traceS :: (TraceS a, MonadDebug m) => VerboseKey -> VerboseLevel -> a -> m c -> m c -- | 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. class ReportS a reportS :: (ReportS a, MonadDebug m) => VerboseKey -> VerboseLevel -> a -> m () defaultGetVerbosity :: HasOptions m => m Verbosity defaultGetProfileOptions :: HasOptions m => m ProfileOptions defaultIsDebugPrinting :: MonadTCEnv m => m Bool defaultNowDebugPrinting :: MonadTCEnv m => m a -> m a -- | Print a debug message if switched on. displayDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () -- | During printing, catch internal errors of kind Impossible and -- print them. catchAndPrintImpossible :: (CatchImpossible m, Monad m) => VerboseKey -> VerboseLevel -> m String -> m String -- | Conditionally println debug string. reportSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () __IMPOSSIBLE_VERBOSE__ :: (HasCallStack, MonadDebug m) => String -> m a -- | Conditionally render debug Doc and print it. reportSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m () -- | Debug print the result of a computation. reportResult :: MonadDebug m => VerboseKey -> VerboseLevel -> (a -> TCM Doc) -> m a -> m a unlessDebugPrinting :: MonadDebug m => m () -> m () traceSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a -- | Conditionally render debug Doc, print it, and then continue. traceSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m a -> m a openVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () closeVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> m () closeVerboseBracketException :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -- | Check whether a certain verbosity level is activated. -- -- Precondition: The level must be non-negative. hasVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool -- | Check whether a certain verbosity level is activated (exact match). hasExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool -- | Run a computation if a certain verbosity level is activated (exact -- match). whenExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () __CRASH_WHEN__ :: (HasCallStack, MonadTCM m, MonadDebug m) => VerboseKey -> VerboseLevel -> m () -- | Run a computation if a certain verbosity level is activated. -- -- Precondition: The level must be non-negative. verboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () -- | Apply a function 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 -- | Check whether a certain profile option is activated. hasProfileOption :: MonadDebug m => ProfileOption -> m Bool -- | Run some code when the given profiling option is active. whenProfile :: MonadDebug m => ProfileOption -> m () -> m () -- | Nothing is used if no verbosity options have been given, thus -- making it possible to handle the default case relatively quickly. Note -- that Nothing corresponds to a trie with verbosity level 1 for -- the empty path. type Verbosity = Maybe (Trie VerboseKeyItem VerboseLevel) type VerboseKey = String type VerboseLevel = Int instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Debug.TraceS (Agda.TypeChecking.Monad.Base.TCM Text.PrettyPrint.HughesPJ.Doc) instance Agda.TypeChecking.Monad.Debug.TraceS GHC.Base.String instance Agda.TypeChecking.Monad.Debug.TraceS [Agda.TypeChecking.Monad.Base.TCM Text.PrettyPrint.HughesPJ.Doc] instance Agda.TypeChecking.Monad.Debug.TraceS [GHC.Base.String] instance Agda.TypeChecking.Monad.Debug.TraceS [Text.PrettyPrint.HughesPJ.Doc] instance Agda.TypeChecking.Monad.Debug.TraceS Text.PrettyPrint.HughesPJ.Doc instance Agda.TypeChecking.Monad.Debug.ReportS (Agda.TypeChecking.Monad.Base.TCM Text.PrettyPrint.HughesPJ.Doc) instance Agda.TypeChecking.Monad.Debug.ReportS GHC.Base.String instance Agda.TypeChecking.Monad.Debug.ReportS [Agda.TypeChecking.Monad.Base.TCM Text.PrettyPrint.HughesPJ.Doc] instance Agda.TypeChecking.Monad.Debug.ReportS [GHC.Base.String] instance Agda.TypeChecking.Monad.Debug.ReportS [Text.PrettyPrint.HughesPJ.Doc] instance Agda.TypeChecking.Monad.Debug.ReportS Text.PrettyPrint.HughesPJ.Doc instance Agda.TypeChecking.Monad.Debug.MonadDebug Agda.TypeChecking.Monad.Base.TCM instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Agda.Utils.Update.ChangeT m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Control.Monad.Trans.Except.ExceptT e m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Control.Monad.Trans.State.Lazy.StateT s m) instance (Agda.TypeChecking.Monad.Debug.MonadDebug m, GHC.Base.Monoid w) => Agda.TypeChecking.Monad.Debug.MonadDebug (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Agda.Utils.ListT.ListT m) module Agda.TypeChecking.Monad.Base -- | Datatype representing a single boundary condition: x_0 = u_0, ... ,x_n -- = u_n ⊢ t = ?n es data IPBoundary' t IPBoundary :: [(t, t)] -> t -> t -> Overapplied -> IPBoundary' t -- | [ipbEquations] :: IPBoundary' t -> [(t, t)] -- |
--   t
--   
[ipbValue] :: IPBoundary' t -> t -- |
--   ?n es
--   
[ipbMetaApp] :: IPBoundary' t -> t -- | Is ?n overapplied in ?n es ? [ipbOverapplied] :: IPBoundary' t -> Overapplied -- | Polarity for equality and subtype checking. data Polarity -- | monotone Covariant :: Polarity -- | antitone Contravariant :: Polarity -- | no information (mixed variance) Invariant :: Polarity -- | constant Nonvariant :: Polarity data Comparison CmpEq :: Comparison CmpLeq :: Comparison type BackendName = String -- | Maps top-level module names to the corresponding source file names. type ModuleToSource = Map TopLevelModuleName AbsolutePath -- | Type checking monad. type TCM = TCMT IO -- | The type checking monad transformer. Adds readonly TCEnv and -- mutable TCState. newtype TCMT m a TCM :: (IORef TCState -> TCEnv -> m a) -> TCMT m a [unTCM] :: TCMT m a -> IORef TCState -> TCEnv -> m a data TCState TCSt :: !PreScopeState -> !PostScopeState -> !PersistentTCState -> TCState -- | The state which is frozen after scope checking. [stPreScopeState] :: TCState -> !PreScopeState -- | The state which is modified after scope checking. [stPostScopeState] :: TCState -> !PostScopeState -- | State which is forever, like a diamond. [stPersistentState] :: TCState -> !PersistentTCState data TCEnv TCEnv :: Context -> LetBindings -> ModuleName -> Maybe AbsolutePath -> [(ModuleName, Nat)] -> [TopLevelModuleName] -> Maybe MutualId -> TerminationCheck () -> CoverageCheck -> Bool -> Bool -> Bool -> Bool -> Bool -> Set ProblemId -> AbstractMode -> Modality -> Bool -> Bool -> Range -> Range -> IPClause -> Maybe (Closure Call) -> HighlightingLevel -> HighlightingMethod -> ExpandHidden -> Maybe QName -> Simplification -> AllowedReductions -> ReduceDefs -> Bool -> Int -> Bool -> Bool -> Bool -> Bool -> UnquoteFlags -> !Int -> Bool -> [QName] -> Bool -> CheckpointId -> Map CheckpointId Substitution -> DoGeneralize -> Map QName GeneralizedValue -> Maybe BackendName -> Bool -> Bool -> !Maybe Int -> TCEnv [envContext] :: TCEnv -> Context [envLetBindings] :: TCEnv -> LetBindings [envCurrentModule] :: TCEnv -> ModuleName -- | 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). [envCurrentPath] :: TCEnv -> Maybe AbsolutePath -- | anonymous modules and their number of free variables [envAnonymousModules] :: TCEnv -> [(ModuleName, Nat)] -- | The module stack with the entry being the top-level module as Agda -- chases modules. It will be empty if there is no main module, will have -- a single entry for the top level module, or more when descending past -- the main module. This is used to detect import cycles and in some -- cases highlighting behavior. The level of a given module is not -- necessarily the same as the length, in the module dependency graph, of -- the shortest path from the top-level module; it depends on in which -- order Agda chooses to chase dependencies. [envImportPath] :: TCEnv -> [TopLevelModuleName] -- | the current (if any) mutual block [envMutualBlock] :: TCEnv -> Maybe MutualId -- | are we inside the scope of a termination pragma [envTerminationCheck] :: TCEnv -> TerminationCheck () -- | are we inside the scope of a coverage pragma [envCoverageCheck] :: TCEnv -> CoverageCheck -- | are we inside a make-case (if so, ignore forcing analysis in unifier) [envMakeCase] :: TCEnv -> Bool -- | Are we currently in the process of solving active constraints? [envSolvingConstraints] :: TCEnv -> Bool -- | Have we stepped into the where-declarations of a clause? Everything -- under a where will be checked with this flag on. [envCheckingWhere] :: TCEnv -> Bool -- | Are we working on types? Turned on by workOnTypes. [envWorkingOnTypes] :: TCEnv -> Bool -- | Are we allowed to assign metas? [envAssignMetas] :: TCEnv -> Bool [envActiveProblems] :: TCEnv -> Set ProblemId -- | 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. [envAbstractMode] :: TCEnv -> AbstractMode -- | 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. [envModality] :: TCEnv -> Modality -- | Are we currently case-splitting on a strict datatype (i.e. in SSet)? -- If yes, the pattern-matching unifier will solve reflexive equations -- even --without-K. [envSplitOnStrict] :: TCEnv -> Bool -- | Sometimes we want to disable display forms. [envDisplayFormsEnabled] :: TCEnv -> Bool [envRange] :: TCEnv -> Range -- | Interactive highlighting uses this range rather than envRange. [envHighlightingRange] :: TCEnv -> Range -- | What is the current clause we are type-checking? Will be recorded in -- interaction points in this clause. [envClause] :: TCEnv -> IPClause -- | what we're doing at the moment [envCall] :: TCEnv -> Maybe (Closure Call) -- | Set to None when imported modules are type-checked. [envHighlightingLevel] :: TCEnv -> HighlightingLevel [envHighlightingMethod] :: TCEnv -> HighlightingMethod -- | When type-checking an alias f=e, we do not want to insert hidden -- arguments in the end, because these will become unsolved metas. [envExpandLast] :: TCEnv -> ExpandHidden -- | We are reducing an application of this function. (For tracking of -- incomplete matches.) [envAppDef] :: TCEnv -> Maybe QName -- | Did we encounter a simplification (proper match) during the current -- reduction process? [envSimplification] :: TCEnv -> Simplification [envAllowedReductions] :: TCEnv -> AllowedReductions [envReduceDefs] :: TCEnv -> ReduceDefs [envReconstructed] :: TCEnv -> Bool -- | Injectivity can cause non-termination for unsolvable contraints (#431, -- #3067). Keep a limit on the nesting depth of injectivity uses. [envInjectivityDepth] :: TCEnv -> Int -- | 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. [envCompareBlocked] :: TCEnv -> Bool -- | When True, types will be omitted from printed pi types if -- they can be inferred. [envPrintDomainFreePi] :: TCEnv -> 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. [envPrintMetasBare] :: TCEnv -> 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. [envInsideDotPattern] :: TCEnv -> Bool [envUnquoteFlags] :: TCEnv -> UnquoteFlags -- | Until we get a termination checker for instance search (#1743) we -- limit the search depth to ensure termination. [envInstanceDepth] :: TCEnv -> !Int [envIsDebugPrinting] :: TCEnv -> Bool -- | #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. [envPrintingPatternLambdas] :: TCEnv -> [QName] -- | Use call-by-need evaluation for reductions. [envCallByNeed] :: TCEnv -> Bool -- | Checkpoints track the evolution of the context as we go under binders -- or refine it by pattern matching. [envCurrentCheckpoint] :: TCEnv -> CheckpointId -- | Keeps the substitution from each previous checkpoint to the current -- context. [envCheckpoints] :: TCEnv -> Map CheckpointId Substitution -- | Should new metas generalized over. [envGeneralizeMetas] :: TCEnv -> DoGeneralize -- | Values for used generalizable variables. [envGeneralizedVars] :: TCEnv -> Map QName GeneralizedValue -- | 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. [envActiveBackendName] :: TCEnv -> Maybe BackendName -- | Are we currently computing the overlap between two rewrite rules for -- the purpose of confluence checking? [envConflComputingOverlap] :: TCEnv -> Bool -- | Are we currently in the process of executing an elaborate-and-give -- interactive command? [envCurrentlyElaborating] :: TCEnv -> Bool -- | If this counter is Nothing, then syntactic equality checking is -- unrestricted. If it is zero, then syntactic equality checking is not -- run at all. If it is a positive number, then syntactic equality -- checking is allowed to run, but the counter is decreased in the -- failure continuation of checkSyntacticEquality. [envSyntacticEqualityFuel] :: TCEnv -> !Maybe Int -- | How much highlighting should be sent to the user interface? data HighlightingLevel None :: HighlightingLevel NonInteractive :: HighlightingLevel -- | This includes both non-interactive highlighting and interactive -- highlighting of the expression that is currently being type-checked. Interactive :: HighlightingLevel -- | How should highlighting be sent to the user interface? data HighlightingMethod -- | Via stdout. Direct :: HighlightingMethod -- | Both via files and via stdout. Indirect :: HighlightingMethod -- | For printing, we couple a meta with its name suggestion. data NamedMeta NamedMeta :: MetaNameSuggestion -> MetaId -> NamedMeta [nmSuggestion] :: NamedMeta -> MetaNameSuggestion [nmid] :: NamedMeta -> MetaId data TCWarning TCWarning :: CallStack -> Range -> Warning -> Doc -> Bool -> TCWarning -- | Location in the internal Agda source code location where the error -- raised [tcWarningLocation] :: TCWarning -> CallStack -- | Range where the warning was raised [tcWarningRange] :: TCWarning -> Range -- | The warning itself [tcWarning] :: TCWarning -> Warning -- | The warning printed in the state and environment where it was raised [tcWarningPrintedWarning] :: TCWarning -> Doc -- | Should the warning be affected by caching. [tcWarningCached] :: TCWarning -> Bool -- | Type-checking errors. data TCErr TypeError :: CallStack -> TCState -> Closure TypeError -> TCErr -- | Location in the internal Agda source code where the error was raised [tcErrLocation] :: TCErr -> CallStack -- | The state in which the error was raised. [tcErrState] :: TCErr -> TCState -- | The environment in which the error as raised plus the error. [tcErrClosErr] :: TCErr -> Closure TypeError Exception :: Range -> Doc -> TCErr -- | The first argument is the state in which the error was raised. IOException :: TCState -> Range -> IOException -> TCErr -- | The exception which is usually caught. Raised for pattern violations -- during unification (assignV) but also in other situations -- where we want to backtrack. Contains an unblocker to control when the -- computation should be retried. PatternErr :: Blocker -> TCErr -- | A non-fatal error is an error which does not prevent us from checking -- the document further and interacting with the user. data Warning NicifierIssue :: DeclarationWarning -> Warning TerminationIssue :: [TerminationError] -> Warning -- | `UnreachableClauses f rs` means that the clauses in f whose -- ranges are rs are unreachable UnreachableClauses :: QName -> [Range] -> Warning -- | `CoverageIssue f pss` means that pss are not covered in -- f CoverageIssue :: QName -> [(Telescope, [NamedArg DeBruijnPattern])] -> Warning CoverageNoExactSplit :: QName -> [Clause] -> Warning NotStrictlyPositive :: QName -> Seq OccursWhere -> Warning -- | Do not use directly with warning UnsolvedMetaVariables :: [Range] -> Warning -- | Do not use directly with warning UnsolvedInteractionMetas :: [Range] -> Warning -- | Do not use directly with warning UnsolvedConstraints :: Constraints -> Warning CantGeneralizeOverSorts :: [MetaId] -> Warning AbsurdPatternRequiresNoRHS :: [NamedArg DeBruijnPattern] -> Warning -- | In `OldBuiltin old new`, the BUILTIN old has been replaced by new OldBuiltin :: String -> String -> Warning -- | If the user wrote just {-# REWRITE #-}. EmptyRewritePragma :: Warning -- | An empty where block is dead code. EmptyWhere :: Warning -- | If the user wrote something other than an unqualified name in the -- as clause of an import statement. The String -- gives optionally extra explanation. IllformedAsClause :: String -> Warning -- | If a renaming import directive introduces a name or module -- name clash in the exported names of a module. (See issue #4154.) ClashesViaRenaming :: NameOrModule -> [Name] -> Warning -- | The 'pattern' declaration is useless in the presence of either -- coinductive or eta-equality. Content of -- String is "coinductive" or "eta", resp. UselessPatternDeclarationForRecord :: String -> Warning -- | If the user opens a module public before the module header. (See issue -- #2377.) UselessPublic :: Warning -- | Names in hiding directive that don't hide anything imported by -- a using directive. UselessHiding :: [ImportedName] -> Warning UselessInline :: QName -> Warning WrongInstanceDeclaration :: Warning -- | An instance was declared with an implicit argument, which means it -- will never actually be considered by instance search. InstanceWithExplicitArg :: QName -> Warning -- | The type of an instance argument doesn't end in a named or variable -- type, so it will never be considered by instance search. InstanceNoOutputTypeName :: Doc -> Warning -- | As InstanceWithExplicitArg, but for local bindings rather than -- top-level instances. InstanceArgWithExplicitArg :: Doc -> Warning -- | The --inversion-max-depth was reached. InversionDepthReached :: QName -> Warning -- | A coinductive record was declared but neither --guardedness nor -- --sized-types is enabled. NoGuardednessFlag :: QName -> Warning -- | Harmless generic warning (not an error) GenericWarning :: Doc -> Warning -- | Generic error which doesn't abort proceedings (not a warning) GenericNonFatalError :: Doc -> Warning -- | Generic warning when code is useless and thus ignored. Range' -- is for dead code highlighting. GenericUseless :: Range -> Doc -> Warning SafeFlagPostulate :: Name -> Warning -- | Unsafe OPTIONS. SafeFlagPragma :: [String] -> Warning SafeFlagNonTerminating :: Warning SafeFlagTerminating :: Warning SafeFlagWithoutKFlagPrimEraseEquality :: Warning WithoutKFlagPrimEraseEquality :: Warning SafeFlagNoPositivityCheck :: Warning SafeFlagPolarity :: Warning SafeFlagNoUniverseCheck :: Warning SafeFlagNoCoverageCheck :: Warning SafeFlagInjective :: Warning -- | ETA pragma is unsafe. SafeFlagEta :: Warning ParseWarning :: ParseWarning -> Warning LibraryWarning :: LibWarning -> Warning -- | `DeprecationWarning old new version`: old is deprecated, use -- new instead. This will be an error in Agda version. DeprecationWarning :: String -> String -> String -> Warning -- | User-defined warning (e.g. to mention that a name is deprecated) UserWarning :: Text -> Warning -- | Duplicate mentions of the same name in using directive(s). DuplicateUsing :: List1 ImportedName -> Warning -- | Fixity of modules cannot be changed via renaming (since modules have -- no fixity). FixityInRenamingModule :: List1 Range -> Warning -- | Some imported names are not actually exported by the source module. -- The second argument is the names that could be exported. The third -- argument is the module names that could be exported. ModuleDoesntExport :: QName -> [Name] -> [Name] -> [ImportedName] -> Warning -- | Importing a file using an infective option into one which doesn't InfectiveImport :: Doc -> Warning -- | Importing a file not using a coinfective option from one which does CoInfectiveImport :: Doc -> Warning -- | Confluence checker found critical pair and equality checking resulted -- in a type error RewriteNonConfluent :: Term -> Term -> Term -> Doc -> Warning -- | Confluence checker got stuck on computing overlap between two rewrite -- rules RewriteMaybeNonConfluent :: Term -> Term -> [Doc] -> Warning -- | The global confluence checker found a term u that reduces to -- both v1 and v2 and there is no rule to resolve the -- ambiguity. RewriteAmbiguousRules :: Term -> Term -> Term -> Warning -- | The global confluence checker found a term u that reduces to -- v, but v does not reduce to rho(u). RewriteMissingRule :: Term -> Term -> Term -> Warning -- | COMPILE directive for an erased symbol PragmaCompileErased :: BackendName -> QName -> Warning -- | Out of scope error we can recover from NotInScopeW :: [QName] -> Warning -- | Was not able to compute a full equivalence when splitting. UnsupportedIndexedMatch :: Doc -> Warning -- | The as-name in an as-pattern may not shadow a constructor -- (False) or pattern synonym name (True), because this -- can be confusing to read. AsPatternShadowsConstructorOrPatternSynonym :: Bool -> Warning RecordFieldWarning :: RecordFieldWarning -> Warning -- | The constraints needed for typeError and similar. type MonadTCError m = (MonadTCEnv m, ReadTCState m, MonadError TCErr m) -- | Embedding a TCM computation. class (Applicative tcm, MonadIO tcm, MonadTCEnv tcm, MonadTCState tcm, HasOptions tcm) => MonadTCM tcm liftTCM :: MonadTCM tcm => TCM a -> tcm a liftTCM :: (MonadTCM tcm, MonadTCM m, MonadTrans t, tcm ~ t m) => TCM a -> tcm a newtype BlockT m a BlockT :: ExceptT Blocker m a -> BlockT m a [unBlockT] :: BlockT m a -> ExceptT Blocker m a class Monad m => MonadBlock m -- | `patternViolation b` aborts the current computation patternViolation :: MonadBlock m => Blocker -> m a -- | `patternViolation b` aborts the current computation patternViolation :: (MonadBlock m, MonadTrans t, MonadBlock n, m ~ t n) => Blocker -> m a -- | `catchPatternErr handle m` runs m, handling pattern violations with -- handle (doesn't roll back the state) catchPatternErr :: MonadBlock m => (Blocker -> m a) -> m a -> m a -- | MonadTCState made into its own dedicated service class. This -- allows us to use MonadState for StateT extensions of -- TCM. class Monad m => MonadTCState m getTC :: MonadTCState m => m TCState putTC :: MonadTCState m => TCState -> m () modifyTC :: MonadTCState m => (TCState -> TCState) -> m () getTC :: (MonadTCState m, MonadTrans t, MonadTCState n, t n ~ m) => m TCState putTC :: (MonadTCState m, MonadTrans t, MonadTCState n, t n ~ m) => TCState -> m () modifyTC :: (MonadTCState m, MonadTrans t, MonadTCState n, t n ~ m) => (TCState -> TCState) -> m () -- | MonadTCEnv made into its own dedicated service class. This -- allows us to use MonadReader for ReaderT extensions of -- TCM. class Monad m => MonadTCEnv m askTC :: MonadTCEnv m => m TCEnv localTC :: MonadTCEnv m => (TCEnv -> TCEnv) -> m a -> m a askTC :: (MonadTCEnv m, MonadTrans t, MonadTCEnv n, t n ~ m) => m TCEnv localTC :: (MonadTCEnv m, MonadTransControl t, MonadTCEnv n, t n ~ m) => (TCEnv -> TCEnv) -> m a -> m a class (Applicative m, MonadTCEnv m, ReadTCState m, HasOptions m) => MonadReduce m liftReduce :: MonadReduce m => ReduceM a -> m a liftReduce :: (MonadReduce m, MonadTrans t, MonadReduce n, t n ~ m) => ReduceM a -> m a newtype ReduceM a ReduceM :: (ReduceEnv -> a) -> ReduceM a [unReduceM] :: ReduceM a -> ReduceEnv -> a -- | Environment of the reduce monad. data ReduceEnv ReduceEnv :: TCEnv -> TCState -> Maybe (MetaId -> ReduceM Bool) -> ReduceEnv -- | Read only access to environment. [redEnv] :: ReduceEnv -> TCEnv -- | Read only access to state (signature, metas...). [redSt] :: ReduceEnv -> TCState -- | An optional predicate that is used by instantiate' and -- instantiateFull': meta-variables are only instantiated if -- they satisfy this predicate. [redPred] :: ReduceEnv -> Maybe (MetaId -> ReduceM Bool) -- | Distinguish error message when parsing lhs or pattern synonym, resp. data LHSOrPatSyn IsLHS :: LHSOrPatSyn IsPatSyn :: LHSOrPatSyn data TypeError InternalError :: String -> TypeError NotImplemented :: String -> TypeError NotSupported :: String -> TypeError CompilationError :: String -> TypeError PropMustBeSingleton :: TypeError DataMustEndInSort :: Term -> TypeError -- | The target of a constructor isn't an application of its datatype. The -- Type records what it does target. ShouldEndInApplicationOfTheDatatype :: Type -> TypeError -- | 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. ShouldBeAppliedToTheDatatypeParameters :: Term -> Term -> TypeError -- | Expected a type to be an application of a particular datatype. ShouldBeApplicationOf :: Type -> QName -> TypeError -- | constructor, datatype ConstructorPatternInWrongDatatype :: QName -> QName -> TypeError -- | Datatype, constructors. CantResolveOverloadedConstructorsTargetingSameDatatype :: QName -> List1 QName -> TypeError -- | constructor, type DoesNotConstructAnElementOf :: QName -> Type -> TypeError -- | The left hand side of a function definition has a hidden argument -- where a non-hidden was expected. WrongHidingInLHS :: TypeError -- | Expected a non-hidden function and found a hidden lambda. WrongHidingInLambda :: Type -> TypeError -- | A function is applied to a hidden argument where a non-hidden was -- expected. WrongHidingInApplication :: Type -> TypeError -- | A function is applied to a hidden named argument it does not have. The -- list contains names of possible hidden arguments at this point. WrongNamedArgument :: NamedArg Expr -> [NamedName] -> TypeError -- | Wrong user-given relevance annotation in lambda. WrongIrrelevanceInLambda :: TypeError -- | Wrong user-given quantity annotation in lambda. WrongQuantityInLambda :: TypeError -- | Wrong user-given cohesion annotation in lambda. WrongCohesionInLambda :: TypeError -- | The given quantity does not correspond to the expected quantity. QuantityMismatch :: Quantity -> Quantity -> TypeError -- | The given hiding does not correspond to the expected hiding. HidingMismatch :: Hiding -> Hiding -> TypeError -- | The given relevance does not correspond to the expected relevane. RelevanceMismatch :: Relevance -> Relevance -> TypeError UninstantiatedDotPattern :: Expr -> TypeError ForcedConstructorNotInstantiated :: Pattern -> TypeError IllformedProjectionPattern :: Pattern -> TypeError CannotEliminateWithPattern :: Maybe Blocker -> NamedArg Pattern -> Type -> TypeError WrongNumberOfConstructorArguments :: QName -> Nat -> Nat -> TypeError ShouldBeEmpty :: Type -> [DeBruijnPattern] -> TypeError -- | The given type should have been a sort. ShouldBeASort :: Type -> TypeError -- | The given type should have been a pi. ShouldBePi :: Type -> TypeError ShouldBePath :: Type -> TypeError ShouldBeRecordType :: Type -> TypeError ShouldBeRecordPattern :: DeBruijnPattern -> TypeError NotAProjectionPattern :: NamedArg Pattern -> TypeError NotAProperTerm :: TypeError -- | This sort is not a type expression. InvalidTypeSort :: Sort -> TypeError -- | This term is not a type expression. InvalidType :: Term -> TypeError -- | This term, a function type constructor, lives in SizeUniv, -- which is not allowed. FunctionTypeInSizeUniv :: Term -> TypeError SplitOnIrrelevant :: Dom Type -> TypeError SplitOnUnusableCohesion :: Dom Type -> TypeError SplitOnNonVariable :: Term -> Type -> TypeError SplitOnNonEtaRecord :: QName -> TypeError DefinitionIsIrrelevant :: QName -> TypeError DefinitionIsErased :: QName -> TypeError VariableIsIrrelevant :: Name -> TypeError VariableIsErased :: Name -> TypeError VariableIsOfUnusableCohesion :: Name -> Cohesion -> TypeError UnequalLevel :: Comparison -> Level -> Level -> TypeError UnequalTerms :: Comparison -> Term -> Term -> CompareAs -> TypeError UnequalTypes :: Comparison -> Type -> Type -> TypeError -- | The two function types have different relevance. UnequalRelevance :: Comparison -> Term -> Term -> TypeError -- | The two function types have different relevance. UnequalQuantity :: Comparison -> Term -> Term -> TypeError -- | The two function types have different cohesion. UnequalCohesion :: Comparison -> Term -> Term -> TypeError -- | One of the function types has a finite domain (i.e. is a -- Partial@) and the other isonot. UnequalFiniteness :: Comparison -> Term -> Term -> TypeError -- | The two function types have different hiding. UnequalHiding :: Term -> Term -> TypeError UnequalSorts :: Sort -> Sort -> TypeError UnequalBecauseOfUniverseConflict :: Comparison -> Term -> Term -> TypeError NotLeqSort :: Sort -> Sort -> TypeError -- | The arguments are the meta variable and the parameter that it wants to -- depend on. MetaCannotDependOn :: MetaId -> Nat -> TypeError MetaOccursInItself :: MetaId -> TypeError MetaIrrelevantSolution :: MetaId -> Term -> TypeError MetaErasedSolution :: MetaId -> Term -> TypeError GenericError :: String -> TypeError GenericDocError :: Doc -> TypeError -- | the meta is what we might be blocked on. SortOfSplitVarError :: Maybe Blocker -> Doc -> TypeError BuiltinMustBeConstructor :: String -> Expr -> TypeError NoSuchBuiltinName :: String -> TypeError DuplicateBuiltinBinding :: String -> Term -> Term -> TypeError NoBindingForBuiltin :: String -> TypeError NoSuchPrimitiveFunction :: String -> TypeError DuplicatePrimitiveBinding :: String -> QName -> QName -> TypeError WrongModalityForPrimitive :: String -> ArgInfo -> ArgInfo -> TypeError ShadowedModule :: Name -> [ModuleName] -> TypeError BuiltinInParameterisedModule :: String -> TypeError IllegalLetInTelescope :: TypedBinding -> TypeError IllegalPatternInTelescope :: Binder -> TypeError NoRHSRequiresAbsurdPattern :: [NamedArg Pattern] -> TypeError -- | Record type, fields not supplied by user, non-fields but supplied. TooManyFields :: QName -> [Name] -> [Name] -> TypeError DuplicateFields :: [Name] -> TypeError DuplicateConstructors :: [Name] -> TypeError WithOnFreeVariable :: Expr -> Term -> TypeError UnexpectedWithPatterns :: [Pattern] -> TypeError WithClausePatternMismatch :: Pattern -> NamedArg DeBruijnPattern -> TypeError FieldOutsideRecord :: TypeError ModuleArityMismatch :: ModuleName -> Telescope -> [NamedArg Expr] -> TypeError GeneralizeCyclicDependency :: TypeError GeneralizeUnsolvedMeta :: TypeError SplitError :: SplitError -> TypeError ImpossibleConstructor :: QName -> NegativeUnification -> TypeError TooManyPolarities :: QName -> Int -> TypeError LocalVsImportedModuleClash :: ModuleName -> TypeError -- | 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. SolvedButOpenHoles :: TypeError CyclicModuleDependency :: [TopLevelModuleName] -> TypeError FileNotFound :: TopLevelModuleName -> [AbsolutePath] -> TypeError OverlappingProjects :: AbsolutePath -> TopLevelModuleName -> TopLevelModuleName -> TypeError AmbiguousTopLevelModuleName :: TopLevelModuleName -> [AbsolutePath] -> TypeError -- | Found module name, expected module name. ModuleNameUnexpected :: TopLevelModuleName -> TopLevelModuleName -> TypeError ModuleNameDoesntMatchFileName :: TopLevelModuleName -> [AbsolutePath] -> TypeError ClashingFileNamesFor :: ModuleName -> [AbsolutePath] -> TypeError -- | Module name, file from which it was loaded, file which the include -- path says contains the module. Scope errors ModuleDefinedInOtherFile :: TopLevelModuleName -> AbsolutePath -> AbsolutePath -> TypeError BothWithAndRHS :: TypeError AbstractConstructorNotInScope :: QName -> TypeError NotInScope :: [QName] -> TypeError NoSuchModule :: QName -> TypeError AmbiguousName :: QName -> AmbiguousNameReason -> TypeError AmbiguousModule :: QName -> List1 ModuleName -> TypeError ClashingDefinition :: QName -> QName -> Maybe NiceDeclaration -> TypeError ClashingModule :: ModuleName -> ModuleName -> TypeError ClashingImport :: Name -> QName -> TypeError ClashingModuleImport :: Name -> ModuleName -> TypeError PatternShadowsConstructor :: Name -> QName -> TypeError DuplicateImports :: QName -> [ImportedName] -> TypeError InvalidPattern :: Pattern -> TypeError RepeatedVariablesInPattern :: [Name] -> TypeError GeneralizeNotSupportedHere :: QName -> TypeError MultipleFixityDecls :: [(Name, [Fixity'])] -> TypeError MultiplePolarityPragmas :: [Name] -> TypeError -- | The expr was used in the right hand side of an implicit module -- definition, but it wasn't of the form m Delta. NotAModuleExpr :: Expr -> TypeError NotAnExpression :: Expr -> TypeError NotAValidLetBinding :: NiceDeclaration -> TypeError NotValidBeforeField :: NiceDeclaration -> TypeError NothingAppliedToHiddenArg :: Expr -> TypeError NothingAppliedToInstanceArg :: Expr -> TypeError BadArgumentsToPatternSynonym :: AmbiguousQName -> TypeError TooFewArgumentsToPatternSynonym :: AmbiguousQName -> TypeError CannotResolveAmbiguousPatternSynonym :: List1 (QName, PatternSynDefn) -> TypeError UnusedVariableInPatternSynonym :: TypeError NoParseForApplication :: List2 Expr -> TypeError AmbiguousParseForApplication :: List2 Expr -> List1 Expr -> TypeError -- | The list contains patterns that failed to be interpreted. If it is -- non-empty, the first entry could be printed as error hint. NoParseForLHS :: LHSOrPatSyn -> [Pattern] -> Pattern -> TypeError -- | Pattern and its possible interpretations. AmbiguousParseForLHS :: LHSOrPatSyn -> Pattern -> [Pattern] -> TypeError OperatorInformation :: [NotationSection] -> TypeError -> TypeError InstanceNoCandidate :: Type -> [(Term, TCErr)] -> TypeError UnquoteFailed :: UnquoteError -> TypeError DeBruijnIndexOutOfScope :: Nat -> Telescope -> [Name] -> TypeError NeedOptionCopatterns :: TypeError NeedOptionRewriting :: TypeError NeedOptionProp :: TypeError NeedOptionTwoLevel :: TypeError NonFatalErrors :: [TCWarning] -> TypeError InstanceSearchDepthExhausted :: Term -> Type -> Int -> TypeError TriedToCopyConstrainedPrim :: QName -> TypeError data UnquoteError BadVisibility :: String -> Arg Term -> UnquoteError ConInsteadOfDef :: QName -> String -> String -> UnquoteError DefInsteadOfCon :: QName -> String -> String -> UnquoteError NonCanonical :: String -> Term -> UnquoteError BlockedOnMeta :: TCState -> Blocker -> UnquoteError UnquotePanic :: String -> UnquoteError data UnificationFailure -- | Failed to apply injectivity to constructor of indexed datatype UnifyIndicesNotVars :: Telescope -> Type -> Term -> Term -> Args -> UnificationFailure -- | Can't solve equation because variable occurs in (type of) lhs UnifyRecursiveEq :: Telescope -> Type -> Int -> Term -> UnificationFailure -- | Can't solve reflexive equation because --without-K is enabled UnifyReflexiveEq :: Telescope -> Type -> Term -> UnificationFailure -- | Can't solve equation because solution modality is less "usable" UnifyUnusableModality :: Telescope -> Type -> Int -> Term -> Modality -> UnificationFailure data NegativeUnification UnifyConflict :: Telescope -> Term -> Term -> NegativeUnification UnifyCycle :: Telescope -> Int -> Term -> NegativeUnification -- | Error when splitting a pattern variable into possible constructor -- patterns. data SplitError -- | Neither data type nor record. NotADatatype :: Closure Type -> SplitError -- | Type could not be sufficiently reduced. BlockedType :: Blocker -> Closure Type -> SplitError -- | 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. ErasedDatatype :: Bool -> Closure Type -> SplitError -- | Split on codata not allowed. UNUSED, but keep! -- | -- NoRecordConstructor Type -- ^ record type, but no constructor CoinductiveDatatype :: Closure Type -> SplitError UnificationStuck :: Maybe Blocker -> QName -> Telescope -> Args -> Args -> [UnificationFailure] -> SplitError -- | Blocking metavariable (if any) [cantSplitBlocker] :: SplitError -> Maybe Blocker -- | Constructor. [cantSplitConName] :: SplitError -> QName -- | Context for indices. [cantSplitTel] :: SplitError -> Telescope -- | Inferred indices (from type of constructor). [cantSplitConIdx] :: SplitError -> Args -- | Expected indices (from checking pattern). [cantSplitGivenIdx] :: SplitError -> Args -- | Reason(s) why unification got stuck. [cantSplitFailures] :: SplitError -> [UnificationFailure] -- | Copattern split with a catchall CosplitCatchall :: SplitError -- | We do not know the target type of the clause. CosplitNoTarget :: SplitError -- | Target type is not a record type. CosplitNoRecordType :: Closure Type -> SplitError CannotCreateMissingClause :: QName -> (Telescope, [NamedArg DeBruijnPattern]) -> Doc -> Closure (Abs Type) -> SplitError GenericSplitError :: String -> SplitError -- | Information about a mutual block which did not pass the termination -- checker. data TerminationError TerminationError :: [QName] -> [CallInfo] -> TerminationError -- | The functions which failed to check. (May not include automatically -- generated functions.) [termErrFunctions] :: TerminationError -> [QName] -- | The problematic call sites. [termErrCalls] :: TerminationError -> [CallInfo] -- | Information about a call. data CallInfo CallInfo :: QName -> Closure Term -> CallInfo -- | Target function name. (Contains its range.) [callInfoTarget] :: CallInfo -> QName -- | To be formatted representation of the call. [callInfoCall] :: CallInfo -> Closure Term data RecordFieldWarning -- | Each redundant field comes with a range of associated dead code. DuplicateFieldsWarning :: [(Name, Range)] -> RecordFieldWarning -- | Record type, fields not supplied by user, non-fields but supplied. The -- redundant fields come with a range of associated dead code. TooManyFieldsWarning :: QName -> [Name] -> [(Name, Range)] -> RecordFieldWarning data ArgsCheckState a ACState :: [Maybe Range] -> Elims -> [Maybe (Abs Constraint)] -> Type -> a -> ArgsCheckState a -- | Ranges of checked arguments, where present. e.g. inserted implicits -- have no correponding abstract syntax. [acRanges] :: ArgsCheckState a -> [Maybe Range] -- | Checked and inserted arguments so far. [acElims] :: ArgsCheckState a -> Elims -- | Constraints for the head so far, i.e. before applying the correponding -- elim. [acConstraints] :: ArgsCheckState a -> [Maybe (Abs Constraint)] -- | Type for the rest of the application. [acType] :: ArgsCheckState a -> Type [acData] :: ArgsCheckState a -> a -- | A candidate solution for an instance meta is a term with its type. It -- may be the case that the candidate is not fully applied yet or of the -- wrong type, hence the need for the type. data Candidate Candidate :: CandidateKind -> Term -> Type -> Bool -> Candidate [candidateKind] :: Candidate -> CandidateKind [candidateTerm] :: Candidate -> Term [candidateType] :: Candidate -> Type [candidateOverlappable] :: Candidate -> Bool data CandidateKind LocalCandidate :: CandidateKind GlobalCandidate :: QName -> CandidateKind data ExpandHidden -- | Add implicit arguments in the end until type is no longer hidden -- Pi. ExpandLast :: ExpandHidden -- | Do not append implicit arguments. DontExpandLast :: ExpandHidden -- | Makes doExpandLast have no effect. Used to avoid implicit -- insertion of arguments to metavariables. ReallyDontExpandLast :: ExpandHidden data AbstractMode -- | Abstract things in the current module can be accessed. AbstractMode :: AbstractMode -- | No abstract things can be accessed. ConcreteMode :: AbstractMode -- | All abstract things can be accessed. IgnoreAbstractMode :: AbstractMode type LetBindings = Map Name (Open (Term, Dom Type)) type ContextEntry = Dom (Name, Type) -- | The Context is a stack of ContextEntrys. type Context = [ContextEntry] data UnquoteFlags UnquoteFlags :: Bool -> UnquoteFlags [_unquoteNormalise] :: UnquoteFlags -> Bool class LensTCEnv a lensTCEnv :: LensTCEnv a => Lens' TCEnv a data Builtin pf Builtin :: Term -> Builtin pf Prim :: pf -> Builtin pf -- | BUILTIN REWRITE. We can have several rewrite relations. BuiltinRewriteRelations :: Set QName -> Builtin pf type BuiltinThings pf = Map String (Builtin pf) data BuiltinInfo BuiltinInfo :: String -> BuiltinDescriptor -> BuiltinInfo [builtinName] :: BuiltinInfo -> String [builtinDesc] :: BuiltinInfo -> BuiltinDescriptor data BuiltinDescriptor BuiltinData :: TCM Type -> [String] -> BuiltinDescriptor BuiltinDataCons :: TCM Type -> BuiltinDescriptor BuiltinPrim :: String -> (Term -> TCM ()) -> BuiltinDescriptor BuiltinSort :: String -> BuiltinDescriptor BuiltinPostulate :: Relevance -> TCM Type -> BuiltinDescriptor -- | Builtin of any kind. Type can be checked (Just t) or inferred -- (Nothing). The second argument is the hook for the -- verification function. BuiltinUnknown :: Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor -- | When typechecking something of the following form: -- -- instance x : _ x = y -- -- it's not yet known where to add x, so we add it to a list of -- unresolved instances and we'll deal with it later. type TempInstanceTable = (InstanceTable, Set QName) -- | The instance table is a Map associating to every name of -- recorddata typepostulate its list of instances type InstanceTable = Map QName (Set QName) data Call CheckClause :: Type -> SpineClause -> Call CheckLHS :: SpineLHS -> Call CheckPattern :: Pattern -> Telescope -> Type -> Call CheckPatternLinearityType :: Name -> Call CheckPatternLinearityValue :: Name -> Call CheckLetBinding :: LetBinding -> Call InferExpr :: Expr -> Call CheckExprCall :: Comparison -> Expr -> Type -> Call CheckDotPattern :: Expr -> Term -> Call CheckProjection :: Range -> QName -> Type -> Call IsTypeCall :: Comparison -> Expr -> Sort -> Call IsType_ :: Expr -> Call InferVar :: Name -> Call InferDef :: QName -> Call CheckArguments :: Range -> [NamedArg Expr] -> Type -> Maybe Type -> Call CheckMetaSolution :: Range -> MetaId -> Type -> Term -> Call CheckTargetType :: Range -> Type -> Type -> Call CheckDataDef :: Range -> QName -> [LamBinding] -> [Constructor] -> Call CheckRecDef :: Range -> QName -> [LamBinding] -> [Constructor] -> Call CheckConstructor :: QName -> Telescope -> Sort -> Constructor -> Call CheckConstructorFitsIn :: QName -> Type -> Sort -> Call -- | Highlight (interactively) if and only if the boolean is True. CheckFunDefCall :: Range -> QName -> [Clause] -> Bool -> Call CheckPragma :: Range -> Pragma -> Call CheckPrimitive :: Range -> QName -> Expr -> Call CheckIsEmpty :: Range -> Type -> Call CheckConfluence :: QName -> QName -> Call CheckWithFunctionType :: Type -> Call CheckSectionApplication :: Range -> ModuleName -> ModuleApplication -> Call CheckNamedWhere :: ModuleName -> Call -- | Checking a clause for confluence with endpoint reductions. Always -- φ ⊢ f vs = rhs for now, but we store the simplifications of -- f vs[φ] and rhs[φ]. CheckIApplyConfluence :: Range -> QName -> Term -> Term -> Term -> Type -> Call ScopeCheckExpr :: Expr -> Call ScopeCheckDeclaration :: NiceDeclaration -> Call ScopeCheckLHS :: QName -> Pattern -> Call NoHighlighting :: Call -- | Interaction command: show module contents. ModuleContents :: Call -- | used by setCurrentRange SetRange :: Range -> Call type Statistics = Map String Integer newtype MutualId MutId :: Int32 -> MutualId data TermHead SortHead :: TermHead PiHead :: TermHead ConsHead :: QName -> TermHead VarHead :: Nat -> TermHead UnknownHead :: TermHead data FunctionInverse' c NotInjective :: FunctionInverse' c Inverse :: InversionMap c -> FunctionInverse' c type InversionMap c = Map TermHead [c] type FunctionInverse = FunctionInverse' Clause data PrimFun PrimFun :: QName -> Arity -> ([Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun [primFunName] :: PrimFun -> QName [primFunArity] :: PrimFun -> Arity [primFunImplementation] :: PrimFun -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) -- | Primitives data PrimitiveImpl PrimImpl :: Type -> PrimFun -> PrimitiveImpl data ReduceDefs OnlyReduceDefs :: Set QName -> ReduceDefs DontReduceDefs :: Set QName -> ReduceDefs type AllowedReductions = SmallSet AllowedReduction -- | Controlling reduce. data AllowedReduction -- | (Projection and) projection-like functions may be reduced. ProjectionReductions :: AllowedReduction -- | Functions marked INLINE may be reduced. InlineReductions :: AllowedReduction -- | Copattern definitions may be reduced. CopatternReductions :: AllowedReduction -- | Non-recursive functions and primitives may be reduced. FunctionReductions :: AllowedReduction -- | Even recursive functions may be reduced. RecursiveReductions :: AllowedReduction -- | Reduce Term terms. LevelReductions :: AllowedReduction -- | Allow allReductions in types, even if not allowed at term -- level (used by confluence checker) TypeLevelReductions :: AllowedReduction -- | Functions whose termination has not (yet) been confirmed. UnconfirmedReductions :: AllowedReduction -- | Functions that have failed termination checking. NonTerminatingReductions :: AllowedReduction type MaybeReducedElims = [MaybeReduced Elim] type MaybeReducedArgs = [MaybeReduced (Arg Term)] data MaybeReduced a MaybeRed :: IsReduced -> a -> MaybeReduced a [isReduced] :: MaybeReduced a -> IsReduced [ignoreReduced] :: MaybeReduced a -> a -- | Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not -- blocked. data IsReduced NotReduced :: IsReduced Reduced :: Blocked () -> IsReduced data Reduced no yes NoReduction :: no -> Reduced no yes YesReduction :: Simplification -> yes -> Reduced no yes -- | Did we encounter a simplifying reduction? In terms of CIC, that would -- be a iota-reduction. In terms of Agda, this is a constructor or -- literal pattern that matched. Just beta-reduction (substitution) or -- delta-reduction (unfolding of definitions) does not count as -- simplifying? data Simplification YesSimplification :: Simplification NoSimplification :: Simplification newtype Fields Fields :: [(Name, Type)] -> Fields data PrimitiveSortData PrimitiveSortData :: String -> Sort -> PrimitiveSortData [_primSortName] :: PrimitiveSortData -> String [_primSortSort] :: PrimitiveSortData -> Sort data PrimitiveData PrimitiveData :: IsAbstract -> String -> [Clause] -> FunctionInverse -> Maybe CompiledClauses -> PrimitiveData [_primAbstr] :: PrimitiveData -> IsAbstract [_primName] :: PrimitiveData -> String -- | null for primitive functions, not null for builtin -- functions. [_primClauses] :: PrimitiveData -> [Clause] -- | Builtin functions can have inverses. For instance, natural number -- addition. [_primInv] :: PrimitiveData -> FunctionInverse -- | Nothing for primitive functions, Just something -- for builtin functions. [_primCompiled] :: PrimitiveData -> Maybe CompiledClauses data ConstructorData ConstructorData :: Int -> Int -> ConHead -> QName -> IsAbstract -> Induction -> CompKit -> Maybe [QName] -> [IsForced] -> Maybe [Bool] -> ConstructorData -- | Number of parameters. [_conPars] :: ConstructorData -> Int -- | Number of arguments (excluding parameters). [_conArity] :: ConstructorData -> Int -- | Name of (original) constructor and fields. (This might be in a module -- instance.) [_conSrcCon] :: ConstructorData -> ConHead -- | Name of datatype or record type. [_conData] :: ConstructorData -> QName [_conAbstr] :: ConstructorData -> IsAbstract -- | Inductive or coinductive? [_conInd] :: ConstructorData -> Induction -- | Cubical composition. [_conComp] :: ConstructorData -> CompKit -- | Projections. Nothing if not yet computed. [_conProj] :: ConstructorData -> Maybe [QName] -- | 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. [_conForced] :: ConstructorData -> [IsForced] -- | 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. [_conErased] :: ConstructorData -> Maybe [Bool] data RecordData RecordData :: Nat -> Maybe Clause -> ConHead -> Bool -> [Dom QName] -> Telescope -> Maybe [QName] -> EtaEquality -> PatternOrCopattern -> Maybe Induction -> Maybe Bool -> IsAbstract -> CompKit -> RecordData -- | Number of parameters. [_recPars] :: RecordData -> Nat -- | Was this record type created by a module application? If yes, the -- clause is its definition (linking back to the original record type). [_recClause] :: RecordData -> Maybe Clause -- | Constructor name and fields. [_recConHead] :: RecordData -> ConHead -- | Does this record have a constructor? [_recNamedCon] :: RecordData -> Bool -- | The record field names. [_recFields] :: RecordData -> [Dom QName] -- | The record field telescope. (Includes record parameters.) Note: -- TelV recTel _ == telView' recConType. Thus, recTel -- is redundant. [_recTel] :: RecordData -> Telescope -- | Mutually recursive functions, datas and records. -- Does include this record. Empty if not recursive. Nothing if -- not yet computed (by positivity checker). [_recMutual] :: RecordData -> Maybe [QName] -- | Eta-expand at this record type? False for unguarded recursive -- records and coinductive records unless the user specifies otherwise. [_recEtaEquality'] :: RecordData -> EtaEquality -- | In case eta-equality is off, do we allow pattern matching on the -- constructor or construction by copattern matching? Having both loses -- subject reduction, see issue #4560. After positivity checking, this -- field is obsolete, part of EtaEquality. [_recPatternMatching] :: RecordData -> PatternOrCopattern -- | Inductive or CoInductive? Matters only for recursive -- records. Nothing means that the user did not specify it, which -- is an error for recursive records. [_recInduction] :: RecordData -> Maybe Induction -- | 'Just True' means that unfolding of the recursive record terminates, -- 'Just False' means that we have no evidence for termination, and -- Nothing means we have not run the termination checker yet. [_recTerminates] :: RecordData -> Maybe Bool [_recAbstr] :: RecordData -> IsAbstract [_recComp] :: RecordData -> CompKit data DatatypeData DatatypeData :: Nat -> Nat -> Maybe Clause -> [QName] -> Sort -> Maybe [QName] -> IsAbstract -> [QName] -> Maybe QName -> Maybe QName -> DatatypeData -- | Number of parameters. [_dataPars] :: DatatypeData -> Nat -- | Number of indices. [_dataIxs] :: DatatypeData -> Nat -- | This might be in an instantiated module. [_dataClause] :: DatatypeData -> Maybe Clause -- | Constructor names, ordered according to the order of their definition. [_dataCons] :: DatatypeData -> [QName] [_dataSort] :: DatatypeData -> Sort -- | Mutually recursive functions, datas and records. -- Does include this data type. Empty if not recursive. Nothing -- if not yet computed (by positivity checker). [_dataMutual] :: DatatypeData -> Maybe [QName] [_dataAbstr] :: DatatypeData -> IsAbstract -- | Path constructor names (subset of dataCons). [_dataPathCons] :: DatatypeData -> [QName] -- | If indexed datatype, name of the "index transport" function. [_dataTranspIx] :: DatatypeData -> Maybe QName -- | Transport function, should be available for all datatypes in supported -- sorts. [_dataTransp] :: DatatypeData -> Maybe QName data FunctionData FunctionData :: [Clause] -> Maybe CompiledClauses -> Maybe SplitTree -> Maybe Compiled -> [Clause] -> FunctionInverse -> Maybe [QName] -> IsAbstract -> Delayed -> Either ProjectionLikenessMissing Projection -> Set FunctionFlag -> Maybe Bool -> Maybe ExtLamInfo -> Maybe QName -> Maybe QName -> FunctionData [_funClauses] :: FunctionData -> [Clause] -- | Nothing while function is still type-checked. Just cc -- after type and coverage checking and translation to case trees. [_funCompiled] :: FunctionData -> Maybe CompiledClauses -- | The split tree constructed by the coverage checker. Needed to -- re-compile the clauses after forcing translation. [_funSplitTree] :: FunctionData -> Maybe SplitTree -- | Intermediate representation for compiler backends. [_funTreeless] :: FunctionData -> Maybe Compiled -- | Covering clauses computed by coverage checking. Erased by (IApply) -- confluence checking(?) [_funCovering] :: FunctionData -> [Clause] [_funInv] :: FunctionData -> FunctionInverse -- | Mutually recursive functions, datas and records. -- Does include this function. Empty list if not recursive. -- Nothing if not yet computed (by positivity checker). [_funMutual] :: FunctionData -> Maybe [QName] [_funAbstr] :: FunctionData -> IsAbstract -- | Are the clauses of this definition delayed? [_funDelayed] :: FunctionData -> Delayed -- | 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. [_funProjection] :: FunctionData -> Either ProjectionLikenessMissing Projection [_funFlags] :: FunctionData -> Set FunctionFlag -- | Has this function been termination checked? Did it pass? [_funTerminates] :: FunctionData -> Maybe Bool -- | Is this function generated from an extended lambda? If yes, then -- return the number of hidden and non-hidden lambda-lifted arguments. [_funExtLam] :: FunctionData -> Maybe ExtLamInfo -- | Is this a generated with-function? If yes, then what's the name of the -- parent function? [_funWith] :: FunctionData -> Maybe QName -- | Is this a helper for one of the Kan operations (transp, hcomp) on data -- types/records? If so, for which data type? [_funIsKanOp] :: FunctionData -> Maybe QName -- | Indicates the reason behind a function having not been marked -- projection-like. data ProjectionLikenessMissing -- | Projection-likeness analysis has not run on this function yet. It may -- do so in the future. MaybeProjection :: ProjectionLikenessMissing -- | The user has requested that this function be not be marked -- projection-like. The analysis may already have run on this function, -- but the results have been discarded, and it will not be run again. NeverProjection :: ProjectionLikenessMissing data DataOrRecSigData DataOrRecSigData :: Int -> DataOrRecSigData [_datarecPars] :: DataOrRecSigData -> Int data AxiomData AxiomData :: Bool -> AxiomData -- | Can transp for this postulate be constant? Set to True for -- bultins like String. [_axiomConstTransp] :: AxiomData -> Bool data Defn -- | Postulate. AxiomDefn :: AxiomData -> Defn -- | Data or record type signature that doesn't yet have a definition. DataOrRecSigDefn :: DataOrRecSigData -> Defn -- | Generalizable variable (introduced in generalize block). GeneralizableVar :: Defn -- | Returned by getConstInfo if definition is abstract. AbstractDefn :: Defn -> Defn FunctionDefn :: FunctionData -> Defn DatatypeDefn :: DatatypeData -> Defn RecordDefn :: RecordData -> Defn ConstructorDefn :: ConstructorData -> Defn -- | Primitive or builtin functions. PrimitiveDefn :: PrimitiveData -> Defn PrimitiveSortDefn :: PrimitiveSortData -> Defn data CompKit CompKit :: Maybe QName -> Maybe QName -> CompKit [nameOfHComp] :: CompKit -> Maybe QName [nameOfTransp] :: CompKit -> Maybe QName data FunctionFlag -- | Should calls to this function be normalised at compile-time? FunStatic :: FunctionFlag -- | Should calls to this function be inlined by the compiler? FunInline :: FunctionFlag -- | Is this function a macro? FunMacro :: FunctionFlag -- | Should a record type admit eta-equality? data EtaEquality -- | User specifed 'eta-equality' or 'no-eta-equality'. Specified :: !HasEta -> EtaEquality [theEtaEquality] :: EtaEquality -> !HasEta -- | Positivity checker inferred whether eta is safe. Inferred :: !HasEta -> EtaEquality [theEtaEquality] :: EtaEquality -> !HasEta -- | Abstractions to build projection function (dropping parameters). newtype ProjLams ProjLams :: [Arg ArgName] -> ProjLams [getProjLams] :: ProjLams -> [Arg ArgName] -- | Additional information for projection Functions. data Projection Projection :: Maybe QName -> QName -> Arg QName -> Int -> ProjLams -> Projection -- | 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. [projProper] :: Projection -> Maybe QName -- | The original projection name (current name could be from module -- application). [projOrig] :: Projection -> QName -- | Type projected from. Original record type if projProper = -- Just{}. Also stores ArgInfo of the principal argument. -- This field is unchanged by module application. [projFromType] :: Projection -> Arg QName -- | 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. [projIndex] :: Projection -> Int -- | 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. [projLams] :: Projection -> ProjLams -- | Additional information for extended lambdas. data ExtLamInfo ExtLamInfo :: ModuleName -> Bool -> !Maybe System -> ExtLamInfo -- | 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. [extLamModule] :: ExtLamInfo -> ModuleName -- | Was this definition created from an absurd lambda λ ()? [extLamAbsurd] :: ExtLamInfo -> Bool [extLamSys] :: ExtLamInfo -> !Maybe 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). data System System :: Telescope -> [(Face, Term)] -> System -- | the telescope Δ, binding vars for the clauses, Γ ⊢ Δ [systemTel] :: System -> Telescope -- | a system [φ₁ u₁, ... , φₙ uₙ] where Γ, Δ ⊢ φᵢ and Γ, Δ, φᵢ ⊢ uᵢ [systemClauses] :: System -> [(Face, Term)] type Face = [(Term, Bool)] type CompiledRepresentation = Map BackendName [CompilerPragma] -- | The backends are responsible for parsing their own pragmas. data CompilerPragma CompilerPragma :: Range -> String -> CompilerPragma -- | Information about whether an argument is forced by the type of a -- function. data IsForced Forced :: IsForced NotForced :: IsForced data NumGeneralizableArgs NoGeneralizableArgs :: NumGeneralizableArgs -- | When lambda-lifting new args are generalizable if -- SomeGeneralizableArgs, also when the number is zero. SomeGeneralizableArgs :: !Int -> NumGeneralizableArgs data Definition Defn :: ArgInfo -> QName -> Type -> [Polarity] -> [Occurrence] -> NumGeneralizableArgs -> [Maybe Name] -> [LocalDisplayForm] -> MutualId -> CompiledRepresentation -> Maybe QName -> Bool -> Set QName -> Bool -> Bool -> Bool -> Blocked_ -> !Language -> Defn -> Definition -- | Hiding should not be used. [defArgInfo] :: Definition -> ArgInfo -- | The canonical name, used e.g. in compilation. [defName] :: Definition -> QName -- | Type of the lifted definition. [defType] :: Definition -> Type -- | Variance information on arguments of the definition. Does not include -- info for dropped parameters to projection(-like) functions and -- constructors. [defPolarity] :: Definition -> [Polarity] -- | Positivity information on arguments of the definition. Does not -- include info for dropped parameters to projection(-like) functions and -- constructors. [defArgOccurrences] :: Definition -> [Occurrence] -- | How many arguments should be generalised. [defArgGeneralizable] :: Definition -> NumGeneralizableArgs -- | 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. [defGeneralizedParams] :: Definition -> [Maybe Name] [defDisplay] :: Definition -> [LocalDisplayForm] [defMutual] :: Definition -> MutualId [defCompiledRep] :: Definition -> CompiledRepresentation -- | Just q when this definition is an instance of class q [defInstance] :: Definition -> Maybe QName -- | Has this function been created by a module instantiation? [defCopy] :: Definition -> Bool -- | The set of symbols with rewrite rules that match against this symbol [defMatchable] :: Definition -> Set QName -- | should compilers skip this? Used for e.g. cubical's comp [defNoCompilation] :: Definition -> Bool -- | Should the def be treated as injective by the pattern matching -- unifier? [defInjective] :: Definition -> Bool -- | Is this a function defined by copatterns? [defCopatternLHS] :: Definition -> Bool -- | 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. [defBlocked] :: Definition -> Blocked_ -- | The language used for the definition. [defLanguage] :: Definition -> !Language [theDef] :: Definition -> Defn -- | Rewrite rules can be added independently from function clauses. data RewriteRule RewriteRule :: QName -> Telescope -> QName -> PElims -> Term -> Type -> Bool -> RewriteRule -- | Name of rewrite rule q : Γ → f ps ≡ rhs where is -- the rewrite relation. [rewName] :: RewriteRule -> QName -- | Γ. [rewContext] :: RewriteRule -> Telescope -- | f. [rewHead] :: RewriteRule -> QName -- | Γ ⊢ f ps : t. [rewPats] :: RewriteRule -> PElims -- | Γ ⊢ rhs : t. [rewRHS] :: RewriteRule -> Term -- | Γ ⊢ t. [rewType] :: RewriteRule -> Type -- | Was this rewrite rule created from a clause in the definition of the -- function? [rewFromClause] :: RewriteRule -> Bool type RewriteRules = [RewriteRule] data NLPSort PType :: NLPat -> NLPSort PProp :: NLPat -> NLPSort PSSet :: NLPat -> NLPSort PInf :: IsFibrant -> Integer -> NLPSort PSizeUniv :: NLPSort PLockUniv :: NLPSort PIntervalUniv :: NLPSort data NLPType NLPType :: NLPSort -> NLPat -> NLPType [nlpTypeSort] :: NLPType -> NLPSort [nlpTypeUnEl] :: NLPType -> NLPat type PElims = [Elim' NLPat] -- | Non-linear (non-constructor) first-order pattern. data NLPat -- | Matches anything (modulo non-linearity) that only contains bound -- variables that occur in the given arguments. PVar :: !Int -> [Arg Int] -> NLPat -- | Matches f es PDef :: QName -> PElims -> NLPat -- | Matches λ x → t PLam :: ArgInfo -> Abs NLPat -> NLPat -- | Matches (x : A) → B PPi :: Dom NLPType -> Abs NLPType -> NLPat -- | Matches a sort of the given shape. PSort :: NLPSort -> NLPat -- | Matches x es where x is a lambda-bound variable PBoundVar :: {-# UNPACK #-} !Int -> PElims -> NLPat -- | Matches the term modulo β (ideally βη). PTerm :: Term -> NLPat -- | A structured presentation of a Term for reification into -- Syntax. data DisplayTerm -- | (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). DWithApp :: DisplayTerm -> [DisplayTerm] -> Elims -> DisplayTerm -- | c vs. DCon :: ConHead -> ConInfo -> [Arg DisplayTerm] -> DisplayTerm -- | d vs. DDef :: QName -> [Elim' DisplayTerm] -> DisplayTerm -- | .v. DDot :: Term -> DisplayTerm -- | v. DTerm :: Term -> DisplayTerm type LocalDisplayForm = Open 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 the first -- dfPatternVars variables are pattern variables that matches -- any term. data DisplayForm Display :: Nat -> Elims -> DisplayTerm -> DisplayForm -- | Number n of pattern variables in dfPats. [dfPatternVars] :: DisplayForm -> Nat -- | Left hand side patterns, the n first free variables are -- pattern variables, any variables above n are fixed and only -- match that particular variable. This happens when you have display -- forms inside parameterised modules that match on the module -- parameters. The ArgInfo is ignored in these patterns. [dfPats] :: DisplayForm -> Elims -- | Right hand side. [dfRHS] :: DisplayForm -> DisplayTerm newtype Section Section :: Telescope -> Section [_secTelescope] :: Section -> Telescope type DisplayForms = HashMap QName [LocalDisplayForm] type RewriteRuleMap = HashMap QName RewriteRules type Definitions = HashMap QName Definition type Sections = Map ModuleName Section data Signature Sig :: Sections -> Definitions -> RewriteRuleMap -> Signature [_sigSections] :: Signature -> Sections [_sigDefinitions] :: Signature -> Definitions -- | The rewrite rules defined in this file. [_sigRewriteRules] :: Signature -> RewriteRuleMap -- | Which clause is an interaction point located in? data IPClause IPClause :: QName -> Int -> Type -> Maybe Substitution -> SpineClause -> Closure () -> [Closure IPBoundary] -> IPClause -- | The name of the function. [ipcQName] :: IPClause -> QName -- | The number of the clause of this function. [ipcClauseNo] :: IPClause -> Int -- | The type of the function [ipcType] :: IPClause -> Type -- | Module parameter substitution [ipcWithSub] :: IPClause -> Maybe Substitution -- | The original AST clause. [ipcClause] :: IPClause -> SpineClause -- | Environment for rechecking the clause. [ipcClosure] :: IPClause -> Closure () -- | The boundary imposed by the LHS. [ipcBoundary] :: IPClause -> [Closure IPBoundary] -- | The interaction point is not in the rhs of a clause. IPNoClause :: IPClause type IPBoundary = IPBoundary' Term -- | Flag to indicate whether the meta is overapplied in the constraint. A -- meta is overapplied if it has more arguments than the size of the -- telescope in its creation environment (as stored in MetaInfo). data Overapplied Overapplied :: Overapplied NotOverapplied :: Overapplied -- | Data structure managing the interaction points. -- -- We never remove interaction points from this map, only set their -- ipSolved to True. (Issue #2368) type InteractionPoints = BiMap InteractionId InteractionPoint -- | Interaction points are created by the scope checker who sets the -- range. The meta variable is created by the type checker and then -- hooked up to the interaction point. data InteractionPoint InteractionPoint :: Range -> Maybe MetaId -> Bool -> IPClause -> InteractionPoint -- | The position of the interaction point. [ipRange] :: InteractionPoint -> Range -- | The meta variable, if any, holding the type etc. [ipMeta] :: InteractionPoint -> Maybe MetaId -- | Has this interaction point already been solved? [ipSolved] :: InteractionPoint -> Bool -- | The clause of the interaction point (if any). Used for case splitting. [ipClause] :: InteractionPoint -> IPClause -- | Used for meta-variables from other modules (and in Interfaces). type RemoteMetaStore = HashMap MetaId RemoteMetaVariable -- | Used for meta-variables from the current module. type LocalMetaStore = Map MetaId MetaVariable -- | Name suggestion for meta variable. Empty string means no suggestion. type MetaNameSuggestion = String -- | MetaInfo is cloned from one meta to the next during pruning. data MetaInfo MetaInfo :: Closure Range -> Modality -> RunMetaOccursCheck -> MetaNameSuggestion -> Arg DoGeneralize -> MetaInfo [miClosRange] :: MetaInfo -> Closure Range -- | Instantiable with irrelevant/erased solution? [miModality] :: MetaInfo -> Modality -- | Run the extended occurs check that goes in definitions? [miMetaOccursCheck] :: MetaInfo -> RunMetaOccursCheck -- | Used for printing. Just x if meta-variable comes from omitted -- argument with name x. [miNameSuggestion] :: MetaInfo -> MetaNameSuggestion -- | Should this meta be generalized if unsolved? If so, at what ArgInfo? [miGeneralizable] :: MetaInfo -> Arg DoGeneralize data RunMetaOccursCheck RunMetaOccursCheck :: RunMetaOccursCheck DontRunMetaOccursCheck :: RunMetaOccursCheck -- | Meta variable priority: When we have an equation between -- meta-variables, which one should be instantiated? -- -- Higher value means higher priority to be instantiated. newtype MetaPriority MetaPriority :: Int -> MetaPriority data TypeCheckingProblem CheckExpr :: Comparison -> Expr -> Type -> TypeCheckingProblem CheckArgs :: Comparison -> ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> (ArgsCheckState CheckedTarget -> TCM Term) -> TypeCheckingProblem CheckProjAppToKnownPrincipalArg :: Comparison -> Expr -> ProjOrigin -> List1 QName -> Args -> Type -> Int -> Term -> Type -> PrincipalArgTypeMetas -> TypeCheckingProblem -- | (λ (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. CheckLambda :: Comparison -> Arg (List1 (WithHiding Name), Maybe Type) -> Expr -> Type -> TypeCheckingProblem -- | Quote the given term and check type against Term DoQuoteTerm :: Comparison -> Term -> Type -> TypeCheckingProblem data PrincipalArgTypeMetas PrincipalArgTypeMetas :: Args -> Type -> PrincipalArgTypeMetas -- | metas created for hidden and instance arguments in the principal -- argument's type [patmMetas] :: PrincipalArgTypeMetas -> Args -- | principal argument's type, stripped of hidden and instance arguments [patmRemainder] :: PrincipalArgTypeMetas -> Type -- | Solving a CheckArgs constraint may or may not check the target -- type. If it did, it returns a handle to any unsolved constraints. data CheckedTarget CheckedTarget :: Maybe ProblemId -> CheckedTarget NotCheckedTarget :: CheckedTarget -- | Information about remote meta-variables. -- -- Remote meta-variables are meta-variables originating in other modules. -- These meta-variables are always instantiated. We do not retain all the -- information about a local meta-variable when creating an interface: -- -- data RemoteMetaVariable RemoteMetaVariable :: Instantiation -> Modality -> Judgement MetaId -> RemoteMetaVariable [rmvInstantiation] :: RemoteMetaVariable -> Instantiation [rmvModality] :: RemoteMetaVariable -> Modality [rmvJudgement] :: RemoteMetaVariable -> Judgement MetaId -- | Meta-variable instantiations. data Instantiation Instantiation :: [Arg String] -> Term -> Instantiation -- | The solution is abstracted over these free variables. [instTel] :: Instantiation -> [Arg String] -- | The body of the solution. [instBody] :: Instantiation -> Term data MetaInstantiation -- | solved InstV :: Instantiation -> MetaInstantiation -- | unsolved Open :: MetaInstantiation -- | open, to be instantiated by instance search OpenInstance :: MetaInstantiation -- | solution blocked by unsolved constraints BlockedConst :: Term -> MetaInstantiation PostponedTypeCheckingProblem :: Closure TypeCheckingProblem -> MetaInstantiation -- | Frozen meta variable cannot be instantiated by unification. This -- serves to prevent the completion of a definition by its use outside of -- the current block. (See issues 118, 288, 399). data Frozen -- | Do not instantiate. Frozen :: Frozen Instantiable :: Frozen data Listener EtaExpand :: MetaId -> Listener CheckConstraint :: Nat -> ProblemConstraint -> Listener -- | Information about local meta-variables. data MetaVariable MetaVar :: MetaInfo -> MetaPriority -> Permutation -> Judgement MetaId -> MetaInstantiation -> Set Listener -> Frozen -> Maybe MetaId -> MetaVariable [mvInfo] :: MetaVariable -> MetaInfo -- | some metavariables are more eager to be instantiated [mvPriority] :: MetaVariable -> MetaPriority -- | 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 [mvPermutation] :: MetaVariable -> Permutation [mvJudgement] :: MetaVariable -> Judgement MetaId [mvInstantiation] :: MetaVariable -> MetaInstantiation -- | meta variables scheduled for eta-expansion but blocked by this one [mvListeners] :: MetaVariable -> Set Listener -- | are we past the point where we can instantiate this meta variable? [mvFrozen] :: MetaVariable -> Frozen -- | Just m means that this meta-variable will be equated to -- m when the latter is unblocked. See -- blockTermOnProblem. [mvTwin] :: MetaVariable -> Maybe MetaId -- | The value of a generalizable variable. This is created to be a -- generalizable meta before checking the type to be generalized. data GeneralizedValue GeneralizedValue :: CheckpointId -> Term -> Type -> GeneralizedValue [genvalCheckpoint] :: GeneralizedValue -> CheckpointId [genvalTerm] :: GeneralizedValue -> Term [genvalType] :: GeneralizedValue -> Type data DoGeneralize -- | Generalize because it is a generalizable variable. YesGeneralizeVar :: DoGeneralize -- | Generalize because it is a metavariable and we're currently checking -- the type of a generalizable variable (this should get the default -- modality). YesGeneralizeMeta :: DoGeneralize -- | Don't generalize. NoGeneralize :: DoGeneralize -- | Parametrized since it is used without MetaId when creating a new meta. data Judgement a HasType :: a -> Comparison -> Type -> Judgement a [jMetaId] :: Judgement a -> a -- | are we checking (CmpLeq) or inferring (CmpEq) the -- type? [jComparison] :: Judgement a -> Comparison [jMetaType] :: Judgement a -> Type IsSort :: a -> Type -> Judgement a [jMetaId] :: Judgement a -> a [jMetaType] :: Judgement a -> Type -- | A thing tagged with the context it came from. Also keeps the -- substitution from previous checkpoints. This lets us handle the case -- when an open thing was created in a context that we have since exited. -- Remember which module it's from to make sure we don't get confused by -- checkpoints from other files. data Open a OpenThing :: CheckpointId -> Map CheckpointId Substitution -> ModuleNameHash -> a -> Open a [openThingCheckpoint] :: Open a -> CheckpointId [openThingCheckpointMap] :: Open a -> Map CheckpointId Substitution [openThingModule] :: Open a -> ModuleNameHash [openThing] :: Open a -> a -- | We can either compare two terms at a given type, or compare two types -- without knowing (or caring about) their sorts. data CompareAs -- | Type should not be Size. But currently, we do not -- rely on this invariant. AsTermsOf :: Type -> CompareAs -- | Replaces AsTermsOf Size. AsSizes :: CompareAs AsTypes :: CompareAs -- | An extension of Comparison to >=. data CompareDirection DirEq :: CompareDirection DirLeq :: CompareDirection DirGeq :: CompareDirection data Constraint ValueCmp :: Comparison -> CompareAs -> Term -> Term -> Constraint ValueCmpOnFace :: Comparison -> Term -> Type -> Term -> Term -> Constraint ElimCmp :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> Constraint SortCmp :: Comparison -> Sort -> Sort -> Constraint LevelCmp :: Comparison -> Level -> Level -> Constraint HasBiggerSort :: Sort -> Constraint HasPTSRule :: Dom Type -> Abs Sort -> Constraint -- | Check that the sort Term of data type QName admits -- data/record types. E.g., sorts IUniv, SizeUniv etc. -- do not admit such constructions. See checkDataSort. CheckDataSort :: QName -> Sort -> Constraint CheckMetaInst :: MetaId -> Constraint CheckType :: Type -> Constraint -- | Meta created for a term blocked by a postponed type checking problem -- or unsolved constraints. The MetaInstantiation for the meta -- (when unsolved) is either BlockedConst or -- PostponedTypeCheckingProblem. UnBlock :: MetaId -> Constraint -- | The range is the one of the absurd pattern. IsEmpty :: Range -> Type -> Constraint -- | Check that the Term is either not a SIZELT or a non-empty -- SIZELT. CheckSizeLtSat :: Term -> Constraint -- | the first argument is the instance argument and the second one is the -- list of candidates (or Nothing if we haven’t determined the list of -- candidates yet) FindInstance :: MetaId -> Maybe [Candidate] -> Constraint -- | Last argument is the error causing us to postpone. CheckFunDef :: Delayed -> DefInfo -> QName -> [Clause] -> TCErr -> Constraint -- | First argument is computation and the others are hole and goal type UnquoteTactic :: Term -> Term -> Type -> Constraint -- | CheckLockedVars t ty lk lk_ty with t : ty, lk : -- lk_ty and t lk well-typed. CheckLockedVars :: Term -> Type -> Arg Term -> Type -> Constraint -- | Is the term usable at the given modality? This check should run if the -- Sort is Nothing or isFibrant. UsableAtModality :: WhyCheckModality -> Maybe Sort -> Modality -> Term -> Constraint -- | Why are we performing a modality check? data WhyCheckModality -- | Because --without-K is enabled, so the types of data constructors must -- be usable at the context's modality. ConstructorType :: WhyCheckModality -- | Because --without-K is enabled, so the result type of clauses must be -- usable at the context's modality. IndexedClause :: WhyCheckModality -- | Because --without-K is enabled, so any argument (second name) which -- mentions a dotted argument (first name) must have a type which is -- usable at the context's modality. IndexedClauseArg :: Name -> Name -> WhyCheckModality -- | Because we double-check the --cubical-compatible clauses. This is an -- internal error! GeneratedClause :: WhyCheckModality data ProblemConstraint PConstr :: Set ProblemId -> Blocker -> Closure Constraint -> ProblemConstraint [constraintProblems] :: ProblemConstraint -> Set ProblemId [constraintUnblocker] :: ProblemConstraint -> Blocker [theConstraint] :: ProblemConstraint -> Closure Constraint type Constraints = [ProblemConstraint] class LensClosure a b | b -> a lensClosure :: LensClosure a b => Lens' (Closure a) b data Closure a Closure :: Signature -> TCEnv -> ScopeInfo -> Map ModuleName CheckpointId -> a -> Closure a [clSignature] :: Closure a -> Signature [clEnv] :: Closure a -> TCEnv [clScope] :: Closure a -> ScopeInfo [clModuleCheckpoints] :: Closure a -> Map ModuleName CheckpointId [clValue] :: Closure a -> a data Interface Interface :: Hash -> Text -> FileType -> [(TopLevelModuleName, Hash)] -> ModuleName -> TopLevelModuleName -> Map ModuleName Scope -> ScopeInfo -> Signature -> RemoteMetaStore -> DisplayForms -> Map QName Text -> Maybe Text -> BuiltinThings (String, QName) -> Map BackendName [ForeignCode] -> HighlightingInfo -> [OptionsPragma] -> [OptionsPragma] -> PragmaOptions -> PatternSynDefns -> [TCWarning] -> Set QName -> Interface -- | Hash of the source code. [iSourceHash] :: Interface -> Hash -- | 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. [iSource] :: Interface -> Text -- | Source file type, determined from the file extension [iFileType] :: Interface -> FileType -- | Imported modules and their hashes. [iImportedModules] :: Interface -> [(TopLevelModuleName, Hash)] -- | Module name of this interface. [iModuleName] :: Interface -> ModuleName -- | The module's top-level module name. [iTopLevelModuleName] :: Interface -> TopLevelModuleName -- | 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. [iScope] :: Interface -> Map ModuleName Scope -- | Scope after we loaded this interface. Used in AtTopLevel and -- interactionLoop. [iInsideScope] :: Interface -> ScopeInfo [iSignature] :: Interface -> Signature -- | Instantiations for meta-variables that come from this module. [iMetaBindings] :: Interface -> RemoteMetaStore -- | Display forms added for imported identifiers. [iDisplayForms] :: Interface -> DisplayForms -- | User warnings for imported identifiers [iUserWarnings] :: Interface -> Map QName Text -- | Whether this module should raise a warning when imported [iImportWarning] :: Interface -> Maybe Text [iBuiltin] :: Interface -> BuiltinThings (String, QName) [iForeignCode] :: Interface -> Map BackendName [ForeignCode] [iHighlighting] :: Interface -> HighlightingInfo -- | Pragma options set in library files. [iDefaultPragmaOptions] :: Interface -> [OptionsPragma] -- | Pragma options set in the file. [iFilePragmaOptions] :: Interface -> [OptionsPragma] -- | Options/features used when checking the file (can be different from -- options set directly in the file). [iOptionsUsed] :: Interface -> PragmaOptions [iPatternSyns] :: Interface -> PatternSynDefns [iWarnings] :: Interface -> [TCWarning] [iPartialDefs] :: Interface -> Set QName data ForeignCode ForeignCode :: Range -> String -> ForeignCode type DecodedModules = Map TopLevelModuleName ModuleInfo type VisitedModules = Map TopLevelModuleName ModuleInfo data ModuleInfo ModuleInfo :: Interface -> [TCWarning] -> Bool -> ModuleCheckMode -> ModuleInfo [miInterface] :: ModuleInfo -> Interface -- | Warnings were encountered when the module was type checked. These -- might include warnings not stored in the interface itself, -- specifically unsolved interaction metas. See -- Agda.Interaction.Imports [miWarnings] :: ModuleInfo -> [TCWarning] -- | True if the module is a primitive module, which should always -- be importable. [miPrimitive] :: ModuleInfo -> Bool -- | The ModuleCheckMode used to create the Interface [miMode] :: ModuleInfo -> ModuleCheckMode -- | Distinguishes between type-checked and scope-checked interfaces when -- stored in the map of VisitedModules. data ModuleCheckMode ModuleScopeChecked :: ModuleCheckMode ModuleTypeChecked :: ModuleCheckMode -- | A monad that has read and write access to the stConcreteNames part of -- the TCState. Basically, this is a synonym for `MonadState -- ConcreteNames m` (which cannot be used directly because of the -- limitations of Haskell's typeclass system). class Monad m => MonadStConcreteNames m runStConcreteNames :: MonadStConcreteNames m => StateT ConcreteNames m a -> m a useConcreteNames :: MonadStConcreteNames m => m ConcreteNames modifyConcreteNames :: MonadStConcreteNames m => (ConcreteNames -> ConcreteNames) -> m () -- | Create a fresh name from a. class FreshName a freshName_ :: (FreshName a, MonadFresh NameId m) => a -> m Name newtype CheckpointId CheckpointId :: Int -> CheckpointId class Monad m => MonadFresh i m fresh :: MonadFresh i m => m i fresh :: (MonadFresh i m, MonadTrans t, MonadFresh i n, t n ~ m) => m i class Enum i => HasFresh i freshLens :: HasFresh i => Lens' i TCState nextFresh' :: HasFresh i => i -> i -- | A complete log for a module will look like this: -- -- data TypeCheckAction EnterSection :: !ModuleName -> !Telescope -> TypeCheckAction LeaveSection :: !ModuleName -> TypeCheckAction -- | Never a Section or ScopeDecl Decl :: !Declaration -> TypeCheckAction Pragmas :: !PragmaOptions -> TypeCheckAction -- | Like CachedTypeCheckLog, but storing the log for an ongoing -- type checking of a module. Stored in reverse order (last performed -- action first). type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)] -- | A log of what the type checker does and states after the action is -- completed. The cached version is stored first executed action first. type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)] data LoadedFileCache LoadedFileCache :: !CachedTypeCheckLog -> !CurrentTypeCheckLog -> LoadedFileCache [lfcCached] :: LoadedFileCache -> !CachedTypeCheckLog [lfcCurrent] :: LoadedFileCache -> !CurrentTypeCheckLog -- | A part of the state which is not reverted when an error is thrown or -- the state is reset. data PersistentTCState PersistentTCSt :: !DecodedModules -> !BiMap RawTopLevelModuleName ModuleNameHash -> CommandLineOptions -> InteractionOutputCallback -> !Benchmark -> !Statistics -> !Maybe LoadedFileCache -> [Backend] -> PersistentTCState [stDecodedModules] :: PersistentTCState -> !DecodedModules -- | Module name hashes for top-level module names (and vice versa). [stPersistentTopLevelModuleNames] :: PersistentTCState -> !BiMap RawTopLevelModuleName ModuleNameHash [stPersistentOptions] :: PersistentTCState -> CommandLineOptions -- | Callback function to call when there is a response to give to the -- interactive frontend. See the documentation of -- InteractionOutputCallback. [stInteractionOutputCallback] :: PersistentTCState -> InteractionOutputCallback -- | Structure to track how much CPU time was spent on which Agda phase. -- Needs to be a strict field to avoid space leaks! [stBenchmark] :: PersistentTCState -> !Benchmark -- | Should be strict field. [stAccumStatistics] :: PersistentTCState -> !Statistics -- | Cached typechecking state from the last loaded file. Should be -- Nothing when checking imports. [stPersistLoadedFileCache] :: PersistentTCState -> !Maybe LoadedFileCache -- | Current backends with their options [stPersistBackends] :: PersistentTCState -> [Backend] -- | A mutual block of names in the signature. data MutualBlock MutualBlock :: MutualInfo -> Set QName -> MutualBlock -- | The original info of the mutual block. [mutualInfo] :: MutualBlock -> MutualInfo [mutualNames] :: MutualBlock -> Set QName data PostScopeState PostScopeState :: !HighlightingInfo -> !DisambiguatedNames -> !LocalMetaStore -> !LocalMetaStore -> !InteractionPoints -> !Constraints -> !Constraints -> !Bool -> !Set QName -> !Signature -> !Map ModuleName CheckpointId -> !DisplayForms -> !Maybe (ModuleName, TopLevelModuleName) -> !TempInstanceTable -> !ConcreteNames -> !Map RawName (DList RawName) -> !Map Name (DList RawName) -> !Statistics -> ![TCWarning] -> !Map MutualId MutualBlock -> !BuiltinThings PrimFun -> !MetaId -> !MutualId -> !ProblemId -> !CheckpointId -> !Int -> !NameId -> !Bool -> !Bool -> !Bool -> !Bool -> !Set QName -> PostScopeState -- | Highlighting info. [stPostSyntaxInfo] :: PostScopeState -> !HighlightingInfo -- | 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. [stPostDisambiguatedNames] :: PostScopeState -> !DisambiguatedNames -- | Used for open meta-variables. [stPostOpenMetaStore] :: PostScopeState -> !LocalMetaStore -- | Used for local, instantiated meta-variables. [stPostSolvedMetaStore] :: PostScopeState -> !LocalMetaStore [stPostInteractionPoints] :: PostScopeState -> !InteractionPoints [stPostAwakeConstraints] :: PostScopeState -> !Constraints [stPostSleepingConstraints] :: PostScopeState -> !Constraints -- | Dirty when a constraint is added, used to prevent pointer update. -- Currently unused. [stPostDirty] :: PostScopeState -> !Bool -- | 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. [stPostOccursCheckDefs] :: PostScopeState -> !Set QName -- | Declared identifiers of the current file. These will be serialized -- after successful type checking. [stPostSignature] :: PostScopeState -> !Signature -- | For each module remember the checkpoint corresponding to the orignal -- context of the module parameters. [stPostModuleCheckpoints] :: PostScopeState -> !Map ModuleName CheckpointId -- | Display forms we add for imported identifiers [stPostImportsDisplayForms] :: PostScopeState -> !DisplayForms -- | The current module is available after it has been type checked. [stPostCurrentModule] :: PostScopeState -> !Maybe (ModuleName, TopLevelModuleName) [stPostInstanceDefs] :: PostScopeState -> !TempInstanceTable -- | Map keeping track of concrete names assigned to each abstract name -- (can be more than one name in case the first one is shadowed) [stPostConcreteNames] :: PostScopeState -> !ConcreteNames -- | 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. [stPostUsedNames] :: PostScopeState -> !Map RawName (DList RawName) -- | Map keeping track for each (abstract) name the list of all (raw) names -- that it could maybe be shadowed by. [stPostShadowingNames] :: PostScopeState -> !Map Name (DList RawName) -- | Counters to collect various statistics about meta variables etc. Only -- for current file. [stPostStatistics] :: PostScopeState -> !Statistics [stPostTCWarnings] :: PostScopeState -> ![TCWarning] [stPostMutualBlocks] :: PostScopeState -> !Map MutualId MutualBlock [stPostLocalBuiltins] :: PostScopeState -> !BuiltinThings PrimFun [stPostFreshMetaId] :: PostScopeState -> !MetaId [stPostFreshMutualId] :: PostScopeState -> !MutualId [stPostFreshProblemId] :: PostScopeState -> !ProblemId [stPostFreshCheckpointId] :: PostScopeState -> !CheckpointId [stPostFreshInt] :: PostScopeState -> !Int [stPostFreshNameId] :: PostScopeState -> !NameId [stPostAreWeCaching] :: PostScopeState -> !Bool [stPostPostponeInstanceSearch] :: PostScopeState -> !Bool [stPostConsideringInstance] :: PostScopeState -> !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. [stPostInstantiateBlocking] :: PostScopeState -> !Bool -- | Local partial definitions, to be stored in the Interface [stPostLocalPartialDefs] :: PostScopeState -> !Set QName type ConcreteNames = Map Name [Name] type DisambiguatedNames = IntMap DisambiguatedName -- | Name disambiguation for the sake of highlighting. data DisambiguatedName DisambiguatedName :: NameKind -> QName -> DisambiguatedName data PreScopeState PreScopeState :: !HighlightingInfo -> !Signature -> !HashSet TopLevelModuleName -> !ModuleToSource -> !VisitedModules -> !ScopeInfo -> !PatternSynDefns -> !PatternSynDefns -> !Maybe (Set QName) -> !PragmaOptions -> !BuiltinThings PrimFun -> !DisplayForms -> !InstanceTable -> !Map BackendName [ForeignCode] -> !InteractionId -> !Map QName Text -> !Map QName Text -> !Maybe Text -> !Set QName -> !Map FilePath ProjectConfig -> !Map FilePath AgdaLibFile -> !RemoteMetaStore -> PreScopeState -- | Highlighting info for tokens and Happy parser warnings (but not for -- those tokens/warnings for which highlighting exists in -- stPostSyntaxInfo). [stPreTokens] :: PreScopeState -> !HighlightingInfo -- | Imported declared identifiers. Those most not be serialized! [stPreImports] :: PreScopeState -> !Signature -- | The top-level modules imported by the current module. [stPreImportedModules] :: PreScopeState -> !HashSet TopLevelModuleName [stPreModuleToSource] :: PreScopeState -> !ModuleToSource [stPreVisitedModules] :: PreScopeState -> !VisitedModules [stPreScope] :: PreScopeState -> !ScopeInfo -- | Pattern synonyms of the current file. Serialized. [stPrePatternSyns] :: PreScopeState -> !PatternSynDefns -- | Imported pattern synonyms. Must not be serialized! [stPrePatternSynImports] :: PreScopeState -> !PatternSynDefns -- | Collected generalizable variables; used during scope checking of terms [stPreGeneralizedVars] :: PreScopeState -> !Maybe (Set QName) -- | Options applying to the current file. OPTIONS pragmas only -- affect this field. [stPrePragmaOptions] :: PreScopeState -> !PragmaOptions [stPreImportedBuiltins] :: PreScopeState -> !BuiltinThings PrimFun -- | Display forms added by someone else to imported identifiers [stPreImportedDisplayForms] :: PreScopeState -> !DisplayForms [stPreImportedInstanceDefs] :: PreScopeState -> !InstanceTable -- | {-# FOREIGN #-} code that should be included in the compiled -- output. Does not include code for imported modules. [stPreForeignCode] :: PreScopeState -> !Map BackendName [ForeignCode] [stPreFreshInteractionId] :: PreScopeState -> !InteractionId -- | Imported UserWarnings, not to be stored in the -- Interface [stPreImportedUserWarnings] :: PreScopeState -> !Map QName Text -- | Locally defined UserWarnings, to be stored in the -- Interface [stPreLocalUserWarnings] :: PreScopeState -> !Map QName Text -- | Whether the current module should raise a warning when opened [stPreWarningOnImport] :: PreScopeState -> !Maybe Text -- | Imported partial definitions, not to be stored in the -- Interface [stPreImportedPartialDefs] :: PreScopeState -> !Set QName -- | Map from directories to paths of closest enclosing .agda-lib files (or -- Nothing if there are none). [stPreProjectConfigs] :: PreScopeState -> !Map FilePath ProjectConfig -- | Contents of .agda-lib files that have already been parsed. [stPreAgdaLibFiles] :: PreScopeState -> !Map FilePath AgdaLibFile -- | Used for meta-variables from other modules. [stPreImportedMetaStore] :: PreScopeState -> !RemoteMetaStore class Monad m => ReadTCState m getTCState :: ReadTCState m => m TCState locallyTCState :: ReadTCState m => Lens' a TCState -> (a -> a) -> m b -> m b withTCState :: ReadTCState m => (TCState -> TCState) -> m a -> m a getTCState :: (ReadTCState m, MonadTrans t, ReadTCState n, t n ~ m) => m TCState locallyTCState :: (ReadTCState m, MonadTransControl t, ReadTCState n, t n ~ m) => Lens' a TCState -> (a -> a) -> m b -> m b pattern PrimitiveSort :: String -> Sort -> Defn primSortName :: Defn -> String primSortSort :: Defn -> Sort pattern Primitive :: IsAbstract -> String -> [Clause] -> FunctionInverse -> Maybe CompiledClauses -> Defn primAbstr :: Defn -> IsAbstract primName :: Defn -> String primClauses :: Defn -> [Clause] primInv :: Defn -> FunctionInverse primCompiled :: Defn -> Maybe CompiledClauses pattern Constructor :: Int -> Int -> ConHead -> QName -> IsAbstract -> Induction -> CompKit -> Maybe [QName] -> [IsForced] -> Maybe [Bool] -> Defn conPars :: Defn -> Int conArity :: Defn -> Int conSrcCon :: Defn -> ConHead conData :: Defn -> QName conAbstr :: Defn -> IsAbstract conInd :: Defn -> Induction conComp :: Defn -> CompKit conProj :: Defn -> Maybe [QName] conForced :: Defn -> [IsForced] conErased :: Defn -> Maybe [Bool] pattern Record :: Nat -> Maybe Clause -> ConHead -> Bool -> [Dom QName] -> Telescope -> Maybe [QName] -> EtaEquality -> PatternOrCopattern -> Maybe Induction -> Maybe Bool -> IsAbstract -> CompKit -> Defn recPars :: Defn -> Nat recClause :: Defn -> Maybe Clause recConHead :: Defn -> ConHead recNamedCon :: Defn -> Bool recFields :: Defn -> [Dom QName] recTel :: Defn -> Telescope recMutual :: Defn -> Maybe [QName] recEtaEquality' :: Defn -> EtaEquality recPatternMatching :: Defn -> PatternOrCopattern recInduction :: Defn -> Maybe Induction recTerminates :: Defn -> Maybe Bool recAbstr :: Defn -> IsAbstract recComp :: Defn -> CompKit pattern Datatype :: Nat -> Nat -> Maybe Clause -> [QName] -> Sort -> Maybe [QName] -> IsAbstract -> [QName] -> Maybe QName -> Maybe QName -> Defn dataPars :: Defn -> Nat dataIxs :: Defn -> Nat dataClause :: Defn -> Maybe Clause dataCons :: Defn -> [QName] dataSort :: Defn -> Sort dataMutual :: Defn -> Maybe [QName] dataAbstr :: Defn -> IsAbstract dataPathCons :: Defn -> [QName] dataTranspIx :: Defn -> Maybe QName dataTransp :: Defn -> Maybe QName pattern Function :: [Clause] -> Maybe CompiledClauses -> Maybe SplitTree -> Maybe Compiled -> [Clause] -> FunctionInverse -> Maybe [QName] -> IsAbstract -> Delayed -> Either ProjectionLikenessMissing Projection -> Set FunctionFlag -> Maybe Bool -> Maybe ExtLamInfo -> Maybe QName -> Maybe QName -> Defn funClauses :: Defn -> [Clause] funCompiled :: Defn -> Maybe CompiledClauses funSplitTree :: Defn -> Maybe SplitTree funTreeless :: Defn -> Maybe Compiled funCovering :: Defn -> [Clause] funInv :: Defn -> FunctionInverse funMutual :: Defn -> Maybe [QName] funAbstr :: Defn -> IsAbstract funDelayed :: Defn -> Delayed funProjection :: Defn -> Either ProjectionLikenessMissing Projection funFlags :: Defn -> Set FunctionFlag funTerminates :: Defn -> Maybe Bool funExtLam :: Defn -> Maybe ExtLamInfo funWith :: Defn -> Maybe QName funIsKanOp :: Defn -> Maybe QName pattern DataOrRecSig :: Int -> Defn datarecPars :: Defn -> Int pattern Axiom :: Bool -> Defn axiomConstTransp :: Defn -> Bool -- | Empty persistent state. initPersistentState :: PersistentTCState -- | An initial MetaId. initialMetaId :: MetaId -- | Empty state of type checker. initPreScopeState :: PreScopeState initPostScopeState :: PostScopeState initState :: TCState stTokens :: Lens' HighlightingInfo TCState stImports :: Lens' Signature TCState stImportedModules :: Lens' (HashSet TopLevelModuleName) TCState stModuleToSource :: Lens' ModuleToSource TCState stVisitedModules :: Lens' VisitedModules TCState stScope :: Lens' ScopeInfo TCState stPatternSyns :: Lens' PatternSynDefns TCState stPatternSynImports :: Lens' PatternSynDefns TCState stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState stPragmaOptions :: Lens' PragmaOptions TCState stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState stFreshInteractionId :: Lens' InteractionId TCState stImportedUserWarnings :: Lens' (Map QName Text) TCState stLocalUserWarnings :: Lens' (Map QName Text) TCState getUserWarnings :: ReadTCState m => m (Map QName Text) stWarningOnImport :: Lens' (Maybe Text) TCState stImportedPartialDefs :: Lens' (Set QName) TCState stLocalPartialDefs :: Lens' (Set QName) TCState getPartialDefs :: ReadTCState m => m (Set QName) stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState stBackends :: Lens' [Backend] TCState stProjectConfigs :: Lens' (Map FilePath ProjectConfig) TCState stAgdaLibFiles :: Lens' (Map FilePath AgdaLibFile) TCState stTopLevelModuleNames :: Lens' (BiMap RawTopLevelModuleName ModuleNameHash) TCState stImportedMetaStore :: Lens' RemoteMetaStore TCState stFreshNameId :: Lens' NameId TCState stSyntaxInfo :: Lens' HighlightingInfo TCState stDisambiguatedNames :: Lens' DisambiguatedNames TCState stOpenMetaStore :: Lens' LocalMetaStore TCState stSolvedMetaStore :: Lens' LocalMetaStore 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 -- | Note that the lens is "strict". stCurrentModule :: Lens' (Maybe (ModuleName, TopLevelModuleName)) TCState stImportedInstanceDefs :: Lens' InstanceTable TCState stInstanceDefs :: Lens' TempInstanceTable TCState stConcreteNames :: Lens' ConcreteNames TCState stUsedNames :: Lens' (Map RawName (DList RawName)) TCState stShadowingNames :: Lens' (Map Name (DList 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 -- | Union two Builtins. Only defined for -- BuiltinRewriteRelations. unionBuiltin :: Builtin a -> Builtin a -> Builtin a 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 -- | Combines the source hash and the (full) hashes of the imported -- modules. iFullHash :: Interface -> Hash -- | A lens for the iSignature field of the Interface type. intSignature :: Lens' Signature Interface buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a) -- | Embed Comparison into CompareDirection. fromCmp :: Comparison -> CompareDirection -- | Flip the direction of comparison. flipCmp :: CompareDirection -> CompareDirection -- | Turn a Comparison function into a CompareDirection -- function. -- -- Property: dirToCmp f (fromCmp cmp) = f cmp dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c normalMetaPriority :: MetaPriority lowMetaPriority :: MetaPriority highMetaPriority :: MetaPriority getMetaInfo :: MetaVariable -> Closure Range getMetaScope :: MetaVariable -> ScopeInfo getMetaEnv :: MetaVariable -> TCEnv getMetaSig :: MetaVariable -> Signature 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 -- | By default, we have no display form. defaultDisplayForm :: QName -> [LocalDisplayForm] lensTheDef :: Lens' Defn Definition -- | Create a definition with sensible defaults. defaultDefn :: ArgInfo -> QName -> Type -> Language -> Defn -> Definition jsBackendName :: BackendName ghcBackendName :: BackendName noCompiledRep :: CompiledRepresentation modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo -- | Building the projection function (which drops the parameters). projDropPars :: Projection -> ProjOrigin -> Term -- | The info of the principal (record) argument. projArgInfo :: Projection -> ArgInfo -- | Make sure we do not overwrite a user specification. setEtaEquality :: EtaEquality -> HasEta -> EtaEquality emptyCompKit :: CompKit defaultAxiom :: Defn constTranspAxiom :: Defn lensFunction :: Lens' FunctionData Defn lensConstructor :: Lens' ConstructorData Defn lensRecord :: Lens' RecordData Defn lensRecTel :: Lens' Telescope RecordData -- | Is the record type recursive? recRecursive :: Defn -> Bool recEtaEquality :: Defn -> HasEta -- | A template for creating Function definitions, with sensible -- defaults. emptyFunctionData :: FunctionData emptyFunction :: Defn funFlag :: FunctionFlag -> Lens' Bool Defn funStatic :: Lens' Bool Defn funInline :: Lens' Bool Defn funMacro :: Lens' Bool Defn isMacro :: Defn -> Bool -- | Checking whether we are dealing with a function yet to be defined. isEmptyFunction :: Defn -> Bool isCopatternLHS :: [Clause] -> Bool recCon :: Defn -> QName defIsRecord :: Defn -> Bool defIsDataOrRecord :: Defn -> Bool defConstructors :: Defn -> [QName] redReturn :: a -> ReduceM (Reduced a' a) -- | Conceptually: redBind m f k = either (return . Left . f) k -- =<< m redBind :: ReduceM (Reduced a a') -> (a -> b) -> (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b') notReduced :: a -> MaybeReduced a reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term) -- | Not quite all reductions (skip non-terminating reductions) allReductions :: AllowedReductions reallyAllReductions :: AllowedReductions reduceAllDefs :: ReduceDefs locallyReduceDefs :: MonadTCEnv m => ReduceDefs -> m a -> m a locallyReduceAllDefs :: MonadTCEnv m => m a -> m a shouldReduceDef :: MonadTCEnv m => QName -> m Bool locallyReconstructed :: MonadTCEnv m => m a -> m a isReconstructed :: MonadTCEnv m => m Bool primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun defClauses :: Definition -> [Clause] defCompiled :: Definition -> Maybe CompiledClauses defParameters :: Definition -> Maybe Nat defInverse :: Definition -> FunctionInverse defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma] -- | Are the clauses of this definition delayed? defDelayed :: Definition -> Delayed -- | Has the definition failed the termination checker? defNonterminating :: Definition -> Bool -- | Has the definition not termination checked or did the check fail? defTerminationUnconfirmed :: Definition -> Bool defAbstract :: Definition -> IsAbstract defForced :: Definition -> [IsForced] -- | ifTopLevelAndHighlightingLevelIs l b m runs m when -- we're type-checking the top-level module (or before we've started -- doing this) and either the highlighting level is at least -- l or b is True. ifTopLevelAndHighlightingLevelIsOr :: MonadTCEnv tcm => HighlightingLevel -> Bool -> tcm () -> tcm () -- | ifTopLevelAndHighlightingLevelIs l m runs m when -- we're type-checking the top-level module (or before we've started -- doing this) and the highlighting level is at least l. ifTopLevelAndHighlightingLevelIs :: MonadTCEnv tcm => HighlightingLevel -> tcm () -> tcm () initEnv :: TCEnv defaultUnquoteFlags :: UnquoteFlags unquoteNormalise :: Lens' Bool UnquoteFlags eUnquoteNormalise :: Lens' Bool TCEnv eContext :: Lens' Context TCEnv eLetBindings :: Lens' LetBindings TCEnv eCurrentModule :: Lens' ModuleName TCEnv eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv eImportPath :: Lens' [TopLevelModuleName] TCEnv eMutualBlock :: Lens' (Maybe MutualId) TCEnv eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv eCoverageCheck :: Lens' CoverageCheck TCEnv eMakeCase :: Lens' Bool TCEnv eSolvingConstraints :: Lens' Bool TCEnv eCheckingWhere :: Lens' Bool TCEnv eWorkingOnTypes :: Lens' Bool TCEnv eAssignMetas :: Lens' Bool TCEnv eActiveProblems :: Lens' (Set ProblemId) TCEnv eAbstractMode :: Lens' AbstractMode TCEnv eModality :: Lens' Modality TCEnv eRelevance :: Lens' Relevance TCEnv eQuantity :: Lens' Quantity TCEnv eSplitOnStrict :: Lens' Bool TCEnv eDisplayFormsEnabled :: Lens' Bool TCEnv eRange :: Lens' Range TCEnv eHighlightingRange :: Lens' Range TCEnv eCall :: Lens' (Maybe (Closure Call)) TCEnv eHighlightingLevel :: Lens' HighlightingLevel TCEnv eHighlightingMethod :: Lens' HighlightingMethod TCEnv eExpandLast :: Lens' ExpandHidden TCEnv eAppDef :: Lens' (Maybe QName) TCEnv eSimplification :: Lens' Simplification TCEnv eAllowedReductions :: Lens' AllowedReductions TCEnv eReduceDefs :: Lens' ReduceDefs TCEnv eReconstructed :: Lens' Bool TCEnv eInjectivityDepth :: Lens' Int TCEnv eCompareBlocked :: Lens' Bool TCEnv ePrintDomainFreePi :: Lens' Bool TCEnv ePrintMetasBare :: Lens' Bool TCEnv eInsideDotPattern :: Lens' Bool TCEnv eUnquoteFlags :: Lens' UnquoteFlags TCEnv eInstanceDepth :: Lens' Int TCEnv eIsDebugPrinting :: Lens' Bool TCEnv ePrintingPatternLambdas :: Lens' [QName] TCEnv eCallByNeed :: Lens' Bool TCEnv eCurrentCheckpoint :: Lens' CheckpointId TCEnv eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv eGeneralizeMetas :: Lens' DoGeneralize TCEnv eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv eActiveBackendName :: Lens' (Maybe BackendName) TCEnv eConflComputingOverlap :: Lens' Bool TCEnv eCurrentlyElaborating :: Lens' Bool TCEnv aDefToMode :: IsAbstract -> AbstractMode aModeToDef :: AbstractMode -> Maybe IsAbstract isDontExpandLast :: ExpandHidden -> Bool recordFieldWarningToError :: RecordFieldWarning -> TypeError warningName :: Warning -> WarningName tcWarningOrigin :: TCWarning -> SrcFile sizedTypesOption :: HasOptions m => m Bool guardednessOption :: HasOptions m => m Bool withoutKOption :: HasOptions m => m Bool cubicalCompatibleOption :: HasOptions m => m Bool enableCaching :: HasOptions m => m Bool mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv -> ReduceEnv reduceEnv :: Lens' TCEnv ReduceEnv reduceSt :: Lens' TCState ReduceEnv onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b thenReduce :: ReduceM a -> ReduceM b -> ReduceM b beforeReduce :: ReduceM a -> ReduceM b -> ReduceM a bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b runReduceM :: ReduceM a -> TCM a runReduceF :: (a -> ReduceM b) -> TCM (a -> b) useR :: ReadTCState m => Lens' a TCState -> m a askR :: ReduceM ReduceEnv localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a -- | Modify the lens-indicated part of the TCEnv in a -- subcomputation. locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b getsTC :: ReadTCState m => (TCState -> a) -> m a -- | A variant of modifyTC in which the computation is strict in the -- new state. modifyTC' :: MonadTCState m => (TCState -> TCState) -> m () useTC :: ReadTCState m => Lens' a TCState -> m a -- | Overwrite the part of the TCState focused on by the lens. setTCLens :: MonadTCState m => Lens' a TCState -> a -> m () infix 4 `setTCLens` -- | Overwrite the part of the TCState focused on by the lens -- (strictly). setTCLens' :: MonadTCState m => Lens' a TCState -> a -> m () -- | Modify 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 -- (strictly). modifyTCLens' :: MonadTCState m => Lens' a TCState -> (a -> a) -> m () -- | Modify a part of the state monadically. modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m () -- | Modify the part of the TCState focused on by the lens, and -- return some result. stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r, a)) -> m r -- | Modify a part of the state monadically, and return some result. stateTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m (r, a)) -> m r runBlocked :: Monad m => BlockT m a -> m (Either Blocker a) mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a returnTCMT :: Applicative m => a -> TCMT m a bindTCMT :: Monad m => TCMT m a -> (a -> TCMT m b) -> TCMT m b thenTCMT :: Applicative m => TCMT m a -> TCMT m b -> TCMT m b fmapTCMT :: Functor m => (a -> b) -> TCMT m a -> TCMT m b apTCMT :: Applicative m => TCMT m (a -> b) -> TCMT m a -> TCMT m b -- | Preserve the state of the failing computation. catchError_ :: TCM a -> (TCErr -> TCM a) -> 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. finally_ :: TCM a -> TCM b -> TCM a internalError :: (HasCallStack, MonadTCM tcm) => String -> tcm a -- | Utility function for 1-arg constructed type errors. Note that the -- HasCallStack constraint is on the *resulting* function. locatedTypeError :: MonadTCError m => (a -> TypeError) -> HasCallStack => a -> m b genericError :: (HasCallStack, MonadTCError m) => String -> m a genericDocError :: (HasCallStack, MonadTCError m) => Doc -> m a typeError' :: MonadTCError m => CallStack -> TypeError -> m a typeError :: (HasCallStack, MonadTCError m) => TypeError -> m a typeError'_ :: (MonadTCEnv m, ReadTCState m) => CallStack -> TypeError -> m TCErr typeError_ :: (HasCallStack, MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr -- | Running the type checking monad (most general form). runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState) -- | Running the type checking monad on toplevel (with initial state). runTCMTop :: TCM a -> IO (Either TCErr a) runTCMTop' :: MonadIO m => TCMT m a -> m a -- | runSafeTCM runs a safe TCMT action (a TCMT action -- which cannot fail, except that it might raise IOExceptions) in -- the initial environment. runSafeTCM :: TCM a -> TCState -> IO (a, TCState) -- | Runs the given computation in a separate thread, with a copy of -- the current state and environment. -- -- Note that Agda sometimes uses actual, mutable state. If the -- computation given to forkTCM tries to modify this -- state, then bad things can happen, because accesses are not mutually -- exclusive. The forkTCM function has been added mainly to -- allow the thread to read (a snapshot of) the current state in a -- convenient way. -- -- Note also that exceptions which are raised in the thread are not -- propagated to the parent, so the thread should not do anything -- important. forkTCM :: TCM a -> TCM () -- | Base name for patterns in telescopes patternInTeleName :: String -- | Base name for extended lambda patterns extendedLambdaName :: String -- | Check whether we have an definition from an extended lambda. isExtendedLambdaName :: QName -> Bool -- | Name of absurdLambda definitions. absurdLambdaName :: String -- | Check whether we have an definition from an absurd lambda. isAbsurdLambdaName :: QName -> Bool -- | Base name for generalized variable projections generalizedFieldName :: String -- | Check whether we have a generalized variable field getGeneralizedFieldName :: QName -> Maybe String class (Functor m, Applicative m, Monad m) => HasOptions m -- | Returns the pragma options which are currently in effect. pragmaOptions :: HasOptions m => m PragmaOptions -- | Returns the command line options which are currently in effect. commandLineOptions :: HasOptions m => m CommandLineOptions -- | Returns the pragma options which are currently in effect. pragmaOptions :: (HasOptions m, HasOptions n, MonadTrans t, m ~ t n) => m PragmaOptions -- | Returns the command line options which are currently in effect. commandLineOptions :: (HasOptions m, HasOptions n, MonadTrans t, m ~ t n) => m CommandLineOptions instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.DisambiguatedName instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.MutualBlock instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.MutualBlock instance GHC.Show.Show Agda.TypeChecking.Monad.Base.MutualBlock instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TypeCheckAction instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Num.Num Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Real.Integral Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Real.Real Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CheckpointId instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ModuleCheckMode instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ModuleCheckMode instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.ModuleCheckMode instance GHC.Enum.Bounded Agda.TypeChecking.Monad.Base.ModuleCheckMode instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.ModuleCheckMode instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.ModuleCheckMode instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ForeignCode instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ForeignCode instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.WhyCheckModality instance GHC.Show.Show Agda.TypeChecking.Monad.Base.WhyCheckModality instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Comparison instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Comparison instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Comparison instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CompareDirection instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CompareDirection instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.CompareAs instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CompareAs instance GHC.Generics.Generic (Agda.TypeChecking.Monad.Base.Open a) instance Data.Traversable.Traversable Agda.TypeChecking.Monad.Base.Open instance Data.Foldable.Foldable Agda.TypeChecking.Monad.Base.Open instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.Open instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Monad.Base.Open a) instance GHC.Generics.Generic (Agda.TypeChecking.Monad.Base.Judgement a) instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Monad.Base.Judgement a) instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.DoGeneralize instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DoGeneralize instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.DoGeneralize instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.DoGeneralize instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.GeneralizedValue instance GHC.Show.Show Agda.TypeChecking.Monad.Base.GeneralizedValue instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Frozen instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Frozen instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Frozen instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Instantiation instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Instantiation instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance GHC.Show.Show Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PrincipalArgTypeMetas instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.MetaPriority instance GHC.Show.Show Agda.TypeChecking.Monad.Base.MetaPriority instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.MetaPriority instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.MetaPriority instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.RunMetaOccursCheck instance GHC.Show.Show Agda.TypeChecking.Monad.Base.RunMetaOccursCheck instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.RunMetaOccursCheck instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.RunMetaOccursCheck instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Overapplied instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Overapplied instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Overapplied instance GHC.Generics.Generic (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance Data.Traversable.Traversable Agda.TypeChecking.Monad.Base.IPBoundary' instance Data.Foldable.Foldable Agda.TypeChecking.Monad.Base.IPBoundary' instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.IPBoundary' instance GHC.Show.Show t => GHC.Show.Show (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Section instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Section instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.DisplayTerm instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DisplayTerm instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.DisplayForm instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DisplayForm instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.NLPType instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NLPType instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.NLPat instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NLPat instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.NLPSort instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NLPSort instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.RewriteRule instance GHC.Show.Show Agda.TypeChecking.Monad.Base.RewriteRule instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NumGeneralizableArgs instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Polarity instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Polarity instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Polarity instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.IsForced instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.IsForced instance GHC.Show.Show Agda.TypeChecking.Monad.Base.IsForced instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.CompilerPragma instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CompilerPragma instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CompilerPragma instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.System instance GHC.Show.Show Agda.TypeChecking.Monad.Base.System instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ExtLamInfo instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ExtLamInfo instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ProjLams instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.ProjLams instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ProjLams instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Projection instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Projection instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.EtaEquality instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.EtaEquality instance GHC.Show.Show Agda.TypeChecking.Monad.Base.EtaEquality instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.FunctionFlag instance GHC.Show.Show Agda.TypeChecking.Monad.Base.FunctionFlag instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.FunctionFlag instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.FunctionFlag instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.FunctionFlag instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.CompKit instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CompKit instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.CompKit instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CompKit instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.AxiomData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.AxiomData instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.DataOrRecSigData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DataOrRecSigData instance GHC.Enum.Bounded Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.DatatypeData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DatatypeData instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.RecordData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.RecordData instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ConstructorData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ConstructorData instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PrimitiveSortData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.PrimitiveSortData instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.Fields instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Simplification instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Simplification instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Simplification instance GHC.Base.Functor (Agda.TypeChecking.Monad.Base.Reduced no) instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.MaybeReduced instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Ix.Ix Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Enum.Bounded Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Show.Show Agda.TypeChecking.Monad.Base.AllowedReduction instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ReduceDefs instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TermHead instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TermHead instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.TermHead instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.TermHead instance GHC.Generics.Generic (Agda.TypeChecking.Monad.Base.FunctionInverse' c) instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.FunctionInverse' instance GHC.Show.Show c => GHC.Show.Show (Agda.TypeChecking.Monad.Base.FunctionInverse' c) instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PrimitiveData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.PrimitiveData instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.FunctionData instance GHC.Show.Show Agda.TypeChecking.Monad.Base.FunctionData instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Defn instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Defn instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.MutualId instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.MutualId instance GHC.Num.Num Agda.TypeChecking.Monad.Base.MutualId instance GHC.Show.Show Agda.TypeChecking.Monad.Base.MutualId instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.MutualId instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.MutualId instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Definition instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Definition instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Signature instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Signature instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Call instance GHC.Generics.Generic (Agda.TypeChecking.Monad.Base.Builtin pf) instance Data.Traversable.Traversable Agda.TypeChecking.Monad.Base.Builtin instance Data.Foldable.Foldable Agda.TypeChecking.Monad.Base.Builtin instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.Builtin instance GHC.Show.Show pf => GHC.Show.Show (Agda.TypeChecking.Monad.Base.Builtin pf) instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.HighlightingLevel instance GHC.Read.Read Agda.TypeChecking.Monad.Base.HighlightingLevel instance GHC.Show.Show Agda.TypeChecking.Monad.Base.HighlightingLevel instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.HighlightingLevel instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.HighlightingLevel instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.HighlightingMethod instance GHC.Read.Read Agda.TypeChecking.Monad.Base.HighlightingMethod instance GHC.Show.Show Agda.TypeChecking.Monad.Base.HighlightingMethod instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.HighlightingMethod instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.UnquoteFlags instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.AbstractMode instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.AbstractMode instance GHC.Show.Show Agda.TypeChecking.Monad.Base.AbstractMode instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ExpandHidden instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.ExpandHidden instance GHC.Generics.Generic (Agda.TypeChecking.Monad.Base.Closure a) instance Data.Foldable.Foldable Agda.TypeChecking.Monad.Base.Closure instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.Closure instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.IPClause instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TCEnv instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.InteractionPoint instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.MetaInfo instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.CandidateKind instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CandidateKind instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Candidate instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Candidate instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.RecordFieldWarning instance GHC.Show.Show Agda.TypeChecking.Monad.Base.RecordFieldWarning instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.CallInfo instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CallInfo instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TerminationError instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TerminationError instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.NegativeUnification instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NegativeUnification instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.UnificationFailure instance GHC.Show.Show Agda.TypeChecking.Monad.Base.UnificationFailure instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.SplitError instance GHC.Show.Show Agda.TypeChecking.Monad.Base.SplitError instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.LHSOrPatSyn instance GHC.Show.Show Agda.TypeChecking.Monad.Base.LHSOrPatSyn instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.LHSOrPatSyn instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PreScopeState instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Listener instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Monad.Base.ArgsCheckState a) instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TypeCheckingProblem instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.MetaInstantiation instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.MetaVariable instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PrimFun instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PostScopeState instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.LoadedFileCache instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Interface instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Interface instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.UnquoteError instance GHC.Show.Show Agda.TypeChecking.Monad.Base.UnquoteError instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TypeError instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TypeError instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Constraint instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Constraint instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ProblemConstraint instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ProblemConstraint instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.Warning instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Warning instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TCWarning instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TCWarning instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.ModuleInfo instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.PersistentTCState instance GHC.Generics.Generic Agda.TypeChecking.Monad.Base.TCState instance Agda.TypeChecking.Monad.Base.MonadTCM m => Agda.TypeChecking.Monad.Base.MonadTCM (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.Interaction.Options.HasOptions.HasOptions m => Agda.Interaction.Options.HasOptions.HasOptions (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Agda.TypeChecking.Monad.Base.BlockT m) instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Agda.TypeChecking.Monad.Base.BlockT m) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Agda.TypeChecking.Monad.Base.BlockT m) instance Control.Monad.Trans.Class.MonadTrans Agda.TypeChecking.Monad.Base.BlockT instance GHC.Base.Monad m => GHC.Base.Monad (Agda.TypeChecking.Monad.Base.BlockT m) instance GHC.Base.Monad m => GHC.Base.Applicative (Agda.TypeChecking.Monad.Base.BlockT m) instance GHC.Base.Functor m => GHC.Base.Functor (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Agda.TypeChecking.Monad.Base.BlockT m) instance GHC.Base.Monad m => Agda.TypeChecking.Monad.Base.MonadBlock (Agda.TypeChecking.Monad.Base.BlockT m) instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.MonadReduce (Agda.TypeChecking.Monad.Base.TCMT m) instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.MonadTCM (Agda.TypeChecking.Monad.Base.TCMT m) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Agda.Utils.Update.ChangeT tcm) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.Except.ExceptT err tcm) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.Identity.IdentityT tcm) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Agda.Utils.ListT.ListT tcm) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.Maybe.MaybeT tcm) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.Reader.ReaderT r tcm) instance Agda.TypeChecking.Monad.Base.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.State.Lazy.StateT s tcm) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Base.MonadTCM tcm) => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.Writer.Lazy.WriterT w tcm) instance Agda.TypeChecking.Monad.Base.MonadReduce Agda.TypeChecking.Monad.Base.ReduceM instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Agda.Utils.Update.ChangeT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.Except.ExceptT err m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.State.Lazy.StateT w m) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Base.MonadReduce m) => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Agda.Utils.Update.ChangeT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.Except.ExceptT err m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.State.Lazy.StateT s m) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Base.ReadTCState m) => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.TypeChecking.Monad.Base.ReduceM instance Agda.Interaction.Options.HasOptions.HasOptions Agda.TypeChecking.Monad.Base.ReduceM instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.ReadTCState (Agda.TypeChecking.Monad.Base.TCMT m) instance Agda.TypeChecking.Monad.Base.HasFresh i => Agda.TypeChecking.Monad.Base.MonadFresh i Agda.TypeChecking.Monad.Base.TCM instance Agda.TypeChecking.Monad.Base.HasFresh Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Monad.Base.HasFresh Agda.TypeChecking.Monad.Base.MutualId instance Agda.TypeChecking.Monad.Base.HasFresh Agda.Syntax.Common.InteractionId instance Agda.TypeChecking.Monad.Base.HasFresh Agda.Syntax.Common.NameId instance Agda.TypeChecking.Monad.Base.HasFresh GHC.Types.Int instance Agda.TypeChecking.Monad.Base.HasFresh Agda.Syntax.Common.ProblemId instance Agda.TypeChecking.Monad.Base.HasFresh Agda.TypeChecking.Monad.Base.CheckpointId instance Control.Monad.IO.Class.MonadIO m => Agda.Interaction.Options.HasOptions.HasOptions (Agda.TypeChecking.Monad.Base.TCMT m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.Except.ExceptT err m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.State.Lazy.StateT s m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Agda.Utils.Update.ChangeT m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.Identity.IdentityT m) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Base.MonadTCState m) => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.MonadTCState (Agda.TypeChecking.Monad.Base.TCMT m) instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TCState instance Agda.TypeChecking.Monad.Base.MonadStConcreteNames Agda.TypeChecking.Monad.Base.TCM instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Interface instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.Constraint instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Monad.Base.Constraint instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.TypeChecking.Monad.Base.Constraint instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Listener instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.Listener instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.MetaInstantiation instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.MetaVariable instance Agda.Syntax.Position.SetRange Agda.TypeChecking.Monad.Base.MetaVariable instance Agda.Syntax.Common.LensModality Agda.TypeChecking.Monad.Base.MetaVariable instance Agda.Syntax.Common.LensRelevance Agda.TypeChecking.Monad.Base.MetaVariable instance Agda.Syntax.Common.LensQuantity Agda.TypeChecking.Monad.Base.MetaVariable instance Agda.TypeChecking.Monad.Base.LensClosure Agda.Syntax.Position.Range Agda.TypeChecking.Monad.Base.MetaVariable instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.TCWarning instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.TCWarning instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TCErr instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.TCErr instance GHC.Exception.Type.Exception Agda.TypeChecking.Monad.Base.TCErr instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.ReduceM instance GHC.Base.Applicative Agda.TypeChecking.Monad.Base.ReduceM instance GHC.Base.Monad Agda.TypeChecking.Monad.Base.ReduceM instance Control.Monad.Fail.MonadFail Agda.TypeChecking.Monad.Base.ReduceM instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.TypeChecking.Monad.Base.ReduceM instance GHC.Base.Monad m => Agda.TypeChecking.Monad.Base.MonadBlock (Control.Monad.Trans.Except.ExceptT Agda.TypeChecking.Monad.Base.TCErr m) instance GHC.Base.Functor m => GHC.Base.Functor (Agda.TypeChecking.Monad.Base.TCMT m) instance GHC.Base.Applicative m => GHC.Base.Applicative (Agda.TypeChecking.Monad.Base.TCMT m) instance Control.Monad.Trans.Class.MonadTrans Agda.TypeChecking.Monad.Base.TCMT instance GHC.Base.Monad m => GHC.Base.Monad (Agda.TypeChecking.Monad.Base.TCMT m) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.Fail.MonadFail (Agda.TypeChecking.Monad.Base.TCMT m) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Agda.TypeChecking.Monad.Base.TCMT m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Agda.TypeChecking.Monad.Base.TCMT m) instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.TypeChecking.Monad.Base.TCMT m) instance Agda.TypeChecking.Monad.Base.MonadBlock Agda.TypeChecking.Monad.Base.TCM instance Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr Agda.TypeChecking.Monad.Base.TCM instance Agda.Utils.Impossible.CatchImpossible Agda.TypeChecking.Monad.Base.TCM instance (Data.String.IsString a, Control.Monad.IO.Class.MonadIO m) => Data.String.IsString (Agda.TypeChecking.Monad.Base.TCMT m a) instance (Control.Monad.IO.Class.MonadIO m, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Agda.TypeChecking.Monad.Base.TCMT m a) instance (Control.Monad.IO.Class.MonadIO m, GHC.Base.Semigroup a, GHC.Base.Monoid a) => GHC.Base.Monoid (Agda.TypeChecking.Monad.Base.TCMT m a) instance (Control.Monad.IO.Class.MonadIO m, Agda.Utils.Null.Null a) => Agda.Utils.Null.Null (Agda.TypeChecking.Monad.Base.TCMT m a) instance Agda.Utils.Benchmark.MonadBench Agda.TypeChecking.Monad.Base.TCM instance Agda.Utils.Null.Null (Agda.TypeChecking.Monad.Base.TCM Text.PrettyPrint.HughesPJ.Doc) instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TCErr instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PreScopeState instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PostScopeState instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TCState instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PersistentTCState instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.LoadedFileCache instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ModuleInfo instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Interface instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ProblemConstraint instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Constraint instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.MetaVariable instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Listener instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.MetaInstantiation instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TypeCheckingProblem instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PrimFun instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Warning instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TCWarning instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.UnquoteError instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TypeError instance Agda.TypeChecking.Monad.Base.MonadBlock m => Agda.TypeChecking.Monad.Base.MonadBlock (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Base.MonadBlock m => Agda.TypeChecking.Monad.Base.MonadBlock (Control.Monad.Trans.Reader.ReaderT e m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.Utils.Update.ChangeT m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Control.Monad.Trans.Except.ExceptT err m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Control.Monad.Trans.State.Lazy.StateT s m) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Base.MonadTCEnv m) => Agda.TypeChecking.Monad.Base.MonadTCEnv (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.Utils.ListT.ListT m) instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.LHSOrPatSyn instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.SplitError instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.UnificationFailure instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.NegativeUnification instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TerminationError instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.CallInfo instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CallInfo instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.CallInfo instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.RecordFieldWarning instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.Candidate instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Candidate instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.CandidateKind instance Agda.TypeChecking.Monad.Base.LensClosure a (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.Monad.Base.LensClosure Agda.Syntax.Position.Range Agda.TypeChecking.Monad.Base.MetaInfo instance Agda.Syntax.Common.LensIsAbstract Agda.TypeChecking.Monad.Base.MetaInfo instance Agda.Syntax.Common.LensModality Agda.TypeChecking.Monad.Base.MetaInfo instance Agda.Syntax.Common.LensQuantity Agda.TypeChecking.Monad.Base.MetaInfo instance Agda.Syntax.Common.LensRelevance Agda.TypeChecking.Monad.Base.MetaInfo instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.MetaInfo instance Agda.Syntax.Position.SetRange Agda.TypeChecking.Monad.Base.MetaInfo instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.MetaInfo instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.InteractionPoints instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.InteractionPoint instance Agda.Utils.BiMap.HasTag Agda.TypeChecking.Monad.Base.InteractionPoint instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.InteractionPoint instance Agda.TypeChecking.Monad.Base.LensTCEnv (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.Syntax.Common.LensIsAbstract (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.Monad.Base.LensTCEnv Agda.TypeChecking.Monad.Base.TCEnv instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.Syntax.Common.LensIsAbstract Agda.TypeChecking.Monad.Base.TCEnv instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.IPClause instance Agda.Syntax.Common.LensModality Agda.TypeChecking.Monad.Base.TCEnv instance Agda.Syntax.Common.LensRelevance Agda.TypeChecking.Monad.Base.TCEnv instance Agda.Syntax.Common.LensQuantity Agda.TypeChecking.Monad.Base.TCEnv instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.TypeChecking.Monad.Base.Closure a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.TypeChecking.Monad.Base.Closure a) instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.IPClause instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TCEnv instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ExpandHidden instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.AbstractMode instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.UnquoteFlags instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.HighlightingMethod instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.HighlightingLevel instance Control.DeepSeq.NFData pf => Control.DeepSeq.NFData (Agda.TypeChecking.Monad.Base.Builtin pf) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Call instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.Call instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Call instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Signature instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Signature instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Definitions instance Agda.Syntax.Common.LensArgInfo Agda.TypeChecking.Monad.Base.Definition instance Agda.Syntax.Common.LensModality Agda.TypeChecking.Monad.Base.Definition instance Agda.Syntax.Common.LensQuantity Agda.TypeChecking.Monad.Base.Definition instance Agda.Syntax.Common.LensRelevance Agda.TypeChecking.Monad.Base.Definition instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Definition instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Definition instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Definition instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.MutualId instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Defn instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Defn instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Defn instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.FunctionData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.FunctionData instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.PrimitiveData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PrimitiveData instance Agda.Utils.Pretty.Pretty c => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Monad.Base.FunctionInverse' c) instance Agda.Syntax.Position.KillRange c => Agda.Syntax.Position.KillRange (Agda.TypeChecking.Monad.Base.FunctionInverse' c) instance Control.DeepSeq.NFData c => Control.DeepSeq.NFData (Agda.TypeChecking.Monad.Base.FunctionInverse' c) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.TermHead instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.TermHead instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TermHead instance GHC.Base.Semigroup Agda.TypeChecking.Monad.Base.ReduceDefs instance GHC.Base.Monoid Agda.TypeChecking.Monad.Base.ReduceDefs instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ReduceDefs instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.AllowedReduction instance Agda.Syntax.Internal.Elim.IsProjElim e => Agda.Syntax.Internal.Elim.IsProjElim (Agda.TypeChecking.Monad.Base.MaybeReduced e) instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.Simplification instance GHC.Base.Semigroup Agda.TypeChecking.Monad.Base.Simplification instance GHC.Base.Monoid Agda.TypeChecking.Monad.Base.Simplification instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Simplification instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.PrimitiveSortData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PrimitiveSortData instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.ConstructorData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ConstructorData instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.RecordData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.RecordData instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.DatatypeData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.DatatypeData instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.DataOrRecSigData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.DataOrRecSigData instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.AxiomData instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.CompKit instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.CompKit instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.FunctionFlag instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.FunctionFlag instance Agda.Syntax.Common.PatternMatchingAllowed Agda.TypeChecking.Monad.Base.EtaEquality instance Agda.Syntax.Common.CopatternMatchingAllowed Agda.TypeChecking.Monad.Base.EtaEquality instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.EtaEquality instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.EtaEquality instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Projection instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Projection instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Projection instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.ProjLams instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.ProjLams instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ProjLams instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.ExtLamInfo instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ExtLamInfo instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.System instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.System instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.CompiledRepresentation instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.CompilerPragma instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.CompilerPragma instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.IsForced instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.IsForced instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Polarity instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Polarity instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Polarity instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.NumGeneralizableArgs instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.NumGeneralizableArgs instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.RewriteRuleMap instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.RewriteRule instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Monad.Base.NLPat instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.TypeChecking.Monad.Base.NLPat instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Monad.Base.NLPType instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.TypeChecking.Monad.Base.NLPType instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Monad.Base.NLPSort instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.TypeChecking.Monad.Base.NLPSort instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.NLPat instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.NLPType instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.NLPSort instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.NLPat instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.NLPType instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.DisplayForm instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.DisplayTerm instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Sections instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Section instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Section instance Control.DeepSeq.NFData t => Control.DeepSeq.NFData (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Overapplied instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.NamedMeta instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.RunMetaOccursCheck instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.PrincipalArgTypeMetas instance Agda.Syntax.Common.LensModality Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance Agda.Syntax.Common.LensRelevance Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance Agda.Syntax.Common.LensQuantity Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Instantiation instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Frozen instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.GeneralizedValue instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.DoGeneralize instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.DoGeneralize instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Monad.Base.Judgement a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.TypeChecking.Monad.Base.Judgement a) instance Agda.Utils.Functor.Decoration Agda.TypeChecking.Monad.Base.Open instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Monad.Base.Open a) instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.TypeChecking.Monad.Base.Open a) instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.TypeChecking.Monad.Base.Open a) instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.CompareAs instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Monad.Base.CompareAs instance Agda.Syntax.Internal.MetaVars.AllMetas Agda.TypeChecking.Monad.Base.CompareAs instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CompareAs instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.CompareAs instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CompareDirection instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Comparison instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.Comparison instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.WhyCheckModality instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ForeignCode instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.ModuleCheckMode instance Agda.TypeChecking.Monad.Base.MonadStConcreteNames m => Agda.TypeChecking.Monad.Base.MonadStConcreteNames (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Base.MonadStConcreteNames m => Agda.TypeChecking.Monad.Base.MonadStConcreteNames (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Base.MonadStConcreteNames m => Agda.TypeChecking.Monad.Base.MonadStConcreteNames (Control.Monad.Trans.State.Lazy.StateT s m) instance Agda.TypeChecking.Monad.Base.FreshName (Agda.Syntax.Position.Range, GHC.Base.String) instance Agda.TypeChecking.Monad.Base.FreshName GHC.Base.String instance Agda.TypeChecking.Monad.Base.FreshName Agda.Syntax.Position.Range instance Agda.TypeChecking.Monad.Base.FreshName () instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CheckpointId instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CheckpointId instance Agda.TypeChecking.Monad.Base.MonadFresh i m => Agda.TypeChecking.Monad.Base.MonadFresh i (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Base.MonadFresh i m => Agda.TypeChecking.Monad.Base.MonadFresh i (Control.Monad.Trans.State.Lazy.StateT s m) instance Agda.TypeChecking.Monad.Base.MonadFresh i m => Agda.TypeChecking.Monad.Base.MonadFresh i (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Base.MonadFresh i m => Agda.TypeChecking.Monad.Base.MonadFresh i (Control.Monad.Trans.Identity.IdentityT m) instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.TypeCheckAction instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.MutualBlock instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.MutualBlock instance Control.DeepSeq.NFData Agda.TypeChecking.Monad.Base.DisambiguatedName instance Control.DeepSeq.NFData (Agda.Utils.BiMap.BiMap Agda.Syntax.TopLevelModuleName.RawTopLevelModuleName Agda.Syntax.Common.ModuleNameHash) -- | Data type for all interactive responses module Agda.Interaction.Response -- | Responses for any interactive interface -- -- Note that the response is given in pieces and incrementally, so the -- user can have timely response even during long computations. data Response Resp_HighlightingInfo :: HighlightingInfo -> RemoveTokenBasedHighlighting -> HighlightingMethod -> ModuleToSource -> Response Resp_Status :: Status -> Response Resp_JumpToError :: FilePath -> Int32 -> Response Resp_InteractionPoints :: [InteractionId] -> Response Resp_GiveAction :: InteractionId -> GiveResult -> Response -- | Response is list of printed clauses. Resp_MakeCase :: InteractionId -> MakeCaseVariant -> [String] -> Response -- | Solution for one or more meta-variables. Resp_SolveAll :: [(InteractionId, Expr)] -> Response Resp_DisplayInfo :: DisplayInfo -> Response -- | The integer is the message's debug level. Resp_RunningInfo :: Int -> String -> Response Resp_ClearRunningInfo :: Response -- | Clear highlighting of the given kind. Resp_ClearHighlighting :: TokenBased -> Response -- | A command sent when an abort command has completed successfully. Resp_DoneAborting :: Response -- | A command sent when an exit command is about to be completed. Resp_DoneExiting :: Response -- | Should token-based highlighting be removed in conjunction with the -- application of new highlighting (in order to reduce the risk of -- flicker)? data RemoveTokenBasedHighlighting -- | Yes, remove all token-based highlighting from the file. RemoveHighlighting :: RemoveTokenBasedHighlighting -- | No. KeepHighlighting :: RemoveTokenBasedHighlighting -- | There are two kinds of "make case" commands. data MakeCaseVariant Function :: MakeCaseVariant ExtendedLambda :: MakeCaseVariant -- | Info to display at the end of an interactive command data DisplayInfo Info_CompilationOk :: CompilerBackend -> WarningsAndNonFatalErrors -> DisplayInfo Info_Constraints :: [OutputForm Expr Expr] -> DisplayInfo Info_AllGoalsWarnings :: Goals -> WarningsAndNonFatalErrors -> DisplayInfo Info_Time :: CPUTime -> DisplayInfo -- | When an error message is displayed this constructor should be used, if -- appropriate. Info_Error :: Info_Error -> DisplayInfo Info_Intro_NotFound :: DisplayInfo Info_Intro_ConstructorUnknown :: [String] -> DisplayInfo -- | Info_Auto denotes either an error or a success (when -- Resp_GiveAction is present) TODO: split these into separate -- constructors Info_Auto :: String -> DisplayInfo Info_ModuleContents :: [Name] -> Telescope -> [(Name, Type)] -> DisplayInfo Info_SearchAbout :: [(Name, Type)] -> String -> DisplayInfo Info_WhyInScope :: WhyInScopeData -> DisplayInfo Info_NormalForm :: CommandState -> ComputeMode -> Maybe CPUTime -> Expr -> DisplayInfo Info_InferredType :: CommandState -> Maybe CPUTime -> Expr -> DisplayInfo Info_Context :: InteractionId -> [ResponseContextEntry] -> DisplayInfo Info_Version :: DisplayInfo Info_GoalSpecific :: InteractionId -> GoalDisplayInfo -> DisplayInfo data GoalDisplayInfo Goal_HelperFunction :: OutputConstraint' Expr Expr -> GoalDisplayInfo Goal_NormalForm :: ComputeMode -> Expr -> GoalDisplayInfo Goal_GoalType :: Rewrite -> GoalTypeAux -> [ResponseContextEntry] -> [IPBoundary' Expr] -> [OutputForm Expr Expr] -> GoalDisplayInfo Goal_CurrentGoal :: Rewrite -> GoalDisplayInfo Goal_InferredType :: Expr -> GoalDisplayInfo -- | Goals & Warnings type Goals = ([OutputConstraint Expr InteractionId], [OutputConstraint Expr NamedMeta]) -- | Assorted warnings and errors to be displayed to the user data WarningsAndNonFatalErrors -- | Errors that goes into Info_Error -- -- When an error message is displayed this constructor should be used, if -- appropriate. data Info_Error Info_GenericError :: TCErr -> Info_Error Info_CompilationError :: [TCWarning] -> Info_Error Info_HighlightingParseError :: InteractionId -> Info_Error Info_HighlightingScopeCheckError :: InteractionId -> Info_Error -- | Auxiliary information that comes with Goal Type data GoalTypeAux GoalOnly :: GoalTypeAux GoalAndHave :: Expr -> GoalTypeAux GoalAndElaboration :: Term -> GoalTypeAux -- | Entry in context. data ResponseContextEntry ResponseContextEntry :: Name -> Name -> Arg Expr -> Maybe Expr -> NameInScope -> ResponseContextEntry -- | The original concrete name. [respOrigName] :: ResponseContextEntry -> Name -- | The name reified from abstract syntax. [respReifName] :: ResponseContextEntry -> Name -- | The type. [respType] :: ResponseContextEntry -> Arg Expr -- | The value (if it is a let-bound variable) [respLetValue] :: ResponseContextEntry -> Maybe Expr -- | Whether the respReifName is in scope. [respInScope] :: ResponseContextEntry -> NameInScope -- | Status information. data Status Status :: Bool -> Bool -> Bool -> Status -- | Are implicit arguments displayed? [sShowImplicitArguments] :: Status -> Bool -- | Are irrelevant arguments displayed? [sShowIrrelevantArguments] :: Status -> Bool -- | Has the module been successfully type checked? [sChecked] :: Status -> Bool -- | Give action result -- -- Comment derived from agda2-mode.el -- -- If GiveResult is 'Give_String s', then the goal is replaced by -- s, and otherwise the text inside the goal is retained -- (parenthesised if GiveResult is Give_Paren). data GiveResult Give_String :: String -> GiveResult Give_Paren :: GiveResult Give_NoParen :: GiveResult -- | Callback fuction to call when there is a response to give to the -- interactive frontend. -- -- Note that the response is given in pieces and incrementally, so the -- user can have timely response even during long computations. -- -- Typical InteractionOutputCallback functions: -- -- type InteractionOutputCallback = Response -> TCM () -- | The default InteractionOutputCallback function prints certain -- things to stdout (other things generate internal errors). defaultInteractionOutputCallback :: InteractionOutputCallback module Agda.Interaction.Base -- | Auxiliary state of an interactive computation. data CommandState CommandState :: [InteractionId] -> Maybe CurrentFile -> CommandLineOptions -> !OldInteractionScopes -> !CommandQueue -> CommandState -- | The interaction points of the buffer, in the order in which they -- appear in the buffer. The interaction points are recorded in -- theTCState, but when new interaction points are added by give -- or refine Agda does not ensure that the ranges of later interaction -- points are updated. [theInteractionPoints] :: CommandState -> [InteractionId] -- | The file which the state applies to. Only stored if the module was -- successfully type checked (potentially with warnings). [theCurrentFile] :: CommandState -> Maybe CurrentFile -- | Reset the options on each reload to these. [optionsOnReload] :: CommandState -> CommandLineOptions -- | We remember (the scope of) old interaction points to make it possible -- to parse and compute highlighting information for the expression that -- it got replaced by. [oldInteractionScopes] :: CommandState -> !OldInteractionScopes -- | The command queue. -- -- This queue should only be manipulated by -- initialiseCommandQueue and maybeAbort. [commandQueue] :: CommandState -> !CommandQueue type OldInteractionScopes = Map InteractionId ScopeInfo -- | Initial auxiliary interaction state initCommandState :: CommandQueue -> CommandState -- | Monad for computing answers to interactive commands. -- -- CommandM is TCM extended with state CommandState. type CommandM = StateT CommandState TCM -- | Information about the current main module. data CurrentFile CurrentFile :: AbsolutePath -> TopLevelModuleName -> [String] -> ClockTime -> CurrentFile -- | The file currently loaded into interaction. [currentFilePath] :: CurrentFile -> AbsolutePath -- | The top-level module name of the currently loaded file. [currentFileModule] :: CurrentFile -> TopLevelModuleName -- | The arguments to Agda used for loading the file. [currentFileArgs] :: CurrentFile -> [String] -- | The modification time stamp of the file when it was loaded. [currentFileStamp] :: CurrentFile -> ClockTime -- | A generalised command type. data Command' a -- | A command. Command :: !a -> Command' a -- | Stop processing commands. Done :: Command' a -- | An error message for a command that could not be parsed. Error :: String -> Command' a -- | IOTCM commands. type Command = Command' IOTCM -- | IOTCM commands. -- -- The commands are obtained by applying the functions to the current -- top-level module name, if any. Note that the top-level module name is -- not used by independent commands. For other commands the top-level -- module name should be known. type IOTCM = Maybe TopLevelModuleName -> IOTCM' Range -- | Command queues. data CommandQueue CommandQueue :: !TChan (Integer, Command) -> !TVar (Maybe Integer) -> CommandQueue -- | Commands that should be processed, in the order in which they should -- be processed. Each command is associated with a number, and the -- numbers are strictly increasing. Abort commands are not put on this -- queue. [commands] :: CommandQueue -> !TChan (Integer, Command) -- | When this variable is set to Just n an attempt is made to -- abort all commands with a command number that is at most n. [abort] :: CommandQueue -> !TVar (Maybe Integer) -- | An interactive computation. type Interaction = Interaction' Range data Interaction' range -- | cmd_load m argv loads the module in file m, using -- argv as the command-line options. Cmd_load :: FilePath -> [String] -> Interaction' range -- | cmd_compile b m argv compiles the module in file m -- using the backend b, using argv as the command-line -- options. Cmd_compile :: CompilerBackend -> FilePath -> [String] -> Interaction' range Cmd_constraints :: Interaction' range -- | Show unsolved metas. If there are no unsolved metas but unsolved -- constraints show those instead. Cmd_metas :: Rewrite -> Interaction' range -- | A command that fails if there are any unsolved meta-variables. By -- default no output is generated if the command is successful. Cmd_no_metas :: Interaction' range -- | Shows all the top-level names in the given module, along with their -- types. Uses the top-level scope. Cmd_show_module_contents_toplevel :: Rewrite -> String -> Interaction' range -- | Shows all the top-level names in scope which mention all the given -- identifiers in their type. Cmd_search_about_toplevel :: Rewrite -> String -> Interaction' range -- | Solve (all goals / the goal at point) whose values are determined by -- the constraints. Cmd_solveAll :: Rewrite -> Interaction' range Cmd_solveOne :: Rewrite -> InteractionId -> range -> String -> Interaction' range -- | Solve (all goals / the goal at point) by using Auto. Cmd_autoOne :: InteractionId -> range -> String -> Interaction' range Cmd_autoAll :: Interaction' range -- | Parse the given expression (as if it were defined at the top-level of -- the current module) and infer its type. Cmd_infer_toplevel :: Rewrite -> String -> Interaction' range -- | Parse and type check the given expression (as if it were defined at -- the top-level of the current module) and normalise it. Cmd_compute_toplevel :: ComputeMode -> String -> Interaction' range -- | cmd_load_highlighting_info source loads syntax highlighting -- information for the module in source, and asks Emacs to apply -- highlighting info from this file. -- -- If the module does not exist, or its module name is malformed or -- cannot be determined, or the module has not already been visited, or -- the cached info is out of date, then no highlighting information is -- printed. -- -- This command is used to load syntax highlighting information when a -- new file is opened, and it would probably be annoying if jumping to -- the definition of an identifier reset the proof state, so this command -- tries not to do that. One result of this is that the command uses the -- current include directories, whatever they happen to be. Cmd_load_highlighting_info :: FilePath -> Interaction' range -- | Tells Agda to compute token-based highlighting information for the -- file. -- -- This command works even if the file's module name does not match its -- location in the file system, or if the file is not scope-correct. -- Furthermore no file names are put in the generated output. Thus it is -- fine to put source code into a temporary file before calling this -- command. However, the file extension should be correct. -- -- If the second argument is Remove, then the (presumably -- temporary) file is removed after it has been read. Cmd_tokenHighlighting :: FilePath -> Remove -> Interaction' range -- | Tells Agda to compute highlighting information for the expression just -- spliced into an interaction point. Cmd_highlight :: InteractionId -> range -> String -> Interaction' range -- | Tells Agda whether or not to show implicit arguments. ShowImplicitArgs :: Bool -> Interaction' range -- | Toggle display of implicit arguments. ToggleImplicitArgs :: Interaction' range -- | Tells Agda whether or not to show irrelevant arguments. ShowIrrelevantArgs :: Bool -> Interaction' range -- | Toggle display of irrelevant arguments. ToggleIrrelevantArgs :: Interaction' range -- | Goal commands -- -- If the range is noRange, then the string comes from the -- minibuffer rather than the goal. Cmd_give :: UseForce -> InteractionId -> range -> String -> Interaction' range Cmd_refine :: InteractionId -> range -> String -> Interaction' range Cmd_intro :: Bool -> InteractionId -> range -> String -> Interaction' range Cmd_refine_or_intro :: Bool -> InteractionId -> range -> String -> Interaction' range Cmd_context :: Rewrite -> InteractionId -> range -> String -> Interaction' range Cmd_helper_function :: Rewrite -> InteractionId -> range -> String -> Interaction' range Cmd_infer :: Rewrite -> InteractionId -> range -> String -> Interaction' range Cmd_goal_type :: Rewrite -> InteractionId -> range -> String -> Interaction' range -- | Grabs the current goal's type and checks the expression in the hole -- against it. Returns the elaborated term. Cmd_elaborate_give :: Rewrite -> InteractionId -> range -> String -> Interaction' range -- | Displays the current goal and context. Cmd_goal_type_context :: Rewrite -> InteractionId -> range -> String -> Interaction' range -- | Displays the current goal and context and infers the type of an -- expression. Cmd_goal_type_context_infer :: Rewrite -> InteractionId -> range -> String -> Interaction' range -- | Grabs the current goal's type and checks the expression in the hole -- against it. Cmd_goal_type_context_check :: Rewrite -> InteractionId -> range -> String -> Interaction' range -- | Shows all the top-level names in the given module, along with their -- types. Uses the scope of the given goal. Cmd_show_module_contents :: Rewrite -> InteractionId -> range -> String -> Interaction' range Cmd_make_case :: InteractionId -> range -> String -> Interaction' range Cmd_compute :: ComputeMode -> InteractionId -> range -> String -> Interaction' range Cmd_why_in_scope :: InteractionId -> range -> String -> Interaction' range Cmd_why_in_scope_toplevel :: String -> Interaction' range -- | Displays version of the running Agda Cmd_show_version :: Interaction' range -- | Abort the current computation. -- -- Does nothing if no computation is in progress. Cmd_abort :: Interaction' range -- | Exit the program. Cmd_exit :: Interaction' range data IOTCM' range IOTCM :: FilePath -> HighlightingLevel -> HighlightingMethod -> Interaction' range -> IOTCM' range -- | Used to indicate whether something should be removed or not. data Remove Remove :: Remove Keep :: Remove -- | An IOTCM parser. -- -- If the parse fails, then an error message is returned. parseIOTCM :: String -> Either String IOTCM -- | The Parse monad. StateT state holds the remaining input. type Parse a = ExceptT String (StateT String Identity) a -- | Converter from the type of reads to Parse The first -- paramter is part of the error message in case the parse fails. readsToParse :: String -> (String -> Maybe (a, String)) -> Parse a parseToReadsPrec :: Parse a -> Int -> String -> [(a, String)] -- | Demand an exact string. exact :: String -> Parse () readParse :: Read a => Parse a parens' :: Parse a -> Parse a -- | Available backends. data CompilerBackend LaTeX :: CompilerBackend QuickLaTeX :: CompilerBackend OtherBackend :: String -> CompilerBackend -- | Ordered ascendingly by degree of normalization. data Rewrite AsIs :: Rewrite Instantiated :: Rewrite HeadNormal :: Rewrite Simplified :: Rewrite Normalised :: Rewrite data ComputeMode DefaultCompute :: ComputeMode HeadCompute :: ComputeMode IgnoreAbstract :: ComputeMode UseShowInstance :: ComputeMode data UseForce -- | Ignore additional checks, like termination/positivity... WithForce :: UseForce -- | Don't ignore any checks. WithoutForce :: UseForce data OutputForm a b OutputForm :: Range -> [ProblemId] -> Blocker -> OutputConstraint a b -> OutputForm a b data OutputConstraint a b OfType :: b -> a -> OutputConstraint a b CmpInType :: Comparison -> a -> b -> b -> OutputConstraint a b CmpElim :: [Polarity] -> a -> [b] -> [b] -> OutputConstraint a b JustType :: b -> OutputConstraint a b CmpTypes :: Comparison -> b -> b -> OutputConstraint a b CmpLevels :: Comparison -> b -> b -> OutputConstraint a b CmpTeles :: Comparison -> b -> b -> OutputConstraint a b JustSort :: b -> OutputConstraint a b CmpSorts :: Comparison -> b -> b -> OutputConstraint a b Assign :: b -> a -> OutputConstraint a b TypedAssign :: b -> a -> a -> OutputConstraint a b PostponedCheckArgs :: b -> [a] -> a -> a -> OutputConstraint a b IsEmptyType :: a -> OutputConstraint a b SizeLtSat :: a -> OutputConstraint a b FindInstanceOF :: b -> a -> [(a, a, a)] -> OutputConstraint a b PTSInstance :: b -> b -> OutputConstraint a b PostponedCheckFunDef :: QName -> a -> TCErr -> OutputConstraint a b CheckLock :: b -> b -> OutputConstraint a b DataSort :: QName -> b -> OutputConstraint a b UsableAtMod :: Modality -> b -> OutputConstraint a b -- | A subset of OutputConstraint. data OutputConstraint' a b OfType' :: b -> a -> OutputConstraint' a b [ofName] :: OutputConstraint' a b -> b [ofExpr] :: OutputConstraint' a b -> a data OutputContextEntry name ty val ContextVar :: name -> ty -> OutputContextEntry name ty val ContextLet :: name -> ty -> val -> OutputContextEntry name ty val instance GHC.Show.Show Agda.Interaction.Base.CurrentFile instance GHC.Show.Show a => GHC.Show.Show (Agda.Interaction.Base.Command' a) instance GHC.Read.Read Agda.Interaction.Base.Remove instance GHC.Show.Show Agda.Interaction.Base.Remove instance GHC.Classes.Eq Agda.Interaction.Base.CompilerBackend instance GHC.Classes.Ord Agda.Interaction.Base.Rewrite instance GHC.Classes.Eq Agda.Interaction.Base.Rewrite instance GHC.Read.Read Agda.Interaction.Base.Rewrite instance GHC.Show.Show Agda.Interaction.Base.Rewrite instance GHC.Classes.Eq Agda.Interaction.Base.ComputeMode instance GHC.Read.Read Agda.Interaction.Base.ComputeMode instance GHC.Show.Show Agda.Interaction.Base.ComputeMode instance GHC.Show.Show Agda.Interaction.Base.UseForce instance GHC.Read.Read Agda.Interaction.Base.UseForce instance GHC.Classes.Eq Agda.Interaction.Base.UseForce instance Data.Traversable.Traversable Agda.Interaction.Base.Interaction' instance Data.Foldable.Foldable Agda.Interaction.Base.Interaction' instance GHC.Base.Functor Agda.Interaction.Base.Interaction' instance GHC.Read.Read range => GHC.Read.Read (Agda.Interaction.Base.Interaction' range) instance GHC.Show.Show range => GHC.Show.Show (Agda.Interaction.Base.Interaction' range) instance Data.Traversable.Traversable Agda.Interaction.Base.IOTCM' instance Data.Foldable.Foldable Agda.Interaction.Base.IOTCM' instance GHC.Base.Functor Agda.Interaction.Base.IOTCM' instance GHC.Read.Read range => GHC.Read.Read (Agda.Interaction.Base.IOTCM' range) instance GHC.Show.Show range => GHC.Show.Show (Agda.Interaction.Base.IOTCM' range) instance GHC.Base.Functor (Agda.Interaction.Base.OutputConstraint a) instance GHC.Base.Functor (Agda.Interaction.Base.OutputForm a) instance GHC.Show.Show Agda.Interaction.Base.CompilerBackend instance Agda.Utils.Pretty.Pretty Agda.Interaction.Base.CompilerBackend instance GHC.Read.Read Agda.Interaction.Base.CompilerBackend instance GHC.Read.Read Agda.Syntax.Common.InteractionId instance GHC.Read.Read a => GHC.Read.Read (Agda.Syntax.Position.Range' a) instance GHC.Read.Read a => GHC.Read.Read (Agda.Syntax.Position.Interval' a) instance GHC.Read.Read Agda.Utils.FileName.AbsolutePath instance GHC.Read.Read Agda.Syntax.Position.RangeFile instance GHC.Read.Read a => GHC.Read.Read (Agda.Syntax.Position.Position' a) -- | Interface for compiler backend writers. module Agda.Compiler.Backend data Backend [Backend] :: NFData opts => Backend' opts env menv mod def -> Backend data Backend' opts env menv mod def Backend' :: String -> Maybe String -> opts -> [OptDescr (Flag opts)] -> (opts -> Bool) -> (opts -> TCM env) -> (env -> IsMain -> Map TopLevelModuleName mod -> TCM ()) -> (env -> IsMain -> TopLevelModuleName -> Maybe FilePath -> TCM (Recompile menv mod)) -> (env -> menv -> IsMain -> TopLevelModuleName -> [def] -> TCM mod) -> (env -> menv -> IsMain -> Definition -> TCM def) -> Bool -> (QName -> TCM Bool) -> Backend' opts env menv mod def [backendName] :: Backend' opts env menv mod def -> String -- | Optional version information to be printed with --version. [backendVersion] :: Backend' opts env menv mod def -> Maybe String -- | Default options [options] :: Backend' opts env menv mod def -> opts -- | Backend-specific command-line flags. Should at minimum contain a flag -- to enable the backend. [commandLineFlags] :: Backend' opts env menv mod def -> [OptDescr (Flag opts)] -- | Unless the backend has been enabled, runAgda will fall back -- to vanilla Agda behaviour. [isEnabled] :: Backend' opts env menv mod def -> opts -> Bool -- | Called after type checking completes, but before compilation starts. [preCompile] :: Backend' opts env menv mod def -> opts -> TCM env -- | Called after module compilation has completed. The IsMain -- argument is NotMain if the --no-main flag is -- present. [postCompile] :: Backend' opts env menv mod def -> env -> IsMain -> Map TopLevelModuleName mod -> TCM () -- | Called before compilation of each module. Gets the path to the -- .agdai file to allow up-to-date checking of previously -- written compilation results. Should return Skip m if -- compilation is not required. Will be Nothing if only scope -- checking. [preModule] :: Backend' opts env menv mod def -> env -> IsMain -> TopLevelModuleName -> Maybe FilePath -> TCM (Recompile menv mod) -- | Called after all definitions of a module have been compiled. [postModule] :: Backend' opts env menv mod def -> env -> menv -> IsMain -> TopLevelModuleName -> [def] -> TCM mod -- | Compile a single definition. [compileDef] :: Backend' opts env menv mod def -> env -> menv -> IsMain -> Definition -> TCM def -- | True if the backend works if --only-scope-checking is used. [scopeCheckingSuffices] :: Backend' opts env menv mod def -> 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. [mayEraseType] :: Backend' opts env menv mod def -> QName -> TCM Bool data Recompile menv mod Recompile :: menv -> Recompile menv mod Skip :: mod -> Recompile menv mod data IsMain IsMain :: IsMain NotMain :: IsMain -- | 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 type Flag opts = opts -> OptM opts -- | 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. toTreeless :: EvaluationStrategy -> QName -> TCM (Maybe TTerm) class (Functor m, Applicative m, Monad m) => MonadDebug m formatDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m String traceDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a -- | Print brackets around debug messages issued by a computation. verboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a getVerbosity :: MonadDebug m => m Verbosity getProfileOptions :: MonadDebug m => m ProfileOptions -- | Check whether we are currently debug printing. isDebugPrinting :: MonadDebug m => m Bool -- | Flag in a computation that we are currently debug printing. nowDebugPrinting :: MonadDebug m => m a -> m a formatDebugMessage :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> TCM Doc -> m String traceDebugMessage :: (MonadDebug m, MonadTransControl t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> String -> m a -> m a -- | Print brackets around debug messages issued by a computation. verboseBracket :: (MonadDebug m, MonadTransControl t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> String -> m a -> m a getVerbosity :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => m Verbosity getProfileOptions :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => m ProfileOptions -- | Check whether we are currently debug printing. isDebugPrinting :: (MonadDebug m, MonadTrans t, MonadDebug n, m ~ t n) => m Bool -- | Flag in a computation that we are currently debug printing. nowDebugPrinting :: (MonadDebug m, MonadTransControl t, MonadDebug n, m ~ t n) => m a -> m a builtinNat :: String builtinSuc :: String builtinZero :: String builtinNatPlus :: String builtinNatMinus :: String builtinNatTimes :: String builtinNatDivSucAux :: String builtinNatModSucAux :: String builtinNatEquals :: String builtinNatLess :: String builtinWord64 :: String builtinInteger :: String builtinIntegerPos :: String builtinIntegerNegSuc :: String builtinFloat :: String builtinChar :: String builtinString :: String builtinUnit :: String builtinUnitUnit :: String builtinSigma :: String builtinBool :: String builtinTrue :: String builtinFalse :: String builtinList :: String builtinNil :: String builtinCons :: String builtinMaybe :: String builtinNothing :: String builtinJust :: String builtinIO :: String builtinId :: String builtinReflId :: String builtinConId :: String builtinIdElim :: String builtinPath :: String builtinPathP :: String builtinIntervalUniv :: String builtinInterval :: String builtinIMin :: String builtinIMax :: String builtinINeg :: String builtinIZero :: String builtinIOne :: String builtinPartial :: String builtinPartialP :: String builtinIsOne :: String builtinItIsOne :: String builtinEquiv :: String builtinEquivFun :: String builtinEquivProof :: String builtinTranspProof :: String builtinGlue :: String builtin_glue :: String builtin_unglue :: String builtin_glueU :: String builtin_unglueU :: String builtinFaceForall :: String builtinIsOne1 :: String builtinIsOne2 :: String builtinIsOneEmpty :: String builtinComp :: String builtinPOr :: String builtinTrans :: String builtinHComp :: String builtinSub :: String builtinSubIn :: String builtinSubOut :: String builtinSizeUniv :: String builtinSize :: String builtinSizeLt :: String builtinSizeSuc :: String builtinSizeInf :: String builtinSizeMax :: String builtinInf :: String builtinSharp :: String builtinFlat :: String builtinEquality :: String builtinRefl :: String builtinRewrite :: String builtinLevelMax :: String builtinLevel :: String builtinLevelZero :: String builtinLevelSuc :: String builtinSet :: String builtinProp :: String builtinSetOmega :: String builtinLockUniv :: String builtinSSetOmega :: String builtinStrictSet :: String builtinFromNat :: String builtinFromNeg :: String builtinFromString :: String builtinQName :: String builtinAgdaSort :: String builtinAgdaSortSet :: String builtinAgdaSortLit :: String builtinAgdaSortProp :: String builtinAgdaSortPropLit :: String builtinAgdaSortInf :: String builtinAgdaSortUnsupported :: String builtinHiding :: String builtinHidden :: String builtinInstance :: String builtinVisible :: String builtinRelevance :: String builtinRelevant :: String builtinIrrelevant :: String builtinQuantity :: String builtinQuantity0 :: String builtinQuantityω :: String builtinModality :: String builtinModalityConstructor :: String builtinAssoc :: String builtinAssocLeft :: String builtinAssocRight :: String builtinAssocNon :: String builtinPrecedence :: String builtinPrecRelated :: String builtinPrecUnrelated :: String builtinFixity :: String builtinFixityFixity :: String builtinArg :: String builtinArgInfo :: String builtinArgArgInfo :: String builtinArgArg :: String builtinAbs :: String builtinAbsAbs :: String builtinAgdaTerm :: String builtinAgdaTermVar :: String builtinAgdaTermLam :: String builtinAgdaTermExtLam :: String builtinAgdaTermDef :: String builtinAgdaTermCon :: String builtinAgdaTermPi :: String builtinAgdaTermSort :: String builtinAgdaTermLit :: String builtinAgdaTermUnsupported :: String builtinAgdaTermMeta :: String builtinAgdaErrorPart :: String builtinAgdaErrorPartString :: String builtinAgdaErrorPartTerm :: String builtinAgdaErrorPartPatt :: 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 builtinAgdaTCMDeclareData :: String builtinAgdaTCMDefineData :: String builtinAgdaTCMDefineFun :: String builtinAgdaTCMGetType :: String builtinAgdaTCMGetDefinition :: String builtinAgdaTCMBlockOnMeta :: String builtinAgdaTCMCommit :: String builtinAgdaTCMQuoteTerm :: String builtinAgdaTCMUnquoteTerm :: String builtinAgdaTCMQuoteOmegaTerm :: String builtinAgdaTCMIsMacro :: String builtinAgdaTCMWithNormalisation :: String builtinAgdaTCMWithReconsParams :: String builtinAgdaTCMFormatErrorParts :: String builtinAgdaTCMDebugPrint :: String builtinAgdaTCMOnlyReduceDefs :: String builtinAgdaTCMDontReduceDefs :: String builtinAgdaTCMNoConstraints :: String builtinAgdaTCMRunSpeculative :: String builtinAgdaTCMExec :: String builtinAgdaTCMGetInstances :: 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. -- -- {-# BUILTIN TYPE Type #-} -- -- The type of Type would be Type : Level → Setω which -- is not valid Agda. isBuiltinNoDef :: String -> Bool builtinsNoDef :: [String] sizeBuiltins :: [String] -- | Datatype representing a single boundary condition: x_0 = u_0, ... ,x_n -- = u_n ⊢ t = ?n es data IPBoundary' t IPBoundary :: [(t, t)] -> t -> t -> Overapplied -> IPBoundary' t -- | [ipbEquations] :: IPBoundary' t -> [(t, t)] -- |
--   t
--   
[ipbValue] :: IPBoundary' t -> t -- |
--   ?n es
--   
[ipbMetaApp] :: IPBoundary' t -> t -- | Is ?n overapplied in ?n es ? [ipbOverapplied] :: IPBoundary' t -> Overapplied -- | Polarity for equality and subtype checking. data Polarity -- | monotone Covariant :: Polarity -- | antitone Contravariant :: Polarity -- | no information (mixed variance) Invariant :: Polarity -- | constant Nonvariant :: Polarity data Comparison CmpEq :: Comparison CmpLeq :: Comparison type BackendName = String -- | Maps top-level module names to the corresponding source file names. type ModuleToSource = Map TopLevelModuleName AbsolutePath -- | Type checking monad. type TCM = TCMT IO -- | The type checking monad transformer. Adds readonly TCEnv and -- mutable TCState. newtype TCMT m a TCM :: (IORef TCState -> TCEnv -> m a) -> TCMT m a [unTCM] :: TCMT m a -> IORef TCState -> TCEnv -> m a data TCState TCSt :: !PreScopeState -> !PostScopeState -> !PersistentTCState -> TCState -- | The state which is frozen after scope checking. [stPreScopeState] :: TCState -> !PreScopeState -- | The state which is modified after scope checking. [stPostScopeState] :: TCState -> !PostScopeState -- | State which is forever, like a diamond. [stPersistentState] :: TCState -> !PersistentTCState data TCEnv TCEnv :: Context -> LetBindings -> ModuleName -> Maybe AbsolutePath -> [(ModuleName, Nat)] -> [TopLevelModuleName] -> Maybe MutualId -> TerminationCheck () -> CoverageCheck -> Bool -> Bool -> Bool -> Bool -> Bool -> Set ProblemId -> AbstractMode -> Modality -> Bool -> Bool -> Range -> Range -> IPClause -> Maybe (Closure Call) -> HighlightingLevel -> HighlightingMethod -> ExpandHidden -> Maybe QName -> Simplification -> AllowedReductions -> ReduceDefs -> Bool -> Int -> Bool -> Bool -> Bool -> Bool -> UnquoteFlags -> !Int -> Bool -> [QName] -> Bool -> CheckpointId -> Map CheckpointId Substitution -> DoGeneralize -> Map QName GeneralizedValue -> Maybe BackendName -> Bool -> Bool -> !Maybe Int -> TCEnv [envContext] :: TCEnv -> Context [envLetBindings] :: TCEnv -> LetBindings [envCurrentModule] :: TCEnv -> ModuleName -- | 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). [envCurrentPath] :: TCEnv -> Maybe AbsolutePath -- | anonymous modules and their number of free variables [envAnonymousModules] :: TCEnv -> [(ModuleName, Nat)] -- | The module stack with the entry being the top-level module as Agda -- chases modules. It will be empty if there is no main module, will have -- a single entry for the top level module, or more when descending past -- the main module. This is used to detect import cycles and in some -- cases highlighting behavior. The level of a given module is not -- necessarily the same as the length, in the module dependency graph, of -- the shortest path from the top-level module; it depends on in which -- order Agda chooses to chase dependencies. [envImportPath] :: TCEnv -> [TopLevelModuleName] -- | the current (if any) mutual block [envMutualBlock] :: TCEnv -> Maybe MutualId -- | are we inside the scope of a termination pragma [envTerminationCheck] :: TCEnv -> TerminationCheck () -- | are we inside the scope of a coverage pragma [envCoverageCheck] :: TCEnv -> CoverageCheck -- | are we inside a make-case (if so, ignore forcing analysis in unifier) [envMakeCase] :: TCEnv -> Bool -- | Are we currently in the process of solving active constraints? [envSolvingConstraints] :: TCEnv -> Bool -- | Have we stepped into the where-declarations of a clause? Everything -- under a where will be checked with this flag on. [envCheckingWhere] :: TCEnv -> Bool -- | Are we working on types? Turned on by workOnTypes. [envWorkingOnTypes] :: TCEnv -> Bool -- | Are we allowed to assign metas? [envAssignMetas] :: TCEnv -> Bool [envActiveProblems] :: TCEnv -> Set ProblemId -- | 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. [envAbstractMode] :: TCEnv -> AbstractMode -- | 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. [envModality] :: TCEnv -> Modality -- | Are we currently case-splitting on a strict datatype (i.e. in SSet)? -- If yes, the pattern-matching unifier will solve reflexive equations -- even --without-K. [envSplitOnStrict] :: TCEnv -> Bool -- | Sometimes we want to disable display forms. [envDisplayFormsEnabled] :: TCEnv -> Bool [envRange] :: TCEnv -> Range -- | Interactive highlighting uses this range rather than envRange. [envHighlightingRange] :: TCEnv -> Range -- | What is the current clause we are type-checking? Will be recorded in -- interaction points in this clause. [envClause] :: TCEnv -> IPClause -- | what we're doing at the moment [envCall] :: TCEnv -> Maybe (Closure Call) -- | Set to None when imported modules are type-checked. [envHighlightingLevel] :: TCEnv -> HighlightingLevel [envHighlightingMethod] :: TCEnv -> HighlightingMethod -- | When type-checking an alias f=e, we do not want to insert hidden -- arguments in the end, because these will become unsolved metas. [envExpandLast] :: TCEnv -> ExpandHidden -- | We are reducing an application of this function. (For tracking of -- incomplete matches.) [envAppDef] :: TCEnv -> Maybe QName -- | Did we encounter a simplification (proper match) during the current -- reduction process? [envSimplification] :: TCEnv -> Simplification [envAllowedReductions] :: TCEnv -> AllowedReductions [envReduceDefs] :: TCEnv -> ReduceDefs [envReconstructed] :: TCEnv -> Bool -- | Injectivity can cause non-termination for unsolvable contraints (#431, -- #3067). Keep a limit on the nesting depth of injectivity uses. [envInjectivityDepth] :: TCEnv -> Int -- | 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. [envCompareBlocked] :: TCEnv -> Bool -- | When True, types will be omitted from printed pi types if -- they can be inferred. [envPrintDomainFreePi] :: TCEnv -> 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. [envPrintMetasBare] :: TCEnv -> 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. [envInsideDotPattern] :: TCEnv -> Bool [envUnquoteFlags] :: TCEnv -> UnquoteFlags -- | Until we get a termination checker for instance search (#1743) we -- limit the search depth to ensure termination. [envInstanceDepth] :: TCEnv -> !Int [envIsDebugPrinting] :: TCEnv -> Bool -- | #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. [envPrintingPatternLambdas] :: TCEnv -> [QName] -- | Use call-by-need evaluation for reductions. [envCallByNeed] :: TCEnv -> Bool -- | Checkpoints track the evolution of the context as we go under binders -- or refine it by pattern matching. [envCurrentCheckpoint] :: TCEnv -> CheckpointId -- | Keeps the substitution from each previous checkpoint to the current -- context. [envCheckpoints] :: TCEnv -> Map CheckpointId Substitution -- | Should new metas generalized over. [envGeneralizeMetas] :: TCEnv -> DoGeneralize -- | Values for used generalizable variables. [envGeneralizedVars] :: TCEnv -> Map QName GeneralizedValue -- | 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. [envActiveBackendName] :: TCEnv -> Maybe BackendName -- | Are we currently computing the overlap between two rewrite rules for -- the purpose of confluence checking? [envConflComputingOverlap] :: TCEnv -> Bool -- | Are we currently in the process of executing an elaborate-and-give -- interactive command? [envCurrentlyElaborating] :: TCEnv -> Bool -- | If this counter is Nothing, then syntactic equality checking is -- unrestricted. If it is zero, then syntactic equality checking is not -- run at all. If it is a positive number, then syntactic equality -- checking is allowed to run, but the counter is decreased in the -- failure continuation of checkSyntacticEquality. [envSyntacticEqualityFuel] :: TCEnv -> !Maybe Int -- | How much highlighting should be sent to the user interface? data HighlightingLevel None :: HighlightingLevel NonInteractive :: HighlightingLevel -- | This includes both non-interactive highlighting and interactive -- highlighting of the expression that is currently being type-checked. Interactive :: HighlightingLevel -- | How should highlighting be sent to the user interface? data HighlightingMethod -- | Via stdout. Direct :: HighlightingMethod -- | Both via files and via stdout. Indirect :: HighlightingMethod -- | For printing, we couple a meta with its name suggestion. data NamedMeta NamedMeta :: MetaNameSuggestion -> MetaId -> NamedMeta [nmSuggestion] :: NamedMeta -> MetaNameSuggestion [nmid] :: NamedMeta -> MetaId data TCWarning TCWarning :: CallStack -> Range -> Warning -> Doc -> Bool -> TCWarning -- | Location in the internal Agda source code location where the error -- raised [tcWarningLocation] :: TCWarning -> CallStack -- | Range where the warning was raised [tcWarningRange] :: TCWarning -> Range -- | The warning itself [tcWarning] :: TCWarning -> Warning -- | The warning printed in the state and environment where it was raised [tcWarningPrintedWarning] :: TCWarning -> Doc -- | Should the warning be affected by caching. [tcWarningCached] :: TCWarning -> Bool -- | Type-checking errors. data TCErr TypeError :: CallStack -> TCState -> Closure TypeError -> TCErr -- | Location in the internal Agda source code where the error was raised [tcErrLocation] :: TCErr -> CallStack -- | The state in which the error was raised. [tcErrState] :: TCErr -> TCState -- | The environment in which the error as raised plus the error. [tcErrClosErr] :: TCErr -> Closure TypeError Exception :: Range -> Doc -> TCErr -- | The first argument is the state in which the error was raised. IOException :: TCState -> Range -> IOException -> TCErr -- | The exception which is usually caught. Raised for pattern violations -- during unification (assignV) but also in other situations -- where we want to backtrack. Contains an unblocker to control when the -- computation should be retried. PatternErr :: Blocker -> TCErr -- | A non-fatal error is an error which does not prevent us from checking -- the document further and interacting with the user. data Warning NicifierIssue :: DeclarationWarning -> Warning TerminationIssue :: [TerminationError] -> Warning -- | `UnreachableClauses f rs` means that the clauses in f whose -- ranges are rs are unreachable UnreachableClauses :: QName -> [Range] -> Warning -- | `CoverageIssue f pss` means that pss are not covered in -- f CoverageIssue :: QName -> [(Telescope, [NamedArg DeBruijnPattern])] -> Warning CoverageNoExactSplit :: QName -> [Clause] -> Warning NotStrictlyPositive :: QName -> Seq OccursWhere -> Warning -- | Do not use directly with warning UnsolvedMetaVariables :: [Range] -> Warning -- | Do not use directly with warning UnsolvedInteractionMetas :: [Range] -> Warning -- | Do not use directly with warning UnsolvedConstraints :: Constraints -> Warning CantGeneralizeOverSorts :: [MetaId] -> Warning AbsurdPatternRequiresNoRHS :: [NamedArg DeBruijnPattern] -> Warning -- | In `OldBuiltin old new`, the BUILTIN old has been replaced by new OldBuiltin :: String -> String -> Warning -- | If the user wrote just {-# REWRITE #-}. EmptyRewritePragma :: Warning -- | An empty where block is dead code. EmptyWhere :: Warning -- | If the user wrote something other than an unqualified name in the -- as clause of an import statement. The String -- gives optionally extra explanation. IllformedAsClause :: String -> Warning -- | If a renaming import directive introduces a name or module -- name clash in the exported names of a module. (See issue #4154.) ClashesViaRenaming :: NameOrModule -> [Name] -> Warning -- | The 'pattern' declaration is useless in the presence of either -- coinductive or eta-equality. Content of -- String is "coinductive" or "eta", resp. UselessPatternDeclarationForRecord :: String -> Warning -- | If the user opens a module public before the module header. (See issue -- #2377.) UselessPublic :: Warning -- | Names in hiding directive that don't hide anything imported by -- a using directive. UselessHiding :: [ImportedName] -> Warning UselessInline :: QName -> Warning WrongInstanceDeclaration :: Warning -- | An instance was declared with an implicit argument, which means it -- will never actually be considered by instance search. InstanceWithExplicitArg :: QName -> Warning -- | The type of an instance argument doesn't end in a named or variable -- type, so it will never be considered by instance search. InstanceNoOutputTypeName :: Doc -> Warning -- | As InstanceWithExplicitArg, but for local bindings rather than -- top-level instances. InstanceArgWithExplicitArg :: Doc -> Warning -- | The --inversion-max-depth was reached. InversionDepthReached :: QName -> Warning -- | A coinductive record was declared but neither --guardedness nor -- --sized-types is enabled. NoGuardednessFlag :: QName -> Warning -- | Harmless generic warning (not an error) GenericWarning :: Doc -> Warning -- | Generic error which doesn't abort proceedings (not a warning) GenericNonFatalError :: Doc -> Warning -- | Generic warning when code is useless and thus ignored. Range' -- is for dead code highlighting. GenericUseless :: Range -> Doc -> Warning SafeFlagPostulate :: Name -> Warning -- | Unsafe OPTIONS. SafeFlagPragma :: [String] -> Warning SafeFlagNonTerminating :: Warning SafeFlagTerminating :: Warning SafeFlagWithoutKFlagPrimEraseEquality :: Warning WithoutKFlagPrimEraseEquality :: Warning SafeFlagNoPositivityCheck :: Warning SafeFlagPolarity :: Warning SafeFlagNoUniverseCheck :: Warning SafeFlagNoCoverageCheck :: Warning SafeFlagInjective :: Warning -- | ETA pragma is unsafe. SafeFlagEta :: Warning ParseWarning :: ParseWarning -> Warning LibraryWarning :: LibWarning -> Warning -- | `DeprecationWarning old new version`: old is deprecated, use -- new instead. This will be an error in Agda version. DeprecationWarning :: String -> String -> String -> Warning -- | User-defined warning (e.g. to mention that a name is deprecated) UserWarning :: Text -> Warning -- | Duplicate mentions of the same name in using directive(s). DuplicateUsing :: List1 ImportedName -> Warning -- | Fixity of modules cannot be changed via renaming (since modules have -- no fixity). FixityInRenamingModule :: List1 Range -> Warning -- | Some imported names are not actually exported by the source module. -- The second argument is the names that could be exported. The third -- argument is the module names that could be exported. ModuleDoesntExport :: QName -> [Name] -> [Name] -> [ImportedName] -> Warning -- | Importing a file using an infective option into one which doesn't InfectiveImport :: Doc -> Warning -- | Importing a file not using a coinfective option from one which does CoInfectiveImport :: Doc -> Warning -- | Confluence checker found critical pair and equality checking resulted -- in a type error RewriteNonConfluent :: Term -> Term -> Term -> Doc -> Warning -- | Confluence checker got stuck on computing overlap between two rewrite -- rules RewriteMaybeNonConfluent :: Term -> Term -> [Doc] -> Warning -- | The global confluence checker found a term u that reduces to -- both v1 and v2 and there is no rule to resolve the -- ambiguity. RewriteAmbiguousRules :: Term -> Term -> Term -> Warning -- | The global confluence checker found a term u that reduces to -- v, but v does not reduce to rho(u). RewriteMissingRule :: Term -> Term -> Term -> Warning -- | COMPILE directive for an erased symbol PragmaCompileErased :: BackendName -> QName -> Warning -- | Out of scope error we can recover from NotInScopeW :: [QName] -> Warning -- | Was not able to compute a full equivalence when splitting. UnsupportedIndexedMatch :: Doc -> Warning -- | The as-name in an as-pattern may not shadow a constructor -- (False) or pattern synonym name (True), because this -- can be confusing to read. AsPatternShadowsConstructorOrPatternSynonym :: Bool -> Warning RecordFieldWarning :: RecordFieldWarning -> Warning -- | Nothing is used if no verbosity options have been given, thus -- making it possible to handle the default case relatively quickly. Note -- that Nothing corresponds to a trie with verbosity level 1 for -- the empty path. type Verbosity = Maybe (Trie VerboseKeyItem VerboseLevel) type VerboseLevel = Int type VerboseKey = String class (Functor m, Applicative m, Monad m) => HasOptions m -- | Returns the pragma options which are currently in effect. pragmaOptions :: HasOptions m => m PragmaOptions -- | Returns the command line options which are currently in effect. commandLineOptions :: HasOptions m => m CommandLineOptions -- | Returns the pragma options which are currently in effect. pragmaOptions :: (HasOptions m, HasOptions n, MonadTrans t, m ~ t n) => m PragmaOptions -- | Returns the command line options which are currently in effect. commandLineOptions :: (HasOptions m, HasOptions n, MonadTrans t, m ~ t n) => m CommandLineOptions -- | The constraints needed for typeError and similar. type MonadTCError m = (MonadTCEnv m, ReadTCState m, MonadError TCErr m) -- | Embedding a TCM computation. class (Applicative tcm, MonadIO tcm, MonadTCEnv tcm, MonadTCState tcm, HasOptions tcm) => MonadTCM tcm liftTCM :: MonadTCM tcm => TCM a -> tcm a liftTCM :: (MonadTCM tcm, MonadTCM m, MonadTrans t, tcm ~ t m) => TCM a -> tcm a newtype BlockT m a BlockT :: ExceptT Blocker m a -> BlockT m a [unBlockT] :: BlockT m a -> ExceptT Blocker m a class Monad m => MonadBlock m -- | `patternViolation b` aborts the current computation patternViolation :: MonadBlock m => Blocker -> m a -- | `patternViolation b` aborts the current computation patternViolation :: (MonadBlock m, MonadTrans t, MonadBlock n, m ~ t n) => Blocker -> m a -- | `catchPatternErr handle m` runs m, handling pattern violations with -- handle (doesn't roll back the state) catchPatternErr :: MonadBlock m => (Blocker -> m a) -> m a -> m a -- | MonadTCState made into its own dedicated service class. This -- allows us to use MonadState for StateT extensions of -- TCM. class Monad m => MonadTCState m getTC :: MonadTCState m => m TCState putTC :: MonadTCState m => TCState -> m () modifyTC :: MonadTCState m => (TCState -> TCState) -> m () getTC :: (MonadTCState m, MonadTrans t, MonadTCState n, t n ~ m) => m TCState putTC :: (MonadTCState m, MonadTrans t, MonadTCState n, t n ~ m) => TCState -> m () modifyTC :: (MonadTCState m, MonadTrans t, MonadTCState n, t n ~ m) => (TCState -> TCState) -> m () -- | MonadTCEnv made into its own dedicated service class. This -- allows us to use MonadReader for ReaderT extensions of -- TCM. class Monad m => MonadTCEnv m askTC :: MonadTCEnv m => m TCEnv localTC :: MonadTCEnv m => (TCEnv -> TCEnv) -> m a -> m a askTC :: (MonadTCEnv m, MonadTrans t, MonadTCEnv n, t n ~ m) => m TCEnv localTC :: (MonadTCEnv m, MonadTransControl t, MonadTCEnv n, t n ~ m) => (TCEnv -> TCEnv) -> m a -> m a class (Applicative m, MonadTCEnv m, ReadTCState m, HasOptions m) => MonadReduce m liftReduce :: MonadReduce m => ReduceM a -> m a liftReduce :: (MonadReduce m, MonadTrans t, MonadReduce n, t n ~ m) => ReduceM a -> m a newtype ReduceM a ReduceM :: (ReduceEnv -> a) -> ReduceM a [unReduceM] :: ReduceM a -> ReduceEnv -> a -- | Environment of the reduce monad. data ReduceEnv ReduceEnv :: TCEnv -> TCState -> Maybe (MetaId -> ReduceM Bool) -> ReduceEnv -- | Read only access to environment. [redEnv] :: ReduceEnv -> TCEnv -- | Read only access to state (signature, metas...). [redSt] :: ReduceEnv -> TCState -- | An optional predicate that is used by instantiate' and -- instantiateFull': meta-variables are only instantiated if -- they satisfy this predicate. [redPred] :: ReduceEnv -> Maybe (MetaId -> ReduceM Bool) -- | Distinguish error message when parsing lhs or pattern synonym, resp. data LHSOrPatSyn IsLHS :: LHSOrPatSyn IsPatSyn :: LHSOrPatSyn data TypeError InternalError :: String -> TypeError NotImplemented :: String -> TypeError NotSupported :: String -> TypeError CompilationError :: String -> TypeError PropMustBeSingleton :: TypeError DataMustEndInSort :: Term -> TypeError -- | The target of a constructor isn't an application of its datatype. The -- Type records what it does target. ShouldEndInApplicationOfTheDatatype :: Type -> TypeError -- | 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. ShouldBeAppliedToTheDatatypeParameters :: Term -> Term -> TypeError -- | Expected a type to be an application of a particular datatype. ShouldBeApplicationOf :: Type -> QName -> TypeError -- | constructor, datatype ConstructorPatternInWrongDatatype :: QName -> QName -> TypeError -- | Datatype, constructors. CantResolveOverloadedConstructorsTargetingSameDatatype :: QName -> List1 QName -> TypeError -- | constructor, type DoesNotConstructAnElementOf :: QName -> Type -> TypeError -- | The left hand side of a function definition has a hidden argument -- where a non-hidden was expected. WrongHidingInLHS :: TypeError -- | Expected a non-hidden function and found a hidden lambda. WrongHidingInLambda :: Type -> TypeError -- | A function is applied to a hidden argument where a non-hidden was -- expected. WrongHidingInApplication :: Type -> TypeError -- | A function is applied to a hidden named argument it does not have. The -- list contains names of possible hidden arguments at this point. WrongNamedArgument :: NamedArg Expr -> [NamedName] -> TypeError -- | Wrong user-given relevance annotation in lambda. WrongIrrelevanceInLambda :: TypeError -- | Wrong user-given quantity annotation in lambda. WrongQuantityInLambda :: TypeError -- | Wrong user-given cohesion annotation in lambda. WrongCohesionInLambda :: TypeError -- | The given quantity does not correspond to the expected quantity. QuantityMismatch :: Quantity -> Quantity -> TypeError -- | The given hiding does not correspond to the expected hiding. HidingMismatch :: Hiding -> Hiding -> TypeError -- | The given relevance does not correspond to the expected relevane. RelevanceMismatch :: Relevance -> Relevance -> TypeError UninstantiatedDotPattern :: Expr -> TypeError ForcedConstructorNotInstantiated :: Pattern -> TypeError IllformedProjectionPattern :: Pattern -> TypeError CannotEliminateWithPattern :: Maybe Blocker -> NamedArg Pattern -> Type -> TypeError WrongNumberOfConstructorArguments :: QName -> Nat -> Nat -> TypeError ShouldBeEmpty :: Type -> [DeBruijnPattern] -> TypeError -- | The given type should have been a sort. ShouldBeASort :: Type -> TypeError -- | The given type should have been a pi. ShouldBePi :: Type -> TypeError ShouldBePath :: Type -> TypeError ShouldBeRecordType :: Type -> TypeError ShouldBeRecordPattern :: DeBruijnPattern -> TypeError NotAProjectionPattern :: NamedArg Pattern -> TypeError NotAProperTerm :: TypeError -- | This sort is not a type expression. InvalidTypeSort :: Sort -> TypeError -- | This term is not a type expression. InvalidType :: Term -> TypeError -- | This term, a function type constructor, lives in SizeUniv, -- which is not allowed. FunctionTypeInSizeUniv :: Term -> TypeError SplitOnIrrelevant :: Dom Type -> TypeError SplitOnUnusableCohesion :: Dom Type -> TypeError SplitOnNonVariable :: Term -> Type -> TypeError SplitOnNonEtaRecord :: QName -> TypeError DefinitionIsIrrelevant :: QName -> TypeError DefinitionIsErased :: QName -> TypeError VariableIsIrrelevant :: Name -> TypeError VariableIsErased :: Name -> TypeError VariableIsOfUnusableCohesion :: Name -> Cohesion -> TypeError UnequalLevel :: Comparison -> Level -> Level -> TypeError UnequalTerms :: Comparison -> Term -> Term -> CompareAs -> TypeError UnequalTypes :: Comparison -> Type -> Type -> TypeError -- | The two function types have different relevance. UnequalRelevance :: Comparison -> Term -> Term -> TypeError -- | The two function types have different relevance. UnequalQuantity :: Comparison -> Term -> Term -> TypeError -- | The two function types have different cohesion. UnequalCohesion :: Comparison -> Term -> Term -> TypeError -- | One of the function types has a finite domain (i.e. is a -- Partial@) and the other isonot. UnequalFiniteness :: Comparison -> Term -> Term -> TypeError -- | The two function types have different hiding. UnequalHiding :: Term -> Term -> TypeError UnequalSorts :: Sort -> Sort -> TypeError UnequalBecauseOfUniverseConflict :: Comparison -> Term -> Term -> TypeError NotLeqSort :: Sort -> Sort -> TypeError -- | The arguments are the meta variable and the parameter that it wants to -- depend on. MetaCannotDependOn :: MetaId -> Nat -> TypeError MetaOccursInItself :: MetaId -> TypeError MetaIrrelevantSolution :: MetaId -> Term -> TypeError MetaErasedSolution :: MetaId -> Term -> TypeError GenericError :: String -> TypeError GenericDocError :: Doc -> TypeError -- | the meta is what we might be blocked on. SortOfSplitVarError :: Maybe Blocker -> Doc -> TypeError BuiltinMustBeConstructor :: String -> Expr -> TypeError NoSuchBuiltinName :: String -> TypeError DuplicateBuiltinBinding :: String -> Term -> Term -> TypeError NoBindingForBuiltin :: String -> TypeError NoSuchPrimitiveFunction :: String -> TypeError DuplicatePrimitiveBinding :: String -> QName -> QName -> TypeError WrongModalityForPrimitive :: String -> ArgInfo -> ArgInfo -> TypeError ShadowedModule :: Name -> [ModuleName] -> TypeError BuiltinInParameterisedModule :: String -> TypeError IllegalLetInTelescope :: TypedBinding -> TypeError IllegalPatternInTelescope :: Binder -> TypeError NoRHSRequiresAbsurdPattern :: [NamedArg Pattern] -> TypeError -- | Record type, fields not supplied by user, non-fields but supplied. TooManyFields :: QName -> [Name] -> [Name] -> TypeError DuplicateFields :: [Name] -> TypeError DuplicateConstructors :: [Name] -> TypeError WithOnFreeVariable :: Expr -> Term -> TypeError UnexpectedWithPatterns :: [Pattern] -> TypeError WithClausePatternMismatch :: Pattern -> NamedArg DeBruijnPattern -> TypeError FieldOutsideRecord :: TypeError ModuleArityMismatch :: ModuleName -> Telescope -> [NamedArg Expr] -> TypeError GeneralizeCyclicDependency :: TypeError GeneralizeUnsolvedMeta :: TypeError SplitError :: SplitError -> TypeError ImpossibleConstructor :: QName -> NegativeUnification -> TypeError TooManyPolarities :: QName -> Int -> TypeError LocalVsImportedModuleClash :: ModuleName -> TypeError -- | 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. SolvedButOpenHoles :: TypeError CyclicModuleDependency :: [TopLevelModuleName] -> TypeError FileNotFound :: TopLevelModuleName -> [AbsolutePath] -> TypeError OverlappingProjects :: AbsolutePath -> TopLevelModuleName -> TopLevelModuleName -> TypeError AmbiguousTopLevelModuleName :: TopLevelModuleName -> [AbsolutePath] -> TypeError -- | Found module name, expected module name. ModuleNameUnexpected :: TopLevelModuleName -> TopLevelModuleName -> TypeError ModuleNameDoesntMatchFileName :: TopLevelModuleName -> [AbsolutePath] -> TypeError ClashingFileNamesFor :: ModuleName -> [AbsolutePath] -> TypeError -- | Module name, file from which it was loaded, file which the include -- path says contains the module. Scope errors ModuleDefinedInOtherFile :: TopLevelModuleName -> AbsolutePath -> AbsolutePath -> TypeError BothWithAndRHS :: TypeError AbstractConstructorNotInScope :: QName -> TypeError NotInScope :: [QName] -> TypeError NoSuchModule :: QName -> TypeError AmbiguousName :: QName -> AmbiguousNameReason -> TypeError AmbiguousModule :: QName -> List1 ModuleName -> TypeError ClashingDefinition :: QName -> QName -> Maybe NiceDeclaration -> TypeError ClashingModule :: ModuleName -> ModuleName -> TypeError ClashingImport :: Name -> QName -> TypeError ClashingModuleImport :: Name -> ModuleName -> TypeError PatternShadowsConstructor :: Name -> QName -> TypeError DuplicateImports :: QName -> [ImportedName] -> TypeError InvalidPattern :: Pattern -> TypeError RepeatedVariablesInPattern :: [Name] -> TypeError GeneralizeNotSupportedHere :: QName -> TypeError MultipleFixityDecls :: [(Name, [Fixity'])] -> TypeError MultiplePolarityPragmas :: [Name] -> TypeError -- | The expr was used in the right hand side of an implicit module -- definition, but it wasn't of the form m Delta. NotAModuleExpr :: Expr -> TypeError NotAnExpression :: Expr -> TypeError NotAValidLetBinding :: NiceDeclaration -> TypeError NotValidBeforeField :: NiceDeclaration -> TypeError NothingAppliedToHiddenArg :: Expr -> TypeError NothingAppliedToInstanceArg :: Expr -> TypeError BadArgumentsToPatternSynonym :: AmbiguousQName -> TypeError TooFewArgumentsToPatternSynonym :: AmbiguousQName -> TypeError CannotResolveAmbiguousPatternSynonym :: List1 (QName, PatternSynDefn) -> TypeError UnusedVariableInPatternSynonym :: TypeError NoParseForApplication :: List2 Expr -> TypeError AmbiguousParseForApplication :: List2 Expr -> List1 Expr -> TypeError -- | The list contains patterns that failed to be interpreted. If it is -- non-empty, the first entry could be printed as error hint. NoParseForLHS :: LHSOrPatSyn -> [Pattern] -> Pattern -> TypeError -- | Pattern and its possible interpretations. AmbiguousParseForLHS :: LHSOrPatSyn -> Pattern -> [Pattern] -> TypeError OperatorInformation :: [NotationSection] -> TypeError -> TypeError InstanceNoCandidate :: Type -> [(Term, TCErr)] -> TypeError UnquoteFailed :: UnquoteError -> TypeError DeBruijnIndexOutOfScope :: Nat -> Telescope -> [Name] -> TypeError NeedOptionCopatterns :: TypeError NeedOptionRewriting :: TypeError NeedOptionProp :: TypeError NeedOptionTwoLevel :: TypeError NonFatalErrors :: [TCWarning] -> TypeError InstanceSearchDepthExhausted :: Term -> Type -> Int -> TypeError TriedToCopyConstrainedPrim :: QName -> TypeError data UnquoteError BadVisibility :: String -> Arg Term -> UnquoteError ConInsteadOfDef :: QName -> String -> String -> UnquoteError DefInsteadOfCon :: QName -> String -> String -> UnquoteError NonCanonical :: String -> Term -> UnquoteError BlockedOnMeta :: TCState -> Blocker -> UnquoteError UnquotePanic :: String -> UnquoteError data UnificationFailure -- | Failed to apply injectivity to constructor of indexed datatype UnifyIndicesNotVars :: Telescope -> Type -> Term -> Term -> Args -> UnificationFailure -- | Can't solve equation because variable occurs in (type of) lhs UnifyRecursiveEq :: Telescope -> Type -> Int -> Term -> UnificationFailure -- | Can't solve reflexive equation because --without-K is enabled UnifyReflexiveEq :: Telescope -> Type -> Term -> UnificationFailure -- | Can't solve equation because solution modality is less "usable" UnifyUnusableModality :: Telescope -> Type -> Int -> Term -> Modality -> UnificationFailure data NegativeUnification UnifyConflict :: Telescope -> Term -> Term -> NegativeUnification UnifyCycle :: Telescope -> Int -> Term -> NegativeUnification -- | Error when splitting a pattern variable into possible constructor -- patterns. data SplitError -- | Neither data type nor record. NotADatatype :: Closure Type -> SplitError -- | Type could not be sufficiently reduced. BlockedType :: Blocker -> Closure Type -> SplitError -- | 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. ErasedDatatype :: Bool -> Closure Type -> SplitError -- | Split on codata not allowed. UNUSED, but keep! -- | -- NoRecordConstructor Type -- ^ record type, but no constructor CoinductiveDatatype :: Closure Type -> SplitError UnificationStuck :: Maybe Blocker -> QName -> Telescope -> Args -> Args -> [UnificationFailure] -> SplitError -- | Blocking metavariable (if any) [cantSplitBlocker] :: SplitError -> Maybe Blocker -- | Constructor. [cantSplitConName] :: SplitError -> QName -- | Context for indices. [cantSplitTel] :: SplitError -> Telescope -- | Inferred indices (from type of constructor). [cantSplitConIdx] :: SplitError -> Args -- | Expected indices (from checking pattern). [cantSplitGivenIdx] :: SplitError -> Args -- | Reason(s) why unification got stuck. [cantSplitFailures] :: SplitError -> [UnificationFailure] -- | Copattern split with a catchall CosplitCatchall :: SplitError -- | We do not know the target type of the clause. CosplitNoTarget :: SplitError -- | Target type is not a record type. CosplitNoRecordType :: Closure Type -> SplitError CannotCreateMissingClause :: QName -> (Telescope, [NamedArg DeBruijnPattern]) -> Doc -> Closure (Abs Type) -> SplitError GenericSplitError :: String -> SplitError -- | Information about a mutual block which did not pass the termination -- checker. data TerminationError TerminationError :: [QName] -> [CallInfo] -> TerminationError -- | The functions which failed to check. (May not include automatically -- generated functions.) [termErrFunctions] :: TerminationError -> [QName] -- | The problematic call sites. [termErrCalls] :: TerminationError -> [CallInfo] -- | Information about a call. data CallInfo CallInfo :: QName -> Closure Term -> CallInfo -- | Target function name. (Contains its range.) [callInfoTarget] :: CallInfo -> QName -- | To be formatted representation of the call. [callInfoCall] :: CallInfo -> Closure Term data RecordFieldWarning -- | Each redundant field comes with a range of associated dead code. DuplicateFieldsWarning :: [(Name, Range)] -> RecordFieldWarning -- | Record type, fields not supplied by user, non-fields but supplied. The -- redundant fields come with a range of associated dead code. TooManyFieldsWarning :: QName -> [Name] -> [(Name, Range)] -> RecordFieldWarning data ArgsCheckState a ACState :: [Maybe Range] -> Elims -> [Maybe (Abs Constraint)] -> Type -> a -> ArgsCheckState a -- | Ranges of checked arguments, where present. e.g. inserted implicits -- have no correponding abstract syntax. [acRanges] :: ArgsCheckState a -> [Maybe Range] -- | Checked and inserted arguments so far. [acElims] :: ArgsCheckState a -> Elims -- | Constraints for the head so far, i.e. before applying the correponding -- elim. [acConstraints] :: ArgsCheckState a -> [Maybe (Abs Constraint)] -- | Type for the rest of the application. [acType] :: ArgsCheckState a -> Type [acData] :: ArgsCheckState a -> a -- | A candidate solution for an instance meta is a term with its type. It -- may be the case that the candidate is not fully applied yet or of the -- wrong type, hence the need for the type. data Candidate Candidate :: CandidateKind -> Term -> Type -> Bool -> Candidate [candidateKind] :: Candidate -> CandidateKind [candidateTerm] :: Candidate -> Term [candidateType] :: Candidate -> Type [candidateOverlappable] :: Candidate -> Bool data CandidateKind LocalCandidate :: CandidateKind GlobalCandidate :: QName -> CandidateKind data ExpandHidden -- | Add implicit arguments in the end until type is no longer hidden -- Pi. ExpandLast :: ExpandHidden -- | Do not append implicit arguments. DontExpandLast :: ExpandHidden -- | Makes doExpandLast have no effect. Used to avoid implicit -- insertion of arguments to metavariables. ReallyDontExpandLast :: ExpandHidden data AbstractMode -- | Abstract things in the current module can be accessed. AbstractMode :: AbstractMode -- | No abstract things can be accessed. ConcreteMode :: AbstractMode -- | All abstract things can be accessed. IgnoreAbstractMode :: AbstractMode type LetBindings = Map Name (Open (Term, Dom Type)) type ContextEntry = Dom (Name, Type) -- | The Context is a stack of ContextEntrys. type Context = [ContextEntry] data UnquoteFlags UnquoteFlags :: Bool -> UnquoteFlags [_unquoteNormalise] :: UnquoteFlags -> Bool class LensTCEnv a lensTCEnv :: LensTCEnv a => Lens' TCEnv a data Builtin pf Builtin :: Term -> Builtin pf Prim :: pf -> Builtin pf -- | BUILTIN REWRITE. We can have several rewrite relations. BuiltinRewriteRelations :: Set QName -> Builtin pf type BuiltinThings pf = Map String (Builtin pf) data BuiltinInfo BuiltinInfo :: String -> BuiltinDescriptor -> BuiltinInfo [builtinName] :: BuiltinInfo -> String [builtinDesc] :: BuiltinInfo -> BuiltinDescriptor data BuiltinDescriptor BuiltinData :: TCM Type -> [String] -> BuiltinDescriptor BuiltinDataCons :: TCM Type -> BuiltinDescriptor BuiltinPrim :: String -> (Term -> TCM ()) -> BuiltinDescriptor BuiltinSort :: String -> BuiltinDescriptor BuiltinPostulate :: Relevance -> TCM Type -> BuiltinDescriptor -- | Builtin of any kind. Type can be checked (Just t) or inferred -- (Nothing). The second argument is the hook for the -- verification function. BuiltinUnknown :: Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor -- | When typechecking something of the following form: -- -- instance x : _ x = y -- -- it's not yet known where to add x, so we add it to a list of -- unresolved instances and we'll deal with it later. type TempInstanceTable = (InstanceTable, Set QName) -- | The instance table is a Map associating to every name of -- recorddata typepostulate its list of instances type InstanceTable = Map QName (Set QName) data Call CheckClause :: Type -> SpineClause -> Call CheckLHS :: SpineLHS -> Call CheckPattern :: Pattern -> Telescope -> Type -> Call CheckPatternLinearityType :: Name -> Call CheckPatternLinearityValue :: Name -> Call CheckLetBinding :: LetBinding -> Call InferExpr :: Expr -> Call CheckExprCall :: Comparison -> Expr -> Type -> Call CheckDotPattern :: Expr -> Term -> Call CheckProjection :: Range -> QName -> Type -> Call IsTypeCall :: Comparison -> Expr -> Sort -> Call IsType_ :: Expr -> Call InferVar :: Name -> Call InferDef :: QName -> Call CheckArguments :: Range -> [NamedArg Expr] -> Type -> Maybe Type -> Call CheckMetaSolution :: Range -> MetaId -> Type -> Term -> Call CheckTargetType :: Range -> Type -> Type -> Call CheckDataDef :: Range -> QName -> [LamBinding] -> [Constructor] -> Call CheckRecDef :: Range -> QName -> [LamBinding] -> [Constructor] -> Call CheckConstructor :: QName -> Telescope -> Sort -> Constructor -> Call CheckConstructorFitsIn :: QName -> Type -> Sort -> Call -- | Highlight (interactively) if and only if the boolean is True. CheckFunDefCall :: Range -> QName -> [Clause] -> Bool -> Call CheckPragma :: Range -> Pragma -> Call CheckPrimitive :: Range -> QName -> Expr -> Call CheckIsEmpty :: Range -> Type -> Call CheckConfluence :: QName -> QName -> Call CheckWithFunctionType :: Type -> Call CheckSectionApplication :: Range -> ModuleName -> ModuleApplication -> Call CheckNamedWhere :: ModuleName -> Call -- | Checking a clause for confluence with endpoint reductions. Always -- φ ⊢ f vs = rhs for now, but we store the simplifications of -- f vs[φ] and rhs[φ]. CheckIApplyConfluence :: Range -> QName -> Term -> Term -> Term -> Type -> Call ScopeCheckExpr :: Expr -> Call ScopeCheckDeclaration :: NiceDeclaration -> Call ScopeCheckLHS :: QName -> Pattern -> Call NoHighlighting :: Call -- | Interaction command: show module contents. ModuleContents :: Call -- | used by setCurrentRange SetRange :: Range -> Call type Statistics = Map String Integer newtype MutualId MutId :: Int32 -> MutualId data TermHead SortHead :: TermHead PiHead :: TermHead ConsHead :: QName -> TermHead VarHead :: Nat -> TermHead UnknownHead :: TermHead data FunctionInverse' c NotInjective :: FunctionInverse' c Inverse :: InversionMap c -> FunctionInverse' c type InversionMap c = Map TermHead [c] type FunctionInverse = FunctionInverse' Clause data PrimFun PrimFun :: QName -> Arity -> ([Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun [primFunName] :: PrimFun -> QName [primFunArity] :: PrimFun -> Arity [primFunImplementation] :: PrimFun -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) -- | Primitives data PrimitiveImpl PrimImpl :: Type -> PrimFun -> PrimitiveImpl data ReduceDefs OnlyReduceDefs :: Set QName -> ReduceDefs DontReduceDefs :: Set QName -> ReduceDefs type AllowedReductions = SmallSet AllowedReduction -- | Controlling reduce. data AllowedReduction -- | (Projection and) projection-like functions may be reduced. ProjectionReductions :: AllowedReduction -- | Functions marked INLINE may be reduced. InlineReductions :: AllowedReduction -- | Copattern definitions may be reduced. CopatternReductions :: AllowedReduction -- | Non-recursive functions and primitives may be reduced. FunctionReductions :: AllowedReduction -- | Even recursive functions may be reduced. RecursiveReductions :: AllowedReduction -- | Reduce Term terms. LevelReductions :: AllowedReduction -- | Allow allReductions in types, even if not allowed at term -- level (used by confluence checker) TypeLevelReductions :: AllowedReduction -- | Functions whose termination has not (yet) been confirmed. UnconfirmedReductions :: AllowedReduction -- | Functions that have failed termination checking. NonTerminatingReductions :: AllowedReduction type MaybeReducedElims = [MaybeReduced Elim] type MaybeReducedArgs = [MaybeReduced (Arg Term)] data MaybeReduced a MaybeRed :: IsReduced -> a -> MaybeReduced a [isReduced] :: MaybeReduced a -> IsReduced [ignoreReduced] :: MaybeReduced a -> a -- | Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not -- blocked. data IsReduced NotReduced :: IsReduced Reduced :: Blocked () -> IsReduced data Reduced no yes NoReduction :: no -> Reduced no yes YesReduction :: Simplification -> yes -> Reduced no yes -- | Did we encounter a simplifying reduction? In terms of CIC, that would -- be a iota-reduction. In terms of Agda, this is a constructor or -- literal pattern that matched. Just beta-reduction (substitution) or -- delta-reduction (unfolding of definitions) does not count as -- simplifying? data Simplification YesSimplification :: Simplification NoSimplification :: Simplification newtype Fields Fields :: [(Name, Type)] -> Fields data PrimitiveSortData PrimitiveSortData :: String -> Sort -> PrimitiveSortData [_primSortName] :: PrimitiveSortData -> String [_primSortSort] :: PrimitiveSortData -> Sort data PrimitiveData PrimitiveData :: IsAbstract -> String -> [Clause] -> FunctionInverse -> Maybe CompiledClauses -> PrimitiveData [_primAbstr] :: PrimitiveData -> IsAbstract [_primName] :: PrimitiveData -> String -- | null for primitive functions, not null for builtin -- functions. [_primClauses] :: PrimitiveData -> [Clause] -- | Builtin functions can have inverses. For instance, natural number -- addition. [_primInv] :: PrimitiveData -> FunctionInverse -- | Nothing for primitive functions, Just something -- for builtin functions. [_primCompiled] :: PrimitiveData -> Maybe CompiledClauses data ConstructorData ConstructorData :: Int -> Int -> ConHead -> QName -> IsAbstract -> Induction -> CompKit -> Maybe [QName] -> [IsForced] -> Maybe [Bool] -> ConstructorData -- | Number of parameters. [_conPars] :: ConstructorData -> Int -- | Number of arguments (excluding parameters). [_conArity] :: ConstructorData -> Int -- | Name of (original) constructor and fields. (This might be in a module -- instance.) [_conSrcCon] :: ConstructorData -> ConHead -- | Name of datatype or record type. [_conData] :: ConstructorData -> QName [_conAbstr] :: ConstructorData -> IsAbstract -- | Inductive or coinductive? [_conInd] :: ConstructorData -> Induction -- | Cubical composition. [_conComp] :: ConstructorData -> CompKit -- | Projections. Nothing if not yet computed. [_conProj] :: ConstructorData -> Maybe [QName] -- | 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. [_conForced] :: ConstructorData -> [IsForced] -- | 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. [_conErased] :: ConstructorData -> Maybe [Bool] data RecordData RecordData :: Nat -> Maybe Clause -> ConHead -> Bool -> [Dom QName] -> Telescope -> Maybe [QName] -> EtaEquality -> PatternOrCopattern -> Maybe Induction -> Maybe Bool -> IsAbstract -> CompKit -> RecordData -- | Number of parameters. [_recPars] :: RecordData -> Nat -- | Was this record type created by a module application? If yes, the -- clause is its definition (linking back to the original record type). [_recClause] :: RecordData -> Maybe Clause -- | Constructor name and fields. [_recConHead] :: RecordData -> ConHead -- | Does this record have a constructor? [_recNamedCon] :: RecordData -> Bool -- | The record field names. [_recFields] :: RecordData -> [Dom QName] -- | The record field telescope. (Includes record parameters.) Note: -- TelV recTel _ == telView' recConType. Thus, recTel -- is redundant. [_recTel] :: RecordData -> Telescope -- | Mutually recursive functions, datas and records. -- Does include this record. Empty if not recursive. Nothing if -- not yet computed (by positivity checker). [_recMutual] :: RecordData -> Maybe [QName] -- | Eta-expand at this record type? False for unguarded recursive -- records and coinductive records unless the user specifies otherwise. [_recEtaEquality'] :: RecordData -> EtaEquality -- | In case eta-equality is off, do we allow pattern matching on the -- constructor or construction by copattern matching? Having both loses -- subject reduction, see issue #4560. After positivity checking, this -- field is obsolete, part of EtaEquality. [_recPatternMatching] :: RecordData -> PatternOrCopattern -- | Inductive or CoInductive? Matters only for recursive -- records. Nothing means that the user did not specify it, which -- is an error for recursive records. [_recInduction] :: RecordData -> Maybe Induction -- | 'Just True' means that unfolding of the recursive record terminates, -- 'Just False' means that we have no evidence for termination, and -- Nothing means we have not run the termination checker yet. [_recTerminates] :: RecordData -> Maybe Bool [_recAbstr] :: RecordData -> IsAbstract [_recComp] :: RecordData -> CompKit data DatatypeData DatatypeData :: Nat -> Nat -> Maybe Clause -> [QName] -> Sort -> Maybe [QName] -> IsAbstract -> [QName] -> Maybe QName -> Maybe QName -> DatatypeData -- | Number of parameters. [_dataPars] :: DatatypeData -> Nat -- | Number of indices. [_dataIxs] :: DatatypeData -> Nat -- | This might be in an instantiated module. [_dataClause] :: DatatypeData -> Maybe Clause -- | Constructor names, ordered according to the order of their definition. [_dataCons] :: DatatypeData -> [QName] [_dataSort] :: DatatypeData -> Sort -- | Mutually recursive functions, datas and records. -- Does include this data type. Empty if not recursive. Nothing -- if not yet computed (by positivity checker). [_dataMutual] :: DatatypeData -> Maybe [QName] [_dataAbstr] :: DatatypeData -> IsAbstract -- | Path constructor names (subset of dataCons). [_dataPathCons] :: DatatypeData -> [QName] -- | If indexed datatype, name of the "index transport" function. [_dataTranspIx] :: DatatypeData -> Maybe QName -- | Transport function, should be available for all datatypes in supported -- sorts. [_dataTransp] :: DatatypeData -> Maybe QName data FunctionData FunctionData :: [Clause] -> Maybe CompiledClauses -> Maybe SplitTree -> Maybe Compiled -> [Clause] -> FunctionInverse -> Maybe [QName] -> IsAbstract -> Delayed -> Either ProjectionLikenessMissing Projection -> Set FunctionFlag -> Maybe Bool -> Maybe ExtLamInfo -> Maybe QName -> Maybe QName -> FunctionData [_funClauses] :: FunctionData -> [Clause] -- | Nothing while function is still type-checked. Just cc -- after type and coverage checking and translation to case trees. [_funCompiled] :: FunctionData -> Maybe CompiledClauses -- | The split tree constructed by the coverage checker. Needed to -- re-compile the clauses after forcing translation. [_funSplitTree] :: FunctionData -> Maybe SplitTree -- | Intermediate representation for compiler backends. [_funTreeless] :: FunctionData -> Maybe Compiled -- | Covering clauses computed by coverage checking. Erased by (IApply) -- confluence checking(?) [_funCovering] :: FunctionData -> [Clause] [_funInv] :: FunctionData -> FunctionInverse -- | Mutually recursive functions, datas and records. -- Does include this function. Empty list if not recursive. -- Nothing if not yet computed (by positivity checker). [_funMutual] :: FunctionData -> Maybe [QName] [_funAbstr] :: FunctionData -> IsAbstract -- | Are the clauses of this definition delayed? [_funDelayed] :: FunctionData -> Delayed -- | 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. [_funProjection] :: FunctionData -> Either ProjectionLikenessMissing Projection [_funFlags] :: FunctionData -> Set FunctionFlag -- | Has this function been termination checked? Did it pass? [_funTerminates] :: FunctionData -> Maybe Bool -- | Is this function generated from an extended lambda? If yes, then -- return the number of hidden and non-hidden lambda-lifted arguments. [_funExtLam] :: FunctionData -> Maybe ExtLamInfo -- | Is this a generated with-function? If yes, then what's the name of the -- parent function? [_funWith] :: FunctionData -> Maybe QName -- | Is this a helper for one of the Kan operations (transp, hcomp) on data -- types/records? If so, for which data type? [_funIsKanOp] :: FunctionData -> Maybe QName -- | Indicates the reason behind a function having not been marked -- projection-like. data ProjectionLikenessMissing -- | Projection-likeness analysis has not run on this function yet. It may -- do so in the future. MaybeProjection :: ProjectionLikenessMissing -- | The user has requested that this function be not be marked -- projection-like. The analysis may already have run on this function, -- but the results have been discarded, and it will not be run again. NeverProjection :: ProjectionLikenessMissing data DataOrRecSigData DataOrRecSigData :: Int -> DataOrRecSigData [_datarecPars] :: DataOrRecSigData -> Int data AxiomData AxiomData :: Bool -> AxiomData -- | Can transp for this postulate be constant? Set to True for -- bultins like String. [_axiomConstTransp] :: AxiomData -> Bool data Defn -- | Postulate. AxiomDefn :: AxiomData -> Defn -- | Data or record type signature that doesn't yet have a definition. DataOrRecSigDefn :: DataOrRecSigData -> Defn -- | Generalizable variable (introduced in generalize block). GeneralizableVar :: Defn -- | Returned by getConstInfo if definition is abstract. AbstractDefn :: Defn -> Defn FunctionDefn :: FunctionData -> Defn DatatypeDefn :: DatatypeData -> Defn RecordDefn :: RecordData -> Defn ConstructorDefn :: ConstructorData -> Defn -- | Primitive or builtin functions. PrimitiveDefn :: PrimitiveData -> Defn PrimitiveSortDefn :: PrimitiveSortData -> Defn data CompKit CompKit :: Maybe QName -> Maybe QName -> CompKit [nameOfHComp] :: CompKit -> Maybe QName [nameOfTransp] :: CompKit -> Maybe QName data FunctionFlag -- | Should calls to this function be normalised at compile-time? FunStatic :: FunctionFlag -- | Should calls to this function be inlined by the compiler? FunInline :: FunctionFlag -- | Is this function a macro? FunMacro :: FunctionFlag -- | Should a record type admit eta-equality? data EtaEquality -- | User specifed 'eta-equality' or 'no-eta-equality'. Specified :: !HasEta -> EtaEquality [theEtaEquality] :: EtaEquality -> !HasEta -- | Positivity checker inferred whether eta is safe. Inferred :: !HasEta -> EtaEquality [theEtaEquality] :: EtaEquality -> !HasEta -- | Abstractions to build projection function (dropping parameters). newtype ProjLams ProjLams :: [Arg ArgName] -> ProjLams [getProjLams] :: ProjLams -> [Arg ArgName] -- | Additional information for projection Functions. data Projection Projection :: Maybe QName -> QName -> Arg QName -> Int -> ProjLams -> Projection -- | 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. [projProper] :: Projection -> Maybe QName -- | The original projection name (current name could be from module -- application). [projOrig] :: Projection -> QName -- | Type projected from. Original record type if projProper = -- Just{}. Also stores ArgInfo of the principal argument. -- This field is unchanged by module application. [projFromType] :: Projection -> Arg QName -- | 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. [projIndex] :: Projection -> Int -- | 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. [projLams] :: Projection -> ProjLams -- | Additional information for extended lambdas. data ExtLamInfo ExtLamInfo :: ModuleName -> Bool -> !Maybe System -> ExtLamInfo -- | 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. [extLamModule] :: ExtLamInfo -> ModuleName -- | Was this definition created from an absurd lambda λ ()? [extLamAbsurd] :: ExtLamInfo -> Bool [extLamSys] :: ExtLamInfo -> !Maybe 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). data System System :: Telescope -> [(Face, Term)] -> System -- | the telescope Δ, binding vars for the clauses, Γ ⊢ Δ [systemTel] :: System -> Telescope -- | a system [φ₁ u₁, ... , φₙ uₙ] where Γ, Δ ⊢ φᵢ and Γ, Δ, φᵢ ⊢ uᵢ [systemClauses] :: System -> [(Face, Term)] type Face = [(Term, Bool)] type CompiledRepresentation = Map BackendName [CompilerPragma] -- | The backends are responsible for parsing their own pragmas. data CompilerPragma CompilerPragma :: Range -> String -> CompilerPragma -- | Information about whether an argument is forced by the type of a -- function. data IsForced Forced :: IsForced NotForced :: IsForced data NumGeneralizableArgs NoGeneralizableArgs :: NumGeneralizableArgs -- | When lambda-lifting new args are generalizable if -- SomeGeneralizableArgs, also when the number is zero. SomeGeneralizableArgs :: !Int -> NumGeneralizableArgs data Definition Defn :: ArgInfo -> QName -> Type -> [Polarity] -> [Occurrence] -> NumGeneralizableArgs -> [Maybe Name] -> [LocalDisplayForm] -> MutualId -> CompiledRepresentation -> Maybe QName -> Bool -> Set QName -> Bool -> Bool -> Bool -> Blocked_ -> !Language -> Defn -> Definition -- | Hiding should not be used. [defArgInfo] :: Definition -> ArgInfo -- | The canonical name, used e.g. in compilation. [defName] :: Definition -> QName -- | Type of the lifted definition. [defType] :: Definition -> Type -- | Variance information on arguments of the definition. Does not include -- info for dropped parameters to projection(-like) functions and -- constructors. [defPolarity] :: Definition -> [Polarity] -- | Positivity information on arguments of the definition. Does not -- include info for dropped parameters to projection(-like) functions and -- constructors. [defArgOccurrences] :: Definition -> [Occurrence] -- | How many arguments should be generalised. [defArgGeneralizable] :: Definition -> NumGeneralizableArgs -- | 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. [defGeneralizedParams] :: Definition -> [Maybe Name] [defDisplay] :: Definition -> [LocalDisplayForm] [defMutual] :: Definition -> MutualId [defCompiledRep] :: Definition -> CompiledRepresentation -- | Just q when this definition is an instance of class q [defInstance] :: Definition -> Maybe QName -- | Has this function been created by a module instantiation? [defCopy] :: Definition -> Bool -- | The set of symbols with rewrite rules that match against this symbol [defMatchable] :: Definition -> Set QName -- | should compilers skip this? Used for e.g. cubical's comp [defNoCompilation] :: Definition -> Bool -- | Should the def be treated as injective by the pattern matching -- unifier? [defInjective] :: Definition -> Bool -- | Is this a function defined by copatterns? [defCopatternLHS] :: Definition -> Bool -- | 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. [defBlocked] :: Definition -> Blocked_ -- | The language used for the definition. [defLanguage] :: Definition -> !Language [theDef] :: Definition -> Defn -- | Rewrite rules can be added independently from function clauses. data RewriteRule RewriteRule :: QName -> Telescope -> QName -> PElims -> Term -> Type -> Bool -> RewriteRule -- | Name of rewrite rule q : Γ → f ps ≡ rhs where is -- the rewrite relation. [rewName] :: RewriteRule -> QName -- | Γ. [rewContext] :: RewriteRule -> Telescope -- | f. [rewHead] :: RewriteRule -> QName -- | Γ ⊢ f ps : t. [rewPats] :: RewriteRule -> PElims -- | Γ ⊢ rhs : t. [rewRHS] :: RewriteRule -> Term -- | Γ ⊢ t. [rewType] :: RewriteRule -> Type -- | Was this rewrite rule created from a clause in the definition of the -- function? [rewFromClause] :: RewriteRule -> Bool type RewriteRules = [RewriteRule] data NLPSort PType :: NLPat -> NLPSort PProp :: NLPat -> NLPSort PSSet :: NLPat -> NLPSort PInf :: IsFibrant -> Integer -> NLPSort PSizeUniv :: NLPSort PLockUniv :: NLPSort PIntervalUniv :: NLPSort data NLPType NLPType :: NLPSort -> NLPat -> NLPType [nlpTypeSort] :: NLPType -> NLPSort [nlpTypeUnEl] :: NLPType -> NLPat type PElims = [Elim' NLPat] -- | Non-linear (non-constructor) first-order pattern. data NLPat -- | Matches anything (modulo non-linearity) that only contains bound -- variables that occur in the given arguments. PVar :: !Int -> [Arg Int] -> NLPat -- | Matches f es PDef :: QName -> PElims -> NLPat -- | Matches λ x → t PLam :: ArgInfo -> Abs NLPat -> NLPat -- | Matches (x : A) → B PPi :: Dom NLPType -> Abs NLPType -> NLPat -- | Matches a sort of the given shape. PSort :: NLPSort -> NLPat -- | Matches x es where x is a lambda-bound variable PBoundVar :: {-# UNPACK #-} !Int -> PElims -> NLPat -- | Matches the term modulo β (ideally βη). PTerm :: Term -> NLPat -- | A structured presentation of a Term for reification into -- Syntax. data DisplayTerm -- | (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). DWithApp :: DisplayTerm -> [DisplayTerm] -> Elims -> DisplayTerm -- | c vs. DCon :: ConHead -> ConInfo -> [Arg DisplayTerm] -> DisplayTerm -- | d vs. DDef :: QName -> [Elim' DisplayTerm] -> DisplayTerm -- | .v. DDot :: Term -> DisplayTerm -- | v. DTerm :: Term -> DisplayTerm type LocalDisplayForm = Open 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 the first -- dfPatternVars variables are pattern variables that matches -- any term. data DisplayForm Display :: Nat -> Elims -> DisplayTerm -> DisplayForm -- | Number n of pattern variables in dfPats. [dfPatternVars] :: DisplayForm -> Nat -- | Left hand side patterns, the n first free variables are -- pattern variables, any variables above n are fixed and only -- match that particular variable. This happens when you have display -- forms inside parameterised modules that match on the module -- parameters. The ArgInfo is ignored in these patterns. [dfPats] :: DisplayForm -> Elims -- | Right hand side. [dfRHS] :: DisplayForm -> DisplayTerm newtype Section Section :: Telescope -> Section [_secTelescope] :: Section -> Telescope type DisplayForms = HashMap QName [LocalDisplayForm] type RewriteRuleMap = HashMap QName RewriteRules type Definitions = HashMap QName Definition type Sections = Map ModuleName Section data Signature Sig :: Sections -> Definitions -> RewriteRuleMap -> Signature [_sigSections] :: Signature -> Sections [_sigDefinitions] :: Signature -> Definitions -- | The rewrite rules defined in this file. [_sigRewriteRules] :: Signature -> RewriteRuleMap -- | Which clause is an interaction point located in? data IPClause IPClause :: QName -> Int -> Type -> Maybe Substitution -> SpineClause -> Closure () -> [Closure IPBoundary] -> IPClause -- | The name of the function. [ipcQName] :: IPClause -> QName -- | The number of the clause of this function. [ipcClauseNo] :: IPClause -> Int -- | The type of the function [ipcType] :: IPClause -> Type -- | Module parameter substitution [ipcWithSub] :: IPClause -> Maybe Substitution -- | The original AST clause. [ipcClause] :: IPClause -> SpineClause -- | Environment for rechecking the clause. [ipcClosure] :: IPClause -> Closure () -- | The boundary imposed by the LHS. [ipcBoundary] :: IPClause -> [Closure IPBoundary] -- | The interaction point is not in the rhs of a clause. IPNoClause :: IPClause type IPBoundary = IPBoundary' Term -- | Flag to indicate whether the meta is overapplied in the constraint. A -- meta is overapplied if it has more arguments than the size of the -- telescope in its creation environment (as stored in MetaInfo). data Overapplied Overapplied :: Overapplied NotOverapplied :: Overapplied -- | Data structure managing the interaction points. -- -- We never remove interaction points from this map, only set their -- ipSolved to True. (Issue #2368) type InteractionPoints = BiMap InteractionId InteractionPoint -- | Interaction points are created by the scope checker who sets the -- range. The meta variable is created by the type checker and then -- hooked up to the interaction point. data InteractionPoint InteractionPoint :: Range -> Maybe MetaId -> Bool -> IPClause -> InteractionPoint -- | The position of the interaction point. [ipRange] :: InteractionPoint -> Range -- | The meta variable, if any, holding the type etc. [ipMeta] :: InteractionPoint -> Maybe MetaId -- | Has this interaction point already been solved? [ipSolved] :: InteractionPoint -> Bool -- | The clause of the interaction point (if any). Used for case splitting. [ipClause] :: InteractionPoint -> IPClause -- | Used for meta-variables from other modules (and in Interfaces). type RemoteMetaStore = HashMap MetaId RemoteMetaVariable -- | Used for meta-variables from the current module. type LocalMetaStore = Map MetaId MetaVariable -- | Name suggestion for meta variable. Empty string means no suggestion. type MetaNameSuggestion = String -- | MetaInfo is cloned from one meta to the next during pruning. data MetaInfo MetaInfo :: Closure Range -> Modality -> RunMetaOccursCheck -> MetaNameSuggestion -> Arg DoGeneralize -> MetaInfo [miClosRange] :: MetaInfo -> Closure Range -- | Instantiable with irrelevant/erased solution? [miModality] :: MetaInfo -> Modality -- | Run the extended occurs check that goes in definitions? [miMetaOccursCheck] :: MetaInfo -> RunMetaOccursCheck -- | Used for printing. Just x if meta-variable comes from omitted -- argument with name x. [miNameSuggestion] :: MetaInfo -> MetaNameSuggestion -- | Should this meta be generalized if unsolved? If so, at what ArgInfo? [miGeneralizable] :: MetaInfo -> Arg DoGeneralize data RunMetaOccursCheck RunMetaOccursCheck :: RunMetaOccursCheck DontRunMetaOccursCheck :: RunMetaOccursCheck -- | Meta variable priority: When we have an equation between -- meta-variables, which one should be instantiated? -- -- Higher value means higher priority to be instantiated. newtype MetaPriority MetaPriority :: Int -> MetaPriority data TypeCheckingProblem CheckExpr :: Comparison -> Expr -> Type -> TypeCheckingProblem CheckArgs :: Comparison -> ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> (ArgsCheckState CheckedTarget -> TCM Term) -> TypeCheckingProblem CheckProjAppToKnownPrincipalArg :: Comparison -> Expr -> ProjOrigin -> List1 QName -> Args -> Type -> Int -> Term -> Type -> PrincipalArgTypeMetas -> TypeCheckingProblem -- | (λ (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. CheckLambda :: Comparison -> Arg (List1 (WithHiding Name), Maybe Type) -> Expr -> Type -> TypeCheckingProblem -- | Quote the given term and check type against Term DoQuoteTerm :: Comparison -> Term -> Type -> TypeCheckingProblem data PrincipalArgTypeMetas PrincipalArgTypeMetas :: Args -> Type -> PrincipalArgTypeMetas -- | metas created for hidden and instance arguments in the principal -- argument's type [patmMetas] :: PrincipalArgTypeMetas -> Args -- | principal argument's type, stripped of hidden and instance arguments [patmRemainder] :: PrincipalArgTypeMetas -> Type -- | Solving a CheckArgs constraint may or may not check the target -- type. If it did, it returns a handle to any unsolved constraints. data CheckedTarget CheckedTarget :: Maybe ProblemId -> CheckedTarget NotCheckedTarget :: CheckedTarget -- | Information about remote meta-variables. -- -- Remote meta-variables are meta-variables originating in other modules. -- These meta-variables are always instantiated. We do not retain all the -- information about a local meta-variable when creating an interface: -- -- data RemoteMetaVariable RemoteMetaVariable :: Instantiation -> Modality -> Judgement MetaId -> RemoteMetaVariable [rmvInstantiation] :: RemoteMetaVariable -> Instantiation [rmvModality] :: RemoteMetaVariable -> Modality [rmvJudgement] :: RemoteMetaVariable -> Judgement MetaId -- | Meta-variable instantiations. data Instantiation Instantiation :: [Arg String] -> Term -> Instantiation -- | The solution is abstracted over these free variables. [instTel] :: Instantiation -> [Arg String] -- | The body of the solution. [instBody] :: Instantiation -> Term data MetaInstantiation -- | solved InstV :: Instantiation -> MetaInstantiation -- | unsolved Open :: MetaInstantiation -- | open, to be instantiated by instance search OpenInstance :: MetaInstantiation -- | solution blocked by unsolved constraints BlockedConst :: Term -> MetaInstantiation PostponedTypeCheckingProblem :: Closure TypeCheckingProblem -> MetaInstantiation -- | Frozen meta variable cannot be instantiated by unification. This -- serves to prevent the completion of a definition by its use outside of -- the current block. (See issues 118, 288, 399). data Frozen -- | Do not instantiate. Frozen :: Frozen Instantiable :: Frozen data Listener EtaExpand :: MetaId -> Listener CheckConstraint :: Nat -> ProblemConstraint -> Listener -- | Information about local meta-variables. data MetaVariable MetaVar :: MetaInfo -> MetaPriority -> Permutation -> Judgement MetaId -> MetaInstantiation -> Set Listener -> Frozen -> Maybe MetaId -> MetaVariable [mvInfo] :: MetaVariable -> MetaInfo -- | some metavariables are more eager to be instantiated [mvPriority] :: MetaVariable -> MetaPriority -- | 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 [mvPermutation] :: MetaVariable -> Permutation [mvJudgement] :: MetaVariable -> Judgement MetaId [mvInstantiation] :: MetaVariable -> MetaInstantiation -- | meta variables scheduled for eta-expansion but blocked by this one [mvListeners] :: MetaVariable -> Set Listener -- | are we past the point where we can instantiate this meta variable? [mvFrozen] :: MetaVariable -> Frozen -- | Just m means that this meta-variable will be equated to -- m when the latter is unblocked. See -- blockTermOnProblem. [mvTwin] :: MetaVariable -> Maybe MetaId -- | The value of a generalizable variable. This is created to be a -- generalizable meta before checking the type to be generalized. data GeneralizedValue GeneralizedValue :: CheckpointId -> Term -> Type -> GeneralizedValue [genvalCheckpoint] :: GeneralizedValue -> CheckpointId [genvalTerm] :: GeneralizedValue -> Term [genvalType] :: GeneralizedValue -> Type data DoGeneralize -- | Generalize because it is a generalizable variable. YesGeneralizeVar :: DoGeneralize -- | Generalize because it is a metavariable and we're currently checking -- the type of a generalizable variable (this should get the default -- modality). YesGeneralizeMeta :: DoGeneralize -- | Don't generalize. NoGeneralize :: DoGeneralize -- | Parametrized since it is used without MetaId when creating a new meta. data Judgement a HasType :: a -> Comparison -> Type -> Judgement a [jMetaId] :: Judgement a -> a -- | are we checking (CmpLeq) or inferring (CmpEq) the -- type? [jComparison] :: Judgement a -> Comparison [jMetaType] :: Judgement a -> Type IsSort :: a -> Type -> Judgement a [jMetaId] :: Judgement a -> a [jMetaType] :: Judgement a -> Type -- | A thing tagged with the context it came from. Also keeps the -- substitution from previous checkpoints. This lets us handle the case -- when an open thing was created in a context that we have since exited. -- Remember which module it's from to make sure we don't get confused by -- checkpoints from other files. data Open a OpenThing :: CheckpointId -> Map CheckpointId Substitution -> ModuleNameHash -> a -> Open a [openThingCheckpoint] :: Open a -> CheckpointId [openThingCheckpointMap] :: Open a -> Map CheckpointId Substitution [openThingModule] :: Open a -> ModuleNameHash [openThing] :: Open a -> a -- | We can either compare two terms at a given type, or compare two types -- without knowing (or caring about) their sorts. data CompareAs -- | Type should not be Size. But currently, we do not -- rely on this invariant. AsTermsOf :: Type -> CompareAs -- | Replaces AsTermsOf Size. AsSizes :: CompareAs AsTypes :: CompareAs -- | An extension of Comparison to >=. data CompareDirection DirEq :: CompareDirection DirLeq :: CompareDirection DirGeq :: CompareDirection data Constraint ValueCmp :: Comparison -> CompareAs -> Term -> Term -> Constraint ValueCmpOnFace :: Comparison -> Term -> Type -> Term -> Term -> Constraint ElimCmp :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> Constraint SortCmp :: Comparison -> Sort -> Sort -> Constraint LevelCmp :: Comparison -> Level -> Level -> Constraint HasBiggerSort :: Sort -> Constraint HasPTSRule :: Dom Type -> Abs Sort -> Constraint -- | Check that the sort Term of data type QName admits -- data/record types. E.g., sorts IUniv, SizeUniv etc. -- do not admit such constructions. See checkDataSort. CheckDataSort :: QName -> Sort -> Constraint CheckMetaInst :: MetaId -> Constraint CheckType :: Type -> Constraint -- | Meta created for a term blocked by a postponed type checking problem -- or unsolved constraints. The MetaInstantiation for the meta -- (when unsolved) is either BlockedConst or -- PostponedTypeCheckingProblem. UnBlock :: MetaId -> Constraint -- | The range is the one of the absurd pattern. IsEmpty :: Range -> Type -> Constraint -- | Check that the Term is either not a SIZELT or a non-empty -- SIZELT. CheckSizeLtSat :: Term -> Constraint -- | the first argument is the instance argument and the second one is the -- list of candidates (or Nothing if we haven’t determined the list of -- candidates yet) FindInstance :: MetaId -> Maybe [Candidate] -> Constraint -- | Last argument is the error causing us to postpone. CheckFunDef :: Delayed -> DefInfo -> QName -> [Clause] -> TCErr -> Constraint -- | First argument is computation and the others are hole and goal type UnquoteTactic :: Term -> Term -> Type -> Constraint -- | CheckLockedVars t ty lk lk_ty with t : ty, lk : -- lk_ty and t lk well-typed. CheckLockedVars :: Term -> Type -> Arg Term -> Type -> Constraint -- | Is the term usable at the given modality? This check should run if the -- Sort is Nothing or isFibrant. UsableAtModality :: WhyCheckModality -> Maybe Sort -> Modality -> Term -> Constraint -- | Why are we performing a modality check? data WhyCheckModality -- | Because --without-K is enabled, so the types of data constructors must -- be usable at the context's modality. ConstructorType :: WhyCheckModality -- | Because --without-K is enabled, so the result type of clauses must be -- usable at the context's modality. IndexedClause :: WhyCheckModality -- | Because --without-K is enabled, so any argument (second name) which -- mentions a dotted argument (first name) must have a type which is -- usable at the context's modality. IndexedClauseArg :: Name -> Name -> WhyCheckModality -- | Because we double-check the --cubical-compatible clauses. This is an -- internal error! GeneratedClause :: WhyCheckModality data ProblemConstraint PConstr :: Set ProblemId -> Blocker -> Closure Constraint -> ProblemConstraint [constraintProblems] :: ProblemConstraint -> Set ProblemId [constraintUnblocker] :: ProblemConstraint -> Blocker [theConstraint] :: ProblemConstraint -> Closure Constraint type Constraints = [ProblemConstraint] class LensClosure a b | b -> a lensClosure :: LensClosure a b => Lens' (Closure a) b data Closure a Closure :: Signature -> TCEnv -> ScopeInfo -> Map ModuleName CheckpointId -> a -> Closure a [clSignature] :: Closure a -> Signature [clEnv] :: Closure a -> TCEnv [clScope] :: Closure a -> ScopeInfo [clModuleCheckpoints] :: Closure a -> Map ModuleName CheckpointId [clValue] :: Closure a -> a data Interface Interface :: Hash -> Text -> FileType -> [(TopLevelModuleName, Hash)] -> ModuleName -> TopLevelModuleName -> Map ModuleName Scope -> ScopeInfo -> Signature -> RemoteMetaStore -> DisplayForms -> Map QName Text -> Maybe Text -> BuiltinThings (String, QName) -> Map BackendName [ForeignCode] -> HighlightingInfo -> [OptionsPragma] -> [OptionsPragma] -> PragmaOptions -> PatternSynDefns -> [TCWarning] -> Set QName -> Interface -- | Hash of the source code. [iSourceHash] :: Interface -> Hash -- | 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. [iSource] :: Interface -> Text -- | Source file type, determined from the file extension [iFileType] :: Interface -> FileType -- | Imported modules and their hashes. [iImportedModules] :: Interface -> [(TopLevelModuleName, Hash)] -- | Module name of this interface. [iModuleName] :: Interface -> ModuleName -- | The module's top-level module name. [iTopLevelModuleName] :: Interface -> TopLevelModuleName -- | 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. [iScope] :: Interface -> Map ModuleName Scope -- | Scope after we loaded this interface. Used in AtTopLevel and -- interactionLoop. [iInsideScope] :: Interface -> ScopeInfo [iSignature] :: Interface -> Signature -- | Instantiations for meta-variables that come from this module. [iMetaBindings] :: Interface -> RemoteMetaStore -- | Display forms added for imported identifiers. [iDisplayForms] :: Interface -> DisplayForms -- | User warnings for imported identifiers [iUserWarnings] :: Interface -> Map QName Text -- | Whether this module should raise a warning when imported [iImportWarning] :: Interface -> Maybe Text [iBuiltin] :: Interface -> BuiltinThings (String, QName) [iForeignCode] :: Interface -> Map BackendName [ForeignCode] [iHighlighting] :: Interface -> HighlightingInfo -- | Pragma options set in library files. [iDefaultPragmaOptions] :: Interface -> [OptionsPragma] -- | Pragma options set in the file. [iFilePragmaOptions] :: Interface -> [OptionsPragma] -- | Options/features used when checking the file (can be different from -- options set directly in the file). [iOptionsUsed] :: Interface -> PragmaOptions [iPatternSyns] :: Interface -> PatternSynDefns [iWarnings] :: Interface -> [TCWarning] [iPartialDefs] :: Interface -> Set QName data ForeignCode ForeignCode :: Range -> String -> ForeignCode type DecodedModules = Map TopLevelModuleName ModuleInfo type VisitedModules = Map TopLevelModuleName ModuleInfo data ModuleInfo ModuleInfo :: Interface -> [TCWarning] -> Bool -> ModuleCheckMode -> ModuleInfo [miInterface] :: ModuleInfo -> Interface -- | Warnings were encountered when the module was type checked. These -- might include warnings not stored in the interface itself, -- specifically unsolved interaction metas. See -- Agda.Interaction.Imports [miWarnings] :: ModuleInfo -> [TCWarning] -- | True if the module is a primitive module, which should always -- be importable. [miPrimitive] :: ModuleInfo -> Bool -- | The ModuleCheckMode used to create the Interface [miMode] :: ModuleInfo -> ModuleCheckMode -- | Distinguishes between type-checked and scope-checked interfaces when -- stored in the map of VisitedModules. data ModuleCheckMode ModuleScopeChecked :: ModuleCheckMode ModuleTypeChecked :: ModuleCheckMode -- | A monad that has read and write access to the stConcreteNames part of -- the TCState. Basically, this is a synonym for `MonadState -- ConcreteNames m` (which cannot be used directly because of the -- limitations of Haskell's typeclass system). class Monad m => MonadStConcreteNames m runStConcreteNames :: MonadStConcreteNames m => StateT ConcreteNames m a -> m a useConcreteNames :: MonadStConcreteNames m => m ConcreteNames modifyConcreteNames :: MonadStConcreteNames m => (ConcreteNames -> ConcreteNames) -> m () -- | Create a fresh name from a. class FreshName a freshName_ :: (FreshName a, MonadFresh NameId m) => a -> m Name newtype CheckpointId CheckpointId :: Int -> CheckpointId class Monad m => MonadFresh i m fresh :: MonadFresh i m => m i fresh :: (MonadFresh i m, MonadTrans t, MonadFresh i n, t n ~ m) => m i class Enum i => HasFresh i freshLens :: HasFresh i => Lens' i TCState nextFresh' :: HasFresh i => i -> i -- | A complete log for a module will look like this: -- -- data TypeCheckAction EnterSection :: !ModuleName -> !Telescope -> TypeCheckAction LeaveSection :: !ModuleName -> TypeCheckAction -- | Never a Section or ScopeDecl Decl :: !Declaration -> TypeCheckAction Pragmas :: !PragmaOptions -> TypeCheckAction -- | Like CachedTypeCheckLog, but storing the log for an ongoing -- type checking of a module. Stored in reverse order (last performed -- action first). type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)] -- | A log of what the type checker does and states after the action is -- completed. The cached version is stored first executed action first. type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)] data LoadedFileCache LoadedFileCache :: !CachedTypeCheckLog -> !CurrentTypeCheckLog -> LoadedFileCache [lfcCached] :: LoadedFileCache -> !CachedTypeCheckLog [lfcCurrent] :: LoadedFileCache -> !CurrentTypeCheckLog -- | A part of the state which is not reverted when an error is thrown or -- the state is reset. data PersistentTCState PersistentTCSt :: !DecodedModules -> !BiMap RawTopLevelModuleName ModuleNameHash -> CommandLineOptions -> InteractionOutputCallback -> !Benchmark -> !Statistics -> !Maybe LoadedFileCache -> [Backend] -> PersistentTCState [stDecodedModules] :: PersistentTCState -> !DecodedModules -- | Module name hashes for top-level module names (and vice versa). [stPersistentTopLevelModuleNames] :: PersistentTCState -> !BiMap RawTopLevelModuleName ModuleNameHash [stPersistentOptions] :: PersistentTCState -> CommandLineOptions -- | Callback function to call when there is a response to give to the -- interactive frontend. See the documentation of -- InteractionOutputCallback. [stInteractionOutputCallback] :: PersistentTCState -> InteractionOutputCallback -- | Structure to track how much CPU time was spent on which Agda phase. -- Needs to be a strict field to avoid space leaks! [stBenchmark] :: PersistentTCState -> !Benchmark -- | Should be strict field. [stAccumStatistics] :: PersistentTCState -> !Statistics -- | Cached typechecking state from the last loaded file. Should be -- Nothing when checking imports. [stPersistLoadedFileCache] :: PersistentTCState -> !Maybe LoadedFileCache -- | Current backends with their options [stPersistBackends] :: PersistentTCState -> [Backend] -- | A mutual block of names in the signature. data MutualBlock MutualBlock :: MutualInfo -> Set QName -> MutualBlock -- | The original info of the mutual block. [mutualInfo] :: MutualBlock -> MutualInfo [mutualNames] :: MutualBlock -> Set QName data PostScopeState PostScopeState :: !HighlightingInfo -> !DisambiguatedNames -> !LocalMetaStore -> !LocalMetaStore -> !InteractionPoints -> !Constraints -> !Constraints -> !Bool -> !Set QName -> !Signature -> !Map ModuleName CheckpointId -> !DisplayForms -> !Maybe (ModuleName, TopLevelModuleName) -> !TempInstanceTable -> !ConcreteNames -> !Map RawName (DList RawName) -> !Map Name (DList RawName) -> !Statistics -> ![TCWarning] -> !Map MutualId MutualBlock -> !BuiltinThings PrimFun -> !MetaId -> !MutualId -> !ProblemId -> !CheckpointId -> !Int -> !NameId -> !Bool -> !Bool -> !Bool -> !Bool -> !Set QName -> PostScopeState -- | Highlighting info. [stPostSyntaxInfo] :: PostScopeState -> !HighlightingInfo -- | 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. [stPostDisambiguatedNames] :: PostScopeState -> !DisambiguatedNames -- | Used for open meta-variables. [stPostOpenMetaStore] :: PostScopeState -> !LocalMetaStore -- | Used for local, instantiated meta-variables. [stPostSolvedMetaStore] :: PostScopeState -> !LocalMetaStore [stPostInteractionPoints] :: PostScopeState -> !InteractionPoints [stPostAwakeConstraints] :: PostScopeState -> !Constraints [stPostSleepingConstraints] :: PostScopeState -> !Constraints -- | Dirty when a constraint is added, used to prevent pointer update. -- Currently unused. [stPostDirty] :: PostScopeState -> !Bool -- | 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. [stPostOccursCheckDefs] :: PostScopeState -> !Set QName -- | Declared identifiers of the current file. These will be serialized -- after successful type checking. [stPostSignature] :: PostScopeState -> !Signature -- | For each module remember the checkpoint corresponding to the orignal -- context of the module parameters. [stPostModuleCheckpoints] :: PostScopeState -> !Map ModuleName CheckpointId -- | Display forms we add for imported identifiers [stPostImportsDisplayForms] :: PostScopeState -> !DisplayForms -- | The current module is available after it has been type checked. [stPostCurrentModule] :: PostScopeState -> !Maybe (ModuleName, TopLevelModuleName) [stPostInstanceDefs] :: PostScopeState -> !TempInstanceTable -- | Map keeping track of concrete names assigned to each abstract name -- (can be more than one name in case the first one is shadowed) [stPostConcreteNames] :: PostScopeState -> !ConcreteNames -- | 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. [stPostUsedNames] :: PostScopeState -> !Map RawName (DList RawName) -- | Map keeping track for each (abstract) name the list of all (raw) names -- that it could maybe be shadowed by. [stPostShadowingNames] :: PostScopeState -> !Map Name (DList RawName) -- | Counters to collect various statistics about meta variables etc. Only -- for current file. [stPostStatistics] :: PostScopeState -> !Statistics [stPostTCWarnings] :: PostScopeState -> ![TCWarning] [stPostMutualBlocks] :: PostScopeState -> !Map MutualId MutualBlock [stPostLocalBuiltins] :: PostScopeState -> !BuiltinThings PrimFun [stPostFreshMetaId] :: PostScopeState -> !MetaId [stPostFreshMutualId] :: PostScopeState -> !MutualId [stPostFreshProblemId] :: PostScopeState -> !ProblemId [stPostFreshCheckpointId] :: PostScopeState -> !CheckpointId [stPostFreshInt] :: PostScopeState -> !Int [stPostFreshNameId] :: PostScopeState -> !NameId [stPostAreWeCaching] :: PostScopeState -> !Bool [stPostPostponeInstanceSearch] :: PostScopeState -> !Bool [stPostConsideringInstance] :: PostScopeState -> !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. [stPostInstantiateBlocking] :: PostScopeState -> !Bool -- | Local partial definitions, to be stored in the Interface [stPostLocalPartialDefs] :: PostScopeState -> !Set QName type ConcreteNames = Map Name [Name] type DisambiguatedNames = IntMap DisambiguatedName -- | Name disambiguation for the sake of highlighting. data DisambiguatedName DisambiguatedName :: NameKind -> QName -> DisambiguatedName data PreScopeState PreScopeState :: !HighlightingInfo -> !Signature -> !HashSet TopLevelModuleName -> !ModuleToSource -> !VisitedModules -> !ScopeInfo -> !PatternSynDefns -> !PatternSynDefns -> !Maybe (Set QName) -> !PragmaOptions -> !BuiltinThings PrimFun -> !DisplayForms -> !InstanceTable -> !Map BackendName [ForeignCode] -> !InteractionId -> !Map QName Text -> !Map QName Text -> !Maybe Text -> !Set QName -> !Map FilePath ProjectConfig -> !Map FilePath AgdaLibFile -> !RemoteMetaStore -> PreScopeState -- | Highlighting info for tokens and Happy parser warnings (but not for -- those tokens/warnings for which highlighting exists in -- stPostSyntaxInfo). [stPreTokens] :: PreScopeState -> !HighlightingInfo -- | Imported declared identifiers. Those most not be serialized! [stPreImports] :: PreScopeState -> !Signature -- | The top-level modules imported by the current module. [stPreImportedModules] :: PreScopeState -> !HashSet TopLevelModuleName [stPreModuleToSource] :: PreScopeState -> !ModuleToSource [stPreVisitedModules] :: PreScopeState -> !VisitedModules [stPreScope] :: PreScopeState -> !ScopeInfo -- | Pattern synonyms of the current file. Serialized. [stPrePatternSyns] :: PreScopeState -> !PatternSynDefns -- | Imported pattern synonyms. Must not be serialized! [stPrePatternSynImports] :: PreScopeState -> !PatternSynDefns -- | Collected generalizable variables; used during scope checking of terms [stPreGeneralizedVars] :: PreScopeState -> !Maybe (Set QName) -- | Options applying to the current file. OPTIONS pragmas only -- affect this field. [stPrePragmaOptions] :: PreScopeState -> !PragmaOptions [stPreImportedBuiltins] :: PreScopeState -> !BuiltinThings PrimFun -- | Display forms added by someone else to imported identifiers [stPreImportedDisplayForms] :: PreScopeState -> !DisplayForms [stPreImportedInstanceDefs] :: PreScopeState -> !InstanceTable -- | {-# FOREIGN #-} code that should be included in the compiled -- output. Does not include code for imported modules. [stPreForeignCode] :: PreScopeState -> !Map BackendName [ForeignCode] [stPreFreshInteractionId] :: PreScopeState -> !InteractionId -- | Imported UserWarnings, not to be stored in the -- Interface [stPreImportedUserWarnings] :: PreScopeState -> !Map QName Text -- | Locally defined UserWarnings, to be stored in the -- Interface [stPreLocalUserWarnings] :: PreScopeState -> !Map QName Text -- | Whether the current module should raise a warning when opened [stPreWarningOnImport] :: PreScopeState -> !Maybe Text -- | Imported partial definitions, not to be stored in the -- Interface [stPreImportedPartialDefs] :: PreScopeState -> !Set QName -- | Map from directories to paths of closest enclosing .agda-lib files (or -- Nothing if there are none). [stPreProjectConfigs] :: PreScopeState -> !Map FilePath ProjectConfig -- | Contents of .agda-lib files that have already been parsed. [stPreAgdaLibFiles] :: PreScopeState -> !Map FilePath AgdaLibFile -- | Used for meta-variables from other modules. [stPreImportedMetaStore] :: PreScopeState -> !RemoteMetaStore class Monad m => ReadTCState m getTCState :: ReadTCState m => m TCState locallyTCState :: ReadTCState m => Lens' a TCState -> (a -> a) -> m b -> m b withTCState :: ReadTCState m => (TCState -> TCState) -> m a -> m a getTCState :: (ReadTCState m, MonadTrans t, ReadTCState n, t n ~ m) => m TCState locallyTCState :: (ReadTCState m, MonadTransControl t, ReadTCState n, t n ~ m) => Lens' a TCState -> (a -> a) -> m b -> m b pattern PrimitiveSort :: String -> Sort -> Defn primSortName :: Defn -> String primSortSort :: Defn -> Sort pattern Primitive :: IsAbstract -> String -> [Clause] -> FunctionInverse -> Maybe CompiledClauses -> Defn primAbstr :: Defn -> IsAbstract primName :: Defn -> String primClauses :: Defn -> [Clause] primInv :: Defn -> FunctionInverse primCompiled :: Defn -> Maybe CompiledClauses pattern Constructor :: Int -> Int -> ConHead -> QName -> IsAbstract -> Induction -> CompKit -> Maybe [QName] -> [IsForced] -> Maybe [Bool] -> Defn conPars :: Defn -> Int conArity :: Defn -> Int conSrcCon :: Defn -> ConHead conData :: Defn -> QName conAbstr :: Defn -> IsAbstract conInd :: Defn -> Induction conComp :: Defn -> CompKit conProj :: Defn -> Maybe [QName] conForced :: Defn -> [IsForced] conErased :: Defn -> Maybe [Bool] pattern Record :: Nat -> Maybe Clause -> ConHead -> Bool -> [Dom QName] -> Telescope -> Maybe [QName] -> EtaEquality -> PatternOrCopattern -> Maybe Induction -> Maybe Bool -> IsAbstract -> CompKit -> Defn recPars :: Defn -> Nat recClause :: Defn -> Maybe Clause recConHead :: Defn -> ConHead recNamedCon :: Defn -> Bool recFields :: Defn -> [Dom QName] recTel :: Defn -> Telescope recMutual :: Defn -> Maybe [QName] recEtaEquality' :: Defn -> EtaEquality recPatternMatching :: Defn -> PatternOrCopattern recInduction :: Defn -> Maybe Induction recTerminates :: Defn -> Maybe Bool recAbstr :: Defn -> IsAbstract recComp :: Defn -> CompKit pattern Datatype :: Nat -> Nat -> Maybe Clause -> [QName] -> Sort -> Maybe [QName] -> IsAbstract -> [QName] -> Maybe QName -> Maybe QName -> Defn dataPars :: Defn -> Nat dataIxs :: Defn -> Nat dataClause :: Defn -> Maybe Clause dataCons :: Defn -> [QName] dataSort :: Defn -> Sort dataMutual :: Defn -> Maybe [QName] dataAbstr :: Defn -> IsAbstract dataPathCons :: Defn -> [QName] dataTranspIx :: Defn -> Maybe QName dataTransp :: Defn -> Maybe QName pattern Function :: [Clause] -> Maybe CompiledClauses -> Maybe SplitTree -> Maybe Compiled -> [Clause] -> FunctionInverse -> Maybe [QName] -> IsAbstract -> Delayed -> Either ProjectionLikenessMissing Projection -> Set FunctionFlag -> Maybe Bool -> Maybe ExtLamInfo -> Maybe QName -> Maybe QName -> Defn funClauses :: Defn -> [Clause] funCompiled :: Defn -> Maybe CompiledClauses funSplitTree :: Defn -> Maybe SplitTree funTreeless :: Defn -> Maybe Compiled funCovering :: Defn -> [Clause] funInv :: Defn -> FunctionInverse funMutual :: Defn -> Maybe [QName] funAbstr :: Defn -> IsAbstract funDelayed :: Defn -> Delayed funProjection :: Defn -> Either ProjectionLikenessMissing Projection funFlags :: Defn -> Set FunctionFlag funTerminates :: Defn -> Maybe Bool funExtLam :: Defn -> Maybe ExtLamInfo funWith :: Defn -> Maybe QName funIsKanOp :: Defn -> Maybe QName pattern DataOrRecSig :: Int -> Defn datarecPars :: Defn -> Int pattern Axiom :: Bool -> Defn axiomConstTransp :: Defn -> Bool -- | Empty persistent state. initPersistentState :: PersistentTCState -- | An initial MetaId. initialMetaId :: MetaId -- | Empty state of type checker. initPreScopeState :: PreScopeState initPostScopeState :: PostScopeState initState :: TCState stTokens :: Lens' HighlightingInfo TCState stImports :: Lens' Signature TCState stImportedModules :: Lens' (HashSet TopLevelModuleName) TCState stModuleToSource :: Lens' ModuleToSource TCState stVisitedModules :: Lens' VisitedModules TCState stScope :: Lens' ScopeInfo TCState stPatternSyns :: Lens' PatternSynDefns TCState stPatternSynImports :: Lens' PatternSynDefns TCState stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState stPragmaOptions :: Lens' PragmaOptions TCState stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState stFreshInteractionId :: Lens' InteractionId TCState stImportedUserWarnings :: Lens' (Map QName Text) TCState stLocalUserWarnings :: Lens' (Map QName Text) TCState getUserWarnings :: ReadTCState m => m (Map QName Text) stWarningOnImport :: Lens' (Maybe Text) TCState stImportedPartialDefs :: Lens' (Set QName) TCState stLocalPartialDefs :: Lens' (Set QName) TCState getPartialDefs :: ReadTCState m => m (Set QName) stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState stBackends :: Lens' [Backend] TCState stProjectConfigs :: Lens' (Map FilePath ProjectConfig) TCState stAgdaLibFiles :: Lens' (Map FilePath AgdaLibFile) TCState stTopLevelModuleNames :: Lens' (BiMap RawTopLevelModuleName ModuleNameHash) TCState stImportedMetaStore :: Lens' RemoteMetaStore TCState stFreshNameId :: Lens' NameId TCState stSyntaxInfo :: Lens' HighlightingInfo TCState stDisambiguatedNames :: Lens' DisambiguatedNames TCState stOpenMetaStore :: Lens' LocalMetaStore TCState stSolvedMetaStore :: Lens' LocalMetaStore 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 -- | Note that the lens is "strict". stCurrentModule :: Lens' (Maybe (ModuleName, TopLevelModuleName)) TCState stImportedInstanceDefs :: Lens' InstanceTable TCState stInstanceDefs :: Lens' TempInstanceTable TCState stConcreteNames :: Lens' ConcreteNames TCState stUsedNames :: Lens' (Map RawName (DList RawName)) TCState stShadowingNames :: Lens' (Map Name (DList 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 -- | Union two Builtins. Only defined for -- BuiltinRewriteRelations. unionBuiltin :: Builtin a -> Builtin a -> Builtin a 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 -- | Combines the source hash and the (full) hashes of the imported -- modules. iFullHash :: Interface -> Hash -- | A lens for the iSignature field of the Interface type. intSignature :: Lens' Signature Interface buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a) -- | Embed Comparison into CompareDirection. fromCmp :: Comparison -> CompareDirection -- | Flip the direction of comparison. flipCmp :: CompareDirection -> CompareDirection -- | Turn a Comparison function into a CompareDirection -- function. -- -- Property: dirToCmp f (fromCmp cmp) = f cmp dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c normalMetaPriority :: MetaPriority lowMetaPriority :: MetaPriority highMetaPriority :: MetaPriority getMetaInfo :: MetaVariable -> Closure Range getMetaScope :: MetaVariable -> ScopeInfo getMetaEnv :: MetaVariable -> TCEnv getMetaSig :: MetaVariable -> Signature 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 -- | By default, we have no display form. defaultDisplayForm :: QName -> [LocalDisplayForm] lensTheDef :: Lens' Defn Definition -- | Create a definition with sensible defaults. defaultDefn :: ArgInfo -> QName -> Type -> Language -> Defn -> Definition jsBackendName :: BackendName ghcBackendName :: BackendName noCompiledRep :: CompiledRepresentation modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo -- | Building the projection function (which drops the parameters). projDropPars :: Projection -> ProjOrigin -> Term -- | The info of the principal (record) argument. projArgInfo :: Projection -> ArgInfo -- | Make sure we do not overwrite a user specification. setEtaEquality :: EtaEquality -> HasEta -> EtaEquality emptyCompKit :: CompKit defaultAxiom :: Defn constTranspAxiom :: Defn lensFunction :: Lens' FunctionData Defn lensConstructor :: Lens' ConstructorData Defn lensRecord :: Lens' RecordData Defn lensRecTel :: Lens' Telescope RecordData -- | Is the record type recursive? recRecursive :: Defn -> Bool recEtaEquality :: Defn -> HasEta -- | A template for creating Function definitions, with sensible -- defaults. emptyFunctionData :: FunctionData emptyFunction :: Defn funFlag :: FunctionFlag -> Lens' Bool Defn funStatic :: Lens' Bool Defn funInline :: Lens' Bool Defn funMacro :: Lens' Bool Defn isMacro :: Defn -> Bool -- | Checking whether we are dealing with a function yet to be defined. isEmptyFunction :: Defn -> Bool isCopatternLHS :: [Clause] -> Bool recCon :: Defn -> QName defIsRecord :: Defn -> Bool defIsDataOrRecord :: Defn -> Bool defConstructors :: Defn -> [QName] redReturn :: a -> ReduceM (Reduced a' a) -- | Conceptually: redBind m f k = either (return . Left . f) k -- =<< m redBind :: ReduceM (Reduced a a') -> (a -> b) -> (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b') notReduced :: a -> MaybeReduced a reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term) -- | Not quite all reductions (skip non-terminating reductions) allReductions :: AllowedReductions reallyAllReductions :: AllowedReductions reduceAllDefs :: ReduceDefs locallyReduceDefs :: MonadTCEnv m => ReduceDefs -> m a -> m a locallyReduceAllDefs :: MonadTCEnv m => m a -> m a shouldReduceDef :: MonadTCEnv m => QName -> m Bool locallyReconstructed :: MonadTCEnv m => m a -> m a isReconstructed :: MonadTCEnv m => m Bool primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun defClauses :: Definition -> [Clause] defCompiled :: Definition -> Maybe CompiledClauses defParameters :: Definition -> Maybe Nat defInverse :: Definition -> FunctionInverse defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma] -- | Are the clauses of this definition delayed? defDelayed :: Definition -> Delayed -- | Has the definition failed the termination checker? defNonterminating :: Definition -> Bool -- | Has the definition not termination checked or did the check fail? defTerminationUnconfirmed :: Definition -> Bool defAbstract :: Definition -> IsAbstract defForced :: Definition -> [IsForced] -- | ifTopLevelAndHighlightingLevelIs l b m runs m when -- we're type-checking the top-level module (or before we've started -- doing this) and either the highlighting level is at least -- l or b is True. ifTopLevelAndHighlightingLevelIsOr :: MonadTCEnv tcm => HighlightingLevel -> Bool -> tcm () -> tcm () -- | ifTopLevelAndHighlightingLevelIs l m runs m when -- we're type-checking the top-level module (or before we've started -- doing this) and the highlighting level is at least l. ifTopLevelAndHighlightingLevelIs :: MonadTCEnv tcm => HighlightingLevel -> tcm () -> tcm () initEnv :: TCEnv defaultUnquoteFlags :: UnquoteFlags unquoteNormalise :: Lens' Bool UnquoteFlags eUnquoteNormalise :: Lens' Bool TCEnv eContext :: Lens' Context TCEnv eLetBindings :: Lens' LetBindings TCEnv eCurrentModule :: Lens' ModuleName TCEnv eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv eImportPath :: Lens' [TopLevelModuleName] TCEnv eMutualBlock :: Lens' (Maybe MutualId) TCEnv eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv eCoverageCheck :: Lens' CoverageCheck TCEnv eMakeCase :: Lens' Bool TCEnv eSolvingConstraints :: Lens' Bool TCEnv eCheckingWhere :: Lens' Bool TCEnv eWorkingOnTypes :: Lens' Bool TCEnv eAssignMetas :: Lens' Bool TCEnv eActiveProblems :: Lens' (Set ProblemId) TCEnv eAbstractMode :: Lens' AbstractMode TCEnv eModality :: Lens' Modality TCEnv eRelevance :: Lens' Relevance TCEnv eQuantity :: Lens' Quantity TCEnv eSplitOnStrict :: Lens' Bool TCEnv eDisplayFormsEnabled :: Lens' Bool TCEnv eRange :: Lens' Range TCEnv eHighlightingRange :: Lens' Range TCEnv eCall :: Lens' (Maybe (Closure Call)) TCEnv eHighlightingLevel :: Lens' HighlightingLevel TCEnv eHighlightingMethod :: Lens' HighlightingMethod TCEnv eExpandLast :: Lens' ExpandHidden TCEnv eAppDef :: Lens' (Maybe QName) TCEnv eSimplification :: Lens' Simplification TCEnv eAllowedReductions :: Lens' AllowedReductions TCEnv eReduceDefs :: Lens' ReduceDefs TCEnv eReconstructed :: Lens' Bool TCEnv eInjectivityDepth :: Lens' Int TCEnv eCompareBlocked :: Lens' Bool TCEnv ePrintDomainFreePi :: Lens' Bool TCEnv ePrintMetasBare :: Lens' Bool TCEnv eInsideDotPattern :: Lens' Bool TCEnv eUnquoteFlags :: Lens' UnquoteFlags TCEnv eInstanceDepth :: Lens' Int TCEnv eIsDebugPrinting :: Lens' Bool TCEnv ePrintingPatternLambdas :: Lens' [QName] TCEnv eCallByNeed :: Lens' Bool TCEnv eCurrentCheckpoint :: Lens' CheckpointId TCEnv eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv eGeneralizeMetas :: Lens' DoGeneralize TCEnv eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv eActiveBackendName :: Lens' (Maybe BackendName) TCEnv eConflComputingOverlap :: Lens' Bool TCEnv eCurrentlyElaborating :: Lens' Bool TCEnv aDefToMode :: IsAbstract -> AbstractMode aModeToDef :: AbstractMode -> Maybe IsAbstract isDontExpandLast :: ExpandHidden -> Bool recordFieldWarningToError :: RecordFieldWarning -> TypeError warningName :: Warning -> WarningName tcWarningOrigin :: TCWarning -> SrcFile sizedTypesOption :: HasOptions m => m Bool guardednessOption :: HasOptions m => m Bool withoutKOption :: HasOptions m => m Bool cubicalCompatibleOption :: HasOptions m => m Bool enableCaching :: HasOptions m => m Bool mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv -> ReduceEnv reduceEnv :: Lens' TCEnv ReduceEnv reduceSt :: Lens' TCState ReduceEnv onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b thenReduce :: ReduceM a -> ReduceM b -> ReduceM b beforeReduce :: ReduceM a -> ReduceM b -> ReduceM a bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b runReduceM :: ReduceM a -> TCM a runReduceF :: (a -> ReduceM b) -> TCM (a -> b) useR :: ReadTCState m => Lens' a TCState -> m a askR :: ReduceM ReduceEnv localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a -- | Modify the lens-indicated part of the TCEnv in a -- subcomputation. locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b getsTC :: ReadTCState m => (TCState -> a) -> m a -- | A variant of modifyTC in which the computation is strict in the -- new state. modifyTC' :: MonadTCState m => (TCState -> TCState) -> m () useTC :: ReadTCState m => Lens' a TCState -> m a -- | Overwrite the part of the TCState focused on by the lens. setTCLens :: MonadTCState m => Lens' a TCState -> a -> m () infix 4 `setTCLens` -- | Overwrite the part of the TCState focused on by the lens -- (strictly). setTCLens' :: MonadTCState m => Lens' a TCState -> a -> m () -- | Modify 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 -- (strictly). modifyTCLens' :: MonadTCState m => Lens' a TCState -> (a -> a) -> m () -- | Modify a part of the state monadically. modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m () -- | Modify the part of the TCState focused on by the lens, and -- return some result. stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r, a)) -> m r -- | Modify a part of the state monadically, and return some result. stateTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m (r, a)) -> m r runBlocked :: Monad m => BlockT m a -> m (Either Blocker a) mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a returnTCMT :: Applicative m => a -> TCMT m a bindTCMT :: Monad m => TCMT m a -> (a -> TCMT m b) -> TCMT m b thenTCMT :: Applicative m => TCMT m a -> TCMT m b -> TCMT m b fmapTCMT :: Functor m => (a -> b) -> TCMT m a -> TCMT m b apTCMT :: Applicative m => TCMT m (a -> b) -> TCMT m a -> TCMT m b -- | Preserve the state of the failing computation. catchError_ :: TCM a -> (TCErr -> TCM a) -> 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. finally_ :: TCM a -> TCM b -> TCM a internalError :: (HasCallStack, MonadTCM tcm) => String -> tcm a -- | Utility function for 1-arg constructed type errors. Note that the -- HasCallStack constraint is on the *resulting* function. locatedTypeError :: MonadTCError m => (a -> TypeError) -> HasCallStack => a -> m b genericError :: (HasCallStack, MonadTCError m) => String -> m a genericDocError :: (HasCallStack, MonadTCError m) => Doc -> m a typeError' :: MonadTCError m => CallStack -> TypeError -> m a typeError :: (HasCallStack, MonadTCError m) => TypeError -> m a typeError'_ :: (MonadTCEnv m, ReadTCState m) => CallStack -> TypeError -> m TCErr typeError_ :: (HasCallStack, MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr -- | Running the type checking monad (most general form). runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState) -- | Running the type checking monad on toplevel (with initial state). runTCMTop :: TCM a -> IO (Either TCErr a) runTCMTop' :: MonadIO m => TCMT m a -> m a -- | runSafeTCM runs a safe TCMT action (a TCMT action -- which cannot fail, except that it might raise IOExceptions) in -- the initial environment. runSafeTCM :: TCM a -> TCState -> IO (a, TCState) -- | Runs the given computation in a separate thread, with a copy of -- the current state and environment. -- -- Note that Agda sometimes uses actual, mutable state. If the -- computation given to forkTCM tries to modify this -- state, then bad things can happen, because accesses are not mutually -- exclusive. The forkTCM function has been added mainly to -- allow the thread to read (a snapshot of) the current state in a -- convenient way. -- -- Note also that exceptions which are raised in the thread are not -- propagated to the parent, so the thread should not do anything -- important. forkTCM :: TCM a -> TCM () -- | Base name for patterns in telescopes patternInTeleName :: String -- | Base name for extended lambda patterns extendedLambdaName :: String -- | Check whether we have an definition from an extended lambda. isExtendedLambdaName :: QName -> Bool -- | Name of absurdLambda definitions. absurdLambdaName :: String -- | Check whether we have an definition from an absurd lambda. isAbsurdLambdaName :: QName -> Bool -- | Base name for generalized variable projections generalizedFieldName :: String -- | Check whether we have a generalized variable field getGeneralizedFieldName :: QName -> Maybe String -- | Gets the include directories. -- -- Precondition: optAbsoluteIncludePaths must be nonempty (i.e. -- setCommandLineOptions must have run). getIncludeDirs :: HasOptions m => m [AbsolutePath] libToTCM :: LibM a -> TCM a class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m freshInteractionId :: MonadInteractionPoints m => m InteractionId freshInteractionId :: (MonadInteractionPoints m, MonadTrans t, MonadInteractionPoints n, t n ~ m) => m InteractionId modifyInteractionPoints :: MonadInteractionPoints m => (InteractionPoints -> InteractionPoints) -> m () modifyInteractionPoints :: (MonadInteractionPoints m, MonadTrans t, MonadInteractionPoints n, t n ~ m) => (InteractionPoints -> InteractionPoints) -> m () addImport :: TopLevelModuleName -> TCM () addImportCycleCheck :: TopLevelModuleName -> TCM a -> TCM a getImportPath :: TCM [TopLevelModuleName] visitModule :: ModuleInfo -> TCM () setVisitedModules :: VisitedModules -> TCM () getVisitedModules :: ReadTCState m => m VisitedModules getPrettyVisitedModules :: ReadTCState m => m Doc getVisitedModule :: ReadTCState m => TopLevelModuleName -> m (Maybe ModuleInfo) getDecodedModules :: TCM DecodedModules setDecodedModules :: DecodedModules -> TCM () getDecodedModule :: TopLevelModuleName -> TCM (Maybe ModuleInfo) storeDecodedModule :: ModuleInfo -> TCM () dropDecodedModule :: TopLevelModuleName -> TCM () withImportPath :: [TopLevelModuleName] -> TCM a -> TCM a -- | Assumes that the first module in the import path is the module we are -- worried about. checkForImportCycle :: TCM () -- | Get the name of the current module, if any. currentModule :: MonadTCEnv m => m ModuleName -- | Set the name of the current module. withCurrentModule :: MonadTCEnv m => ModuleName -> m a -> m a -- | Get the path of the currently checked file getCurrentPath :: MonadTCEnv m => m AbsolutePath -- | Get the number of variables bound by anonymous modules. getAnonymousVariables :: MonadTCEnv m => ModuleName -> m Nat -- | Add variables bound by an anonymous module. withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a -- | Set the current environment to the given withEnv :: MonadTCEnv m => TCEnv -> m a -> m a -- | Get the current environment getEnv :: TCM TCEnv -- | Set highlighting level withHighlightingLevel :: HighlightingLevel -> TCM a -> TCM a -- | Restore setting for ExpandLast to default. doExpandLast :: TCM a -> TCM a dontExpandLast :: TCM a -> TCM a reallyDontExpandLast :: TCM a -> TCM a -- | If the reduced did a proper match (constructor or literal pattern), -- then record this as simplification step. performedSimplification :: MonadTCEnv m => m a -> m a performedSimplification' :: MonadTCEnv m => Simplification -> m a -> m a getSimplification :: MonadTCEnv m => m Simplification -- | Lens for AllowedReductions. updateAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCEnv -> TCEnv modifyAllowedReductions :: MonadTCEnv m => (AllowedReductions -> AllowedReductions) -> m a -> m a putAllowedReductions :: MonadTCEnv m => AllowedReductions -> m a -> m a -- | Reduce Def f vs only if f is a projection. onlyReduceProjections :: MonadTCEnv m => m a -> m a -- | Allow all reductions except for non-terminating functions (default). allowAllReductions :: MonadTCEnv m => m a -> m a -- | Allow all reductions including non-terminating functions. allowNonTerminatingReductions :: MonadTCEnv m => m a -> m a -- | Allow all reductions when reducing types. Otherwise only allow inlined -- functions to be unfolded. onlyReduceTypes :: MonadTCEnv m => m a -> m a -- | Update allowed reductions when working on types typeLevelReductions :: MonadTCEnv m => m a -> m a insideDotPattern :: TCM a -> TCM a isInsideDotPattern :: TCM Bool -- | Don't use call-by-need evaluation for the given computation. callByName :: TCM a -> TCM a class MonadTCEnv m => MonadAddContext m -- | addCtx x arg cont add a variable to the context. -- -- Chooses an unused Name. -- -- Warning: Does not update module parameter substitution! addCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a -- | Add a let bound variable to the context addLetBinding' :: MonadAddContext m => Name -> Term -> Dom Type -> m a -> m a -- | Update the context. Requires a substitution that transports things -- living in the old context to the new. updateContext :: MonadAddContext m => Substitution -> (Context -> Context) -> m a -> m a withFreshName :: MonadAddContext m => Range -> ArgName -> (Name -> 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! addCtx :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Name -> Dom Type -> m a -> m a -- | Add a let bound variable to the context addLetBinding' :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Name -> Term -> Dom Type -> m a -> m a -- | Update the context. Requires a substitution that transports things -- living in the old context to the new. updateContext :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Substitution -> (Context -> Context) -> m a -> m a withFreshName :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Range -> ArgName -> (Name -> m a) -> m a -- | Get the substitution from the context at a given checkpoint to the -- current context. checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution class (Functor m, Applicative m, MonadFail m) => HasBuiltins m getBuiltinThing :: HasBuiltins m => String -> m (Maybe (Builtin PrimFun)) getBuiltinThing :: (HasBuiltins m, MonadTrans t, HasBuiltins n, t n ~ m) => String -> m (Maybe (Builtin PrimFun)) -- | 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. class TraceS a traceS :: (TraceS a, MonadDebug m) => VerboseKey -> VerboseLevel -> a -> m c -> m c -- | 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. class ReportS a reportS :: (ReportS a, MonadDebug m) => VerboseKey -> VerboseLevel -> a -> m () defaultGetVerbosity :: HasOptions m => m Verbosity defaultGetProfileOptions :: HasOptions m => m ProfileOptions defaultIsDebugPrinting :: MonadTCEnv m => m Bool defaultNowDebugPrinting :: MonadTCEnv m => m a -> m a -- | Print a debug message if switched on. displayDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () -- | During printing, catch internal errors of kind Impossible and -- print them. catchAndPrintImpossible :: (CatchImpossible m, Monad m) => VerboseKey -> VerboseLevel -> m String -> m String -- | Conditionally println debug string. reportSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () __IMPOSSIBLE_VERBOSE__ :: (HasCallStack, MonadDebug m) => String -> m a -- | Conditionally render debug Doc and print it. reportSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m () -- | Debug print the result of a computation. reportResult :: MonadDebug m => VerboseKey -> VerboseLevel -> (a -> TCM Doc) -> m a -> m a unlessDebugPrinting :: MonadDebug m => m () -> m () traceSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a -- | Conditionally render debug Doc, print it, and then continue. traceSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m a -> m a openVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () closeVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> m () closeVerboseBracketException :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -- | Check whether a certain verbosity level is activated. -- -- Precondition: The level must be non-negative. hasVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool -- | Check whether a certain verbosity level is activated (exact match). hasExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool -- | Run a computation if a certain verbosity level is activated (exact -- match). whenExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () __CRASH_WHEN__ :: (HasCallStack, MonadTCM m, MonadDebug m) => VerboseKey -> VerboseLevel -> m () -- | Run a computation if a certain verbosity level is activated. -- -- Precondition: The level must be non-negative. verboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () -- | Apply a function 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 -- | Check whether a certain profile option is activated. hasProfileOption :: MonadDebug m => ProfileOption -> m Bool -- | Run some code when the given profiling option is active. whenProfile :: MonadDebug m => ProfileOption -> m () -> m () class ReadTCState m => MonadStatistics m modifyCounter :: MonadStatistics m => String -> (Integer -> Integer) -> m () modifyCounter :: (MonadStatistics m, MonadStatistics n, MonadTrans t, t n ~ m) => String -> (Integer -> Integer) -> m () -- | Get the statistics. getStatistics :: ReadTCState m => m Statistics -- | Modify the statistics via given function. modifyStatistics :: (Statistics -> Statistics) -> TCM () -- | Increase specified counter by 1. tick :: MonadStatistics m => String -> m () -- | Increase specified counter by n. tickN :: MonadStatistics m => String -> Integer -> m () -- | Set the specified counter to the maximum of its current value and -- n. tickMax :: MonadStatistics m => String -> Integer -> m () -- | Print the given statistics. printStatistics :: (MonadDebug m, MonadTCEnv m, HasOptions m) => Maybe TopLevelModuleName -> Statistics -> m () class (Functor m, Applicative m, MonadFail m, HasOptions m, MonadDebug m, MonadTCEnv m) => HasConstInfo m -- | Lookup the definition of a name. The result is a closed thing, all -- free variables have been abstracted over. getConstInfo :: HasConstInfo m => QName -> m Definition -- | Version that reports exceptions: getConstInfo' :: HasConstInfo m => QName -> m (Either SigError Definition) -- | Lookup the rewrite rules with the given head symbol. getRewriteRulesFor :: HasConstInfo m => QName -> m RewriteRules -- | Version that reports exceptions: getConstInfo' :: (HasConstInfo m, HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m (Either SigError Definition) -- | Lookup the rewrite rules with the given head symbol. getRewriteRulesFor :: (HasConstInfo m, HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m RewriteRules -- | Signature lookup errors. data SigError -- | The name is not in the signature; default error message. SigUnknown :: String -> SigError -- | The name is not available, since it is abstract. SigAbstract :: SigError -- | Lookup a section telescope. -- -- If it doesn't exist, like in hierarchical top-level modules, the -- section telescope is empty. lookupSection :: (Functor m, ReadTCState m) => ModuleName -> m Telescope -- | 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. inFreshModuleIfFreeParams :: TCM a -> TCM a class (HasBuiltins m, HasConstInfo m, MonadAddContext m, MonadDebug m, MonadReduce m, MonadTCEnv m, ReadTCState m) => PureTCM m -- | To be called before any write or restore calls. cachingStarts :: (MonadDebug m, MonadTCState m, ReadTCState m) => m () areWeCaching :: ReadTCState m => m Bool -- | Writes a TypeCheckAction to the current log, using the current -- PostScopeState writeToCurrentLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => TypeCheckAction -> m () restorePostScopeState :: (MonadDebug m, MonadTCState m) => PostScopeState -> m () -- | Runs the action and restores the current cache at the end of it. localCache :: (MonadTCState m, ReadTCState m) => m a -> m a -- | Runs the action without cache and restores the current cache at the -- end of it. withoutCache :: (MonadTCState m, ReadTCState m) => m a -> m a -- | Reads the next entry in the cached type check log, if present. readFromCachedLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => m (Maybe (TypeCheckAction, PostScopeState)) -- | Empties the "to read" CachedState. To be used when it gets invalid. cleanCachedLog :: (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. activateLoadedFileCache :: (HasOptions m, MonadDebug m, MonadTCState m) => m () -- | Caches the current type check log. Discardes the old cache. Does -- nothing if caching is inactive. cacheCurrentLog :: (MonadDebug m, MonadTCState m) => m () data SpeculateResult SpeculateAbort :: SpeculateResult SpeculateCommit :: SpeculateResult -- | Resets the non-persistent part of the type checking state. resetState :: TCM () -- | Resets all of the type checking state. -- -- Keep only Benchmark and backend information. resetAllState :: TCM () -- | Restore TCState after performing subcomputation. -- -- In contrast to localState, the Benchmark info from the -- subcomputation is saved. localTCState :: TCM a -> TCM a -- | Same as localTCState but also returns the state in which we -- were just before reverting it. localTCStateSaving :: TCM a -> TCM (a, TCState) -- | Same as localTCState but keep all warnings. localTCStateSavingWarnings :: TCM a -> TCM a -- | Allow rolling back the state changes of a TCM computation. speculateTCState :: TCM (a, SpeculateResult) -> TCM a speculateTCState_ :: TCM SpeculateResult -> TCM () -- | 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.) freshTCM :: TCM a -> TCM (Either TCErr a) lensPersistentState :: Lens' PersistentTCState TCState updatePersistentState :: (PersistentTCState -> PersistentTCState) -> TCState -> TCState modifyPersistentState :: (PersistentTCState -> PersistentTCState) -> TCM () -- | Lens for stAccumStatistics. lensAccumStatisticsP :: Lens' Statistics PersistentTCState lensAccumStatistics :: Lens' Statistics TCState -- | Get the current scope. getScope :: ReadTCState m => m ScopeInfo -- | Set the current scope. setScope :: ScopeInfo -> TCM () -- | Modify the current scope without updating the inverse maps. modifyScope_ :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () -- | Modify the current scope. modifyScope :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () -- | Get a part of the current scope. useScope :: ReadTCState m => Lens' a ScopeInfo -> m a -- | Run a computation in a modified scope. locallyScope :: ReadTCState m => Lens' a ScopeInfo -> (a -> a) -> m b -> m b -- | Run a computation in a local scope. withScope :: ReadTCState m => ScopeInfo -> m a -> m (a, ScopeInfo) -- | Same as withScope, but discard the scope from the computation. withScope_ :: ReadTCState m => ScopeInfo -> m a -> m a -- | Discard any changes to the scope by a computation. localScope :: TCM a -> TCM a -- | Scope error. notInScopeError :: QName -> TCM a notInScopeWarning :: QName -> TCM () -- | Debug print the scope. printScope :: String -> Int -> String -> TCM () modifySignature :: MonadTCState m => (Signature -> Signature) -> m () modifyImportedSignature :: MonadTCState m => (Signature -> Signature) -> m () getSignature :: ReadTCState m => m Signature -- | 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. modifyGlobalDefinition :: MonadTCState m => QName -> (Definition -> Definition) -> m () setSignature :: MonadTCState m => Signature -> m () -- | Run some computation in a different signature, restore original -- signature. withSignature :: (ReadTCState m, MonadTCState m) => Signature -> m a -> m a addRewriteRulesFor :: QName -> RewriteRules -> [QName] -> Signature -> Signature setMatchableSymbols :: QName -> [QName] -> Signature -> Signature lookupDefinition :: QName -> Signature -> Maybe Definition updateDefinitions :: (Definitions -> Definitions) -> Signature -> Signature updateDefinition :: QName -> (Definition -> Definition) -> Signature -> Signature updateTheDef :: (Defn -> Defn) -> Definition -> Definition updateDefType :: (Type -> Type) -> Definition -> Definition updateDefArgOccurrences :: ([Occurrence] -> [Occurrence]) -> Definition -> Definition updateDefPolarity :: ([Polarity] -> [Polarity]) -> Definition -> Definition updateDefCompiledRep :: (CompiledRepresentation -> CompiledRepresentation) -> Definition -> Definition addCompilerPragma :: BackendName -> CompilerPragma -> Definition -> Definition updateFunClauses :: ([Clause] -> [Clause]) -> Defn -> Defn updateCovering :: ([Clause] -> [Clause]) -> Defn -> Defn updateCompiledClauses :: (Maybe CompiledClauses -> Maybe CompiledClauses) -> Defn -> Defn updateDefCopatternLHS :: (Bool -> Bool) -> Definition -> Definition updateDefBlocked :: (Blocked_ -> Blocked_) -> Definition -> Definition -- | Tries to convert a raw top-level module name to a top-level module -- name. topLevelModuleName :: RawTopLevelModuleName -> TCM TopLevelModuleName -- | Set the top-level module. This affects the global module id of freshly -- generated names. setTopLevelModule :: TopLevelModuleName -> TCM () -- | The name of the current top-level module, if any. currentTopLevelModule :: (MonadTCEnv m, ReadTCState m) => m (Maybe TopLevelModuleName) -- | Use a different top-level module for a computation. Used when -- generating names for imported modules. withTopLevelModule :: TopLevelModuleName -> TCM a -> TCM a currentModuleNameHash :: ReadTCState m => m ModuleNameHash addForeignCode :: BackendName -> String -> TCM () getInteractionOutputCallback :: ReadTCState m => m InteractionOutputCallback appInteractionOutputCallback :: Response -> TCM () setInteractionOutputCallback :: InteractionOutputCallback -> TCM () getPatternSyns :: ReadTCState m => m PatternSynDefns setPatternSyns :: PatternSynDefns -> TCM () -- | Lens for stPatternSyns. modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM () getPatternSynImports :: ReadTCState m => m PatternSynDefns -- | Get both local and imported pattern synonyms getAllPatternSyns :: ReadTCState m => m PatternSynDefns lookupPatternSyn :: AmbiguousQName -> TCM PatternSynDefn lookupSinglePatternSyn :: QName -> TCM PatternSynDefn -- | Lens getter for Benchmark from TCState. theBenchmark :: TCState -> Benchmark -- | Lens map for Benchmark. updateBenchmark :: (Benchmark -> Benchmark) -> TCState -> TCState -- | Lens modify for Benchmark. modifyBenchmark :: (Benchmark -> Benchmark) -> TCM () -- | Look through the signature and reconstruct the instance table. addImportedInstances :: Signature -> TCM () -- | Lens for stInstanceDefs. updateInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCState -> TCState modifyInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCM () getAllInstanceDefs :: TCM TempInstanceTable getAnonInstanceDefs :: TCM (Set QName) -- | Remove all instances whose type is still unresolved. clearAnonInstanceDefs :: TCM () -- | Add an instance whose type is still unresolved. addUnknownInstance :: QName -> TCM () -- | Add instance to some `class'. addNamedInstance :: QName -> QName -> TCM () class (MonadTCEnv m, ReadTCState m) => MonadTrace m -- | Record a function call in the trace. traceCall :: MonadTrace m => Call -> m a -> m a traceCallM :: MonadTrace m => m Call -> m a -> m a -- | 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 -- Call, we will revert to the last interesting call. traceCallCPS :: MonadTrace m => Call -> ((a -> m b) -> m b) -> (a -> m b) -> m b traceClosureCall :: MonadTrace m => Closure Call -> m a -> m a -- | Lispify and print the given highlighting information. printHighlightingInfo :: MonadTrace m => RemoveTokenBasedHighlighting -> HighlightingInfo -> m () -- | Lispify and print the given highlighting information. printHighlightingInfo :: (MonadTrace m, MonadTrans t, MonadTrace n, t n ~ m) => RemoveTokenBasedHighlighting -> HighlightingInfo -> m () interestingCall :: Call -> Bool getCurrentRange :: MonadTCEnv m => m Range -- | 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). setCurrentRange :: (MonadTrace m, HasRange x) => x -> m a -> m a -- | highlightAsTypeChecked rPre r m runs m and returns -- its result. Additionally, some code may be highlighted: -- -- highlightAsTypeChecked :: MonadTrace m => Range -> Range -> m a -> m a noMutualBlock :: TCM a -> TCM a -- | Pass the current mutual block id or create a new mutual block if we -- are not already inside on. inMutualBlock :: (MutualId -> TCM a) -> TCM a -- | Set the mutual block info for a block, possibly overwriting the -- existing one. setMutualBlockInfo :: MutualId -> MutualInfo -> TCM () -- | Set the mutual block info for a block if non-existing. insertMutualBlockInfo :: MutualId -> MutualInfo -> TCM () -- | Set the mutual block for a definition. setMutualBlock :: MutualId -> QName -> TCM () -- | Get the current mutual block, if any, otherwise a fresh mutual block -- is returned. currentOrFreshMutualBlock :: TCM MutualId lookupMutualBlock :: ReadTCState tcm => MutualId -> tcm MutualBlock -- | Reverse lookup of a mutual block id for a name. mutualBlockOf :: QName -> TCM MutualId enterClosure :: (MonadTCEnv m, ReadTCState m, LensClosure a c) => c -> (a -> m b) -> m b withClosure :: (MonadTCEnv m, ReadTCState m) => Closure a -> (a -> m b) -> m (Closure b) mapClosure :: (MonadTCEnv m, ReadTCState m) => (a -> m b) -> Closure a -> m (Closure b) -- | Monad service class containing methods for adding and solving -- constraints class (MonadTCEnv m, ReadTCState m, MonadError TCErr m, MonadBlock m, HasOptions m, MonadDebug m) => MonadConstraint m -- | Unconditionally add the constraint. addConstraint :: MonadConstraint m => Blocker -> Constraint -> m () -- | Add constraint as awake constraint. addAwakeConstraint :: MonadConstraint m => Blocker -> Constraint -> m () solveConstraint :: MonadConstraint m => Constraint -> m () -- | Solve awake constraints matching the predicate. If the second argument -- is True solve constraints even if already isSolvingConstraints. solveSomeAwakeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> Bool -> m () wakeConstraints :: MonadConstraint m => (ProblemConstraint -> WakeUp) -> m () stealConstraints :: MonadConstraint m => ProblemId -> m () modifyAwakeConstraints :: MonadConstraint m => (Constraints -> Constraints) -> m () modifySleepingConstraints :: MonadConstraint m => (Constraints -> Constraints) -> m () data ConstraintStatus AwakeConstraint :: ConstraintStatus SleepingConstraint :: ConstraintStatus 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 -- | Get the awake constraints getAwakeConstraints :: ReadTCState m => m Constraints dropConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () -- | Takes out all constraints matching given filter. Danger! The taken -- constraints need to be solved or put back at some point. takeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m Constraints putConstraintsToSleep :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () putAllConstraintsToSleep :: MonadConstraint m => m () -- | 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. holdConstraints :: (ConstraintStatus -> ProblemConstraint -> Bool) -> TCM a -> TCM a takeAwakeConstraint :: MonadConstraint m => m (Maybe ProblemConstraint) takeAwakeConstraint' :: MonadConstraint m => (ProblemConstraint -> Bool) -> m (Maybe ProblemConstraint) getAllConstraints :: ReadTCState m => m Constraints withConstraint :: MonadConstraint m => (Constraint -> m a) -> ProblemConstraint -> m a buildProblemConstraint :: (MonadTCEnv m, ReadTCState m) => Set ProblemId -> Blocker -> Constraint -> m ProblemConstraint buildProblemConstraint_ :: (MonadTCEnv m, ReadTCState m) => Blocker -> Constraint -> m ProblemConstraint buildConstraint :: Blocker -> Constraint -> TCM ProblemConstraint addAndUnblocker :: MonadBlock m => Blocker -> m a -> m a addOrUnblocker :: MonadBlock m => Blocker -> m a -> m a -- | Add new a constraint addConstraint' :: Blocker -> Constraint -> TCM () addAwakeConstraint' :: Blocker -> Constraint -> TCM () addConstraintTo :: Lens' Constraints TCState -> Blocker -> Constraint -> TCM () -- | Start solving constraints nowSolvingConstraints :: MonadTCEnv m => m a -> m a isSolvingConstraints :: MonadTCEnv m => m Bool -- | Add constraint if the action raises a pattern violation catchConstraint :: MonadConstraint m => Constraint -> m () -> m () isInstanceConstraint :: Constraint -> Bool shouldPostponeInstanceSearch :: (ReadTCState m, HasOptions m) => m Bool -- | Wake constraints matching the given predicate (and aren't instance -- constraints if shouldPostponeInstanceSearch). wakeConstraints' :: MonadConstraint m => (ProblemConstraint -> WakeUp) -> m () mapAwakeConstraints :: (Constraints -> Constraints) -> TCState -> TCState mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState -- | Sets the pragma options. setPragmaOptions :: PragmaOptions -> 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 -- then the state is reset (partly, see setIncludeDirs). -- -- An empty list of relative include directories (Left -- []) is interpreted as ["."]. setCommandLineOptions :: CommandLineOptions -> TCM () setCommandLineOptions' :: AbsolutePath -> CommandLineOptions -> TCM () -- | Returns the library files for a given file. getAgdaLibFiles :: AbsolutePath -> TopLevelModuleName -> TCM [AgdaLibFile] -- | Returns the library options for a given file. getLibraryOptions :: AbsolutePath -> TopLevelModuleName -> TCM [OptionsPragma] setLibraryPaths :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions addDefaultLibraries :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions addTrustedExecutables :: CommandLineOptions -> TCM CommandLineOptions setOptionsFromPragma :: OptionsPragma -> TCM () -- | Disable display forms. enableDisplayForms :: MonadTCEnv m => m a -> m a -- | Disable display forms. disableDisplayForms :: MonadTCEnv m => m a -> m a -- | Check if display forms are enabled. displayFormsEnabled :: MonadTCEnv m => m Bool -- | Makes the given directories absolute and stores them as include -- directories. -- -- If the include directories change, then the state is reset -- (completely, except for the include directories and some other -- things). -- -- An empty list is interpreted as ["."]. setIncludeDirs :: [FilePath] -> AbsolutePath -> TCM () isPropEnabled :: HasOptions m => m Bool isTwoLevelEnabled :: HasOptions m => m Bool hasUniversePolymorphism :: HasOptions m => m Bool showImplicitArguments :: HasOptions m => m Bool showIrrelevantArguments :: HasOptions m => m Bool showIdentitySubstitutions :: HasOptions m => m Bool -- | 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 => m a -> m a withShowAllArguments' :: ReadTCState m => Bool -> m a -> m a -- | Change PragmaOptions for a computation and restore afterwards. withPragmaOptions :: ReadTCState m => (PragmaOptions -> PragmaOptions) -> m a -> m a positivityCheckEnabled :: HasOptions m => m Bool typeInType :: HasOptions m => m Bool etaEnabled :: HasOptions m => m Bool maxInstanceSearchDepth :: HasOptions m => m Int maxInversionDepth :: HasOptions m => m Int -- | Returns the Language currently in effect. getLanguage :: HasOptions m => m Language -- | Create an open term in the current context. makeOpen :: (ReadTCState m, MonadTCEnv m) => a -> m (Open a) -- | Extract the value from an open term. The checkpoint at which it was -- created must be in scope. getOpen :: (TermSubst a, MonadTCEnv m) => Open a -> m a -- | Extract the value from an open term. If the checkpoint is no longer in -- scope use the provided function to pull the object to the most recent -- common checkpoint. The function is given the substitution from the -- common ancestor to the checkpoint of the thing. tryGetOpen :: (TermSubst a, ReadTCState m, MonadTCEnv m) => (Substitution -> a -> Maybe a) -> Open a -> m (Maybe a) -- | An Open is closed if it has checkpoint 0. isClosed :: Open a -> Bool -- | Wrapper to tell addContext not to mark names as -- TypeError. Used when adding a user-provided, but already type -- checked, telescope to the context. newtype KeepNames a KeepNames :: a -> KeepNames a -- | Various specializations of addCtx. class AddContext b addContext :: (AddContext b, MonadAddContext m) => b -> m a -> m a contextSize :: AddContext b => b -> Nat -- | Modify a Context in a computation. Warning: does not update the -- checkpoints. Use updateContext instead. unsafeModifyContext :: MonadTCEnv tcm => (Context -> Context) -> tcm a -> tcm a -- | Modify the Dom' part of context entries. modifyContextInfo :: MonadTCEnv tcm => (forall e. Dom e -> Dom e) -> tcm a -> tcm a -- | Change to top (=empty) context. Resets the checkpoints. inTopContext :: (MonadTCEnv tcm, ReadTCState tcm) => tcm a -> tcm a -- | Change to top (=empty) context, but don't update the checkpoints. -- Totally not safe! unsafeInTopContext :: (MonadTCEnv m, ReadTCState m) => m a -> m 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. unsafeEscapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a -- | Delete the last n bindings from the context. Any occurrences -- of these variables are replaced with the given err. escapeContext :: MonadAddContext m => Impossible -> Int -> m a -> m a -- | Add a new checkpoint. Do not use directly! checkpoint :: (MonadDebug tcm, MonadTCM tcm, MonadFresh CheckpointId tcm, ReadTCState tcm) => Substitution -> tcm a -> tcm a -- | Get the substitution from the context at a given checkpoint to the -- current context. checkpointSubstitution' :: MonadTCEnv tcm => CheckpointId -> tcm (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. getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m (Maybe Substitution) -- | Default implementation of addCtx in terms of updateContext defaultAddCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a withFreshName_ :: MonadAddContext m => ArgName -> (Name -> m a) -> m a -- | 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. withShadowingNameTCM :: Name -> TCM b -> TCM b addRecordNameContext :: (MonadAddContext m, MonadFresh NameId m) => Dom Type -> m b -> m b -- | Go under an abstraction. Do not extend context in case of -- NoAbs. underAbstraction :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b underAbstraction' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b -- | Go under an abstraction, treating NoAbs as Abs. underAbstractionAbs :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b underAbstractionAbs' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b -- | Go under an abstract without worrying about the type to add to the -- context. underAbstraction_ :: (Subst a, MonadAddContext m) => Abs a -> (a -> m b) -> m b -- | Map a monadic function on the thing under the abstraction, adding the -- abstracted variable to the context. mapAbstraction :: (Subst a, Subst b, MonadAddContext m) => Dom Type -> (a -> m b) -> Abs a -> m (Abs b) getLetBindings :: MonadTCM tcm => tcm [(Name, (Term, Dom Type))] -- | Add a let bound variable defaultAddLetBinding' :: (ReadTCState m, 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 -- | Get the current context. getContext :: MonadTCEnv m => m Context -- | Get the size of the current context. getContextSize :: (Applicative m, MonadTCEnv m) => m Nat -- | Generate [var (n - 1), ..., var 0] for all declarations in -- the 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] -- | Get the current context as a Telescope. getContextTelescope :: (Applicative m, MonadTCEnv m) => m Telescope -- | Get the names of all declarations in the context. getContextNames :: (Applicative m, MonadTCEnv m) => m [Name] -- | get type of bound variable (i.e. deBruijn index) lookupBV' :: MonadTCEnv m => Nat -> m (Maybe ContextEntry) 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 -- | 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. getVarInfo :: (MonadFail m, MonadTCEnv m) => Name -> m (Term, Dom Type) -- | Revert the EqualityView. -- -- Postcondition: type is reduced. class EqualityUnview a equalityUnview :: EqualityUnview a => a -> Type -- | Sort primitives. data SortKit SortKit :: QName -> QName -> QName -> (IsFibrant -> QName) -> SortKit [nameOfSet] :: SortKit -> QName [nameOfProp] :: SortKit -> QName [nameOfSSet] :: SortKit -> QName [nameOfSetOmega] :: SortKit -> IsFibrant -> QName -- | The coinductive primitives. data CoinductionKit CoinductionKit :: QName -> QName -> QName -> CoinductionKit [nameOfInf] :: CoinductionKit -> QName [nameOfSharp] :: CoinductionKit -> QName [nameOfFlat] :: CoinductionKit -> 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 () -- | Add one (more) relation symbol to the rewrite relations. bindBuiltinRewriteRelation :: QName -> TCM () -- | Get the currently registered rewrite relation symbols. getBuiltinRewriteRelations :: HasBuiltins m => m (Maybe (Set QName)) getBuiltin :: (HasBuiltins m, MonadTCError 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 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. getTerm :: HasBuiltins m => String -> String -> m Term -- | Rewrite a literal to constructor form if possible. constructorForm :: HasBuiltins m => Term -> m Term constructorForm' :: Applicative m => m Term -> m Term -> Term -> m Term primInteger :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIntegerPos :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIntegerNegSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFloat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primChar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primBool :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSigma :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primUnitUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primTrue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFalse :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primList :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primNil :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primCons :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primMaybe :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primNothing :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primJust :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIO :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primConId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIdElim :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPath :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPathP :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIntervalUniv :: (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 primLevel :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLevelZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLevelSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLevelMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLockUniv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primStrictSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFromNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFromNeg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFromString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArgArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAbsAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primHiding :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primHidden :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primInstance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primVisible :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primRelevance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primRelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIrrelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQuantity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQuantity0 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQuantityω :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primModality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primModalityConstructor :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssoc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssocLeft :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssocRight :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssocNon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPrecedence :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPrecRelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPrecUnrelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFixityFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArgArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortPropLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermVar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermExtLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermCon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermPi :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPart :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPartString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPartTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPartPatt :: (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 primAgdaTCMDeclareData :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDefineData :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDefineFun :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMGetType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMGetDefinition :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMQuoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMQuoteOmegaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMUnquoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMBlockOnMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMCommit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMIsMacro :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMWithNormalisation :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMWithReconsParams :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMFormatErrorParts :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDebugPrint :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMOnlyReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDontReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMNoConstraints :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMRunSpeculative :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMExec :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMGetInstances :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term -- | Tries to build a CoinductionKit. coinductionKit' :: TCM CoinductionKit coinductionKit :: TCM (Maybe CoinductionKit) -- | Compute a SortKit in an environment that supports failures. -- -- When optLoadPrimitives is set to False, sortKit -- is a fallible operation, so for the uses of sortKit in fallible -- contexts (e.g. TCMT), we report a type error rather than -- exploding. sortKit :: (HasBuiltins m, MonadTCError m, HasOptions m) => m SortKit -- | Compute a SortKit in contexts that do not support failure (e.g. -- Reify). This should only be used when we are sure that the -- primitive sorts have been bound, i.e. because it is "after" type -- checking. infallibleSortKit :: HasBuiltins m => m SortKit getPrimName :: Term -> QName getBuiltinName' :: HasBuiltins m => String -> m (Maybe QName) getPrimitiveName' :: HasBuiltins m => String -> m (Maybe QName) isPrimitive :: HasBuiltins m => String -> QName -> m Bool intervalSort :: Sort intervalView' :: HasBuiltins m => m (Term -> IntervalView) intervalView :: HasBuiltins m => Term -> m IntervalView intervalUnview :: HasBuiltins m => IntervalView -> m Term intervalUnview' :: HasBuiltins m => m (IntervalView -> Term) -- | Check whether the type is actually an path (lhs ≡ rhs) and extract -- lhs, rhs, and their type. -- -- Precondition: type is reduced. pathView :: HasBuiltins m => Type -> m PathView pathView' :: HasBuiltins m => m (Type -> PathView) -- | Non dependent Path idViewAsPath :: HasBuiltins m => Type -> m PathView boldPathView :: Type -> PathView -- | Revert the PathView. -- -- Postcondition: type is reduced. pathUnview :: PathView -> Type conidView' :: HasBuiltins m => m (Term -> Term -> Maybe (Arg Term, Arg Term)) -- | Get the name of the equality type. primEqualityName :: TCM QName -- | Check whether the type is actually an equality (lhs ≡ rhs) and extract -- lhs, rhs, and their type. -- -- Precondition: type is reduced. equalityView :: Type -> TCM EqualityView -- | Primitives with typechecking constrants. constrainedPrims :: [String] getNameOfConstrained :: HasBuiltins m => String -> m (Maybe QName) type SizeMaxView' = [DeepSizeView] type SizeMaxView = List1 DeepSizeView data SizeViewComparable a NotComparable :: SizeViewComparable a YesAbove :: DeepSizeView -> a -> SizeViewComparable a YesBelow :: DeepSizeView -> a -> SizeViewComparable a -- | A deep view on sizes. data DeepSizeView DSizeInf :: DeepSizeView DSizeVar :: ProjectedVar -> Offset -> DeepSizeView DSizeMeta :: MetaId -> Elims -> Offset -> DeepSizeView DOtherSize :: Term -> DeepSizeView type Offset = Nat -- | A de Bruijn index under some projections. data ProjectedVar ProjectedVar :: Int -> [(ProjOrigin, QName)] -> ProjectedVar [pvIndex] :: ProjectedVar -> Int [prProjs] :: ProjectedVar -> [(ProjOrigin, QName)] -- | A useful view on sizes. data SizeView SizeInf :: SizeView SizeSuc :: Term -> SizeView OtherSize :: Term -> SizeView -- | Check if a type is the primSize type. The argument should be -- reduced. class IsSizeType a isSizeType :: (IsSizeType a, HasOptions m, HasBuiltins m) => a -> m (Maybe BoundedSize) -- | Result of querying whether size variable i is bounded by -- another size. data BoundedSize -- | yes i : Size< t BoundedLt :: Term -> BoundedSize BoundedNo :: BoundedSize 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) -- | Test whether OPTIONS --sized-types and whether the size built-ins are -- defined. haveSizedTypes :: TCM Bool -- | Test whether the SIZELT builtin is defined. haveSizeLt :: TCM Bool -- | Add polarity info to a SIZE builtin. builtinSizeHook :: String -> QName -> Type -> TCM () -- | The sort of built-in types SIZE and SIZELT. sizeSort :: Sort -- | The type of built-in types SIZE and SIZELT. sizeUniv :: Type -- | The built-in type SIZE with user-given name. sizeType_ :: QName -> Type -- | The built-in type SIZE. sizeType :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => m Type -- | The name of SIZESUC. sizeSucName :: (HasBuiltins m, HasOptions m) => m (Maybe QName) sizeSuc :: HasBuiltins m => Nat -> Term -> m Term sizeSuc_ :: QName -> Term -> Term -- | Transform list of terms into a term build from binary maximum. sizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => List1 Term -> m Term -- | Expects argument to be reduced. sizeView :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => Term -> m SizeView viewProjectedVar :: Term -> Maybe ProjectedVar unviewProjectedVar :: ProjectedVar -> Term -- | sizeViewComparable v w checks whether v >= w -- (then Left) or v <= w (then Right). If -- uncomparable, it returns NotComparable. sizeViewComparable :: DeepSizeView -> DeepSizeView -> SizeViewComparable () sizeViewSuc_ :: QName -> DeepSizeView -> DeepSizeView -- | sizeViewPred k v decrements v by k (must be -- possible!). sizeViewPred :: Nat -> DeepSizeView -> DeepSizeView -- | sizeViewOffset v returns the number of successors or Nothing -- when infty. sizeViewOffset :: DeepSizeView -> Maybe Offset -- | Remove successors common to both sides. removeSucs :: (DeepSizeView, DeepSizeView) -> (DeepSizeView, DeepSizeView) -- | Turn a size view into a term. unSizeView :: SizeView -> TCM Term unDeepSizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => DeepSizeView -> m Term maxViewMax :: SizeMaxView -> SizeMaxView -> SizeMaxView -- | maxViewCons v ws = max v ws. It only adds v to -- ws if it is not subsumed by an element of ws. maxViewCons :: DeepSizeView -> SizeMaxView -> SizeMaxView -- | sizeViewComparableWithMax v ws tries to find w in -- ws that compares with v and singles this out. -- Precondition: v /= DSizeInv. sizeViewComparableWithMax :: DeepSizeView -> SizeMaxView -> SizeViewComparable SizeMaxView' maxViewSuc_ :: QName -> SizeMaxView -> SizeMaxView unMaxView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => SizeMaxView -> m Term -- | Add a constant to the signature. Lifts the definition to top level. addConstant :: QName -> Definition -> TCM () -- | A combination of addConstant and defaultDefn. The -- Language does not need to be supplied. addConstant' :: QName -> ArgInfo -> QName -> Type -> Defn -> TCM () -- | Set termination info of a defined function symbol. setTerminates :: MonadTCState m => QName -> Bool -> m () -- | Set CompiledClauses of a defined function symbol. setCompiledClauses :: QName -> CompiledClauses -> TCM () -- | Set SplitTree of a defined function symbol. setSplitTree :: QName -> SplitTree -> TCM () -- | Modify the clauses of a function. modifyFunClauses :: QName -> ([Clause] -> [Clause]) -> TCM () -- | Lifts clauses to the top-level and adds them to definition. Also -- adjusts the funCopatternLHS field if necessary. addClauses :: (MonadConstraint m, MonadTCState m) => QName -> [Clause] -> m () mkPragma :: String -> TCM CompilerPragma -- | Add a compiler pragma `{-# COMPILE backend name -- text #-}` addPragma :: BackendName -> QName -> String -> TCM () getUniqueCompilerPragma :: BackendName -> QName -> TCM (Maybe CompilerPragma) setFunctionFlag :: FunctionFlag -> Bool -> QName -> TCM () markStatic :: QName -> TCM () markInline :: Bool -> QName -> TCM () markInjective :: QName -> TCM () unionSignatures :: [Signature] -> Signature -- | Add a section to the signature. -- -- The current context will be stored as the cumulative module parameters -- for this section. addSection :: ModuleName -> TCM () -- | Sets the checkpoint for the given module to the current checkpoint. setModuleCheckpoint :: ModuleName -> TCM () -- | 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. getSection :: (Functor m, ReadTCState m) => ModuleName -> m (Maybe Section) -- | Add display forms for a name f copied by a module -- application. Essentially if f can reduce to -- --
--   λ xs → A.B.C.f vs
--   
-- -- by unfolding module application copies (defCopy), then we add a -- display form -- --
--   A.B.C.f vs ==> f xs
--   
addDisplayForms :: QName -> TCM () -- | Module application (followed by module parameter abstraction). applySection :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM () applySection' :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM () -- | Add a display form to a definition (could be in this or imported -- signature). addDisplayForm :: QName -> DisplayForm -> TCM () isLocal :: ReadTCState m => QName -> m Bool getDisplayForms :: (HasConstInfo m, ReadTCState m) => QName -> m [LocalDisplayForm] -- | Find all names used (recursively) by display forms of a given name. chaseDisplayForms :: QName -> TCM (Set QName) -- | Check if a display form is looping. hasLoopingDisplayForm :: QName -> TCM Bool canonicalName :: HasConstInfo m => QName -> m QName sameDef :: HasConstInfo m => QName -> QName -> m (Maybe QName) -- | Can be called on either a (co)datatype, a record type or a -- (co)constructor. whatInduction :: MonadTCM tcm => QName -> tcm Induction -- | Does the given constructor come from a single-constructor type? -- -- Precondition: The name has to refer to a constructor. singleConstructorType :: QName -> TCM Bool -- | Standard eliminator for SigError. sigError :: (String -> a) -> a -> SigError -> a -- | The computation getConstInfo sometimes tweaks the returned -- Definition, depending on the current Language and the -- Language of the Definition. This variant of -- getConstInfo does not perform any tweaks. getOriginalConstInfo :: (ReadTCState m, HasConstInfo m) => QName -> m Definition defaultGetRewriteRulesFor :: (ReadTCState m, MonadTCEnv m) => QName -> m RewriteRules -- | Get the original name of the projection (the current one could be from -- a module application). getOriginalProjection :: HasConstInfo m => QName -> m QName defaultGetConstInfo :: (HasOptions m, MonadDebug m, MonadTCEnv m) => TCState -> TCEnv -> QName -> m (Either SigError Definition) getConInfo :: HasConstInfo m => ConHead -> m Definition -- | Look up the polarity of a definition. getPolarity :: HasConstInfo m => QName -> m [Polarity] -- | Look up polarity of a definition and compose with polarity represented -- by Comparison. getPolarity' :: HasConstInfo m => Comparison -> QName -> m [Polarity] -- | Set the polarity of a definition. setPolarity :: (MonadTCState m, MonadDebug m) => QName -> [Polarity] -> m () -- | Look up the forced arguments of a definition. getForcedArgs :: HasConstInfo m => QName -> m [IsForced] -- | Get argument occurrence info for argument i of definition -- d (never fails). getArgOccurrence :: QName -> Nat -> TCM Occurrence -- | Sets the defArgOccurrences for the given identifier (which -- should already exist in the signature). setArgOccurrences :: MonadTCState m => QName -> [Occurrence] -> m () modifyArgOccurrences :: MonadTCState m => QName -> ([Occurrence] -> [Occurrence]) -> m () setTreeless :: QName -> TTerm -> TCM () setCompiledArgUse :: QName -> [ArgUsage] -> TCM () getCompiled :: HasConstInfo m => QName -> m (Maybe Compiled) -- | Returns a list of length conArity. If no erasure analysis has -- been performed yet, this will be a list of Falses. getErasedConArgs :: HasConstInfo m => QName -> m [Bool] setErasedConArgs :: QName -> [Bool] -> TCM () getTreeless :: HasConstInfo m => QName -> m (Maybe TTerm) getCompiledArgUse :: HasConstInfo m => QName -> m (Maybe [ArgUsage]) -- | add data constructors to a datatype addDataCons :: QName -> [QName] -> TCM () -- | Get the mutually recursive identifiers of a symbol from the signature. getMutual :: QName -> TCM (Maybe [QName]) -- | Get the mutually recursive identifiers from a Definition. getMutual_ :: Defn -> Maybe [QName] -- | Set the mutually recursive identifiers. setMutual :: QName -> [QName] -> TCM () -- | Check whether two definitions are mutually recursive. mutuallyRecursive :: QName -> QName -> TCM Bool -- | A functiondatarecord definition is nonRecursive if it is not -- even mutually recursive with itself. definitelyNonRecursive_ :: Defn -> Bool -- | Get the number of parameters to the current module. getCurrentModuleFreeVars :: TCM Nat getDefModule :: HasConstInfo m => QName -> m (Either SigError ModuleName) -- | 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). getDefFreeVars :: (Functor m, Applicative m, ReadTCState m, MonadTCEnv m) => QName -> m Nat freeVarsToApply :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => QName -> m Args getModuleFreeVars :: (Functor m, Applicative m, MonadTCEnv m, ReadTCState m) => ModuleName -> m Nat -- | 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 Θ] moduleParamsToApply :: (Functor m, Applicative m, HasOptions m, MonadTCEnv m, ReadTCState m, MonadDebug m) => ModuleName -> m Args -- | Instantiate a closed definition with the correct part of the current -- context. instantiateDef :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => Definition -> m Definition instantiateRewriteRule :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRule -> m RewriteRule instantiateRewriteRules :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRules -> m RewriteRules -- | Give the abstract view of a definition. makeAbstract :: Definition -> Maybe Definition -- | Enter abstract mode. Abstract definition in the current module are -- transparent. inAbstractMode :: MonadTCEnv m => m a -> m a -- | Not in abstract mode. All abstract definitions are opaque. inConcreteMode :: MonadTCEnv m => m a -> m a -- | Ignore abstract mode. All abstract definitions are transparent. ignoreAbstractMode :: MonadTCEnv m => m a -> m a -- | Enter concrete or abstract mode depending on whether the given -- identifier is concrete or abstract. inConcreteOrAbstractMode :: (MonadTCEnv m, HasConstInfo m) => QName -> (Definition -> m a) -> m a -- | 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 :: MonadTCEnv m => QName -> m 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. treatAbstractly' :: QName -> TCEnv -> Bool -- | Get type of a constant, instantiated to the current context. typeOfConst :: (HasConstInfo m, ReadTCState m) => QName -> m Type -- | Get relevance of a constant. relOfConst :: HasConstInfo m => QName -> m Relevance -- | Get modality of a constant. modalityOfConst :: HasConstInfo m => QName -> m Modality -- | The number of dropped parameters for a definition. 0 except for -- projection(-like) functions and constructors. droppedPars :: Definition -> Int -- | Is it the name of a record projection? isProjection :: HasConstInfo m => QName -> m (Maybe Projection) isProjection_ :: Defn -> Maybe Projection -- | Is it the name of a non-irrelevant record projection? isRelevantProjection :: HasConstInfo m => QName -> m (Maybe Projection) isRelevantProjection_ :: Definition -> Maybe Projection -- | Is it a function marked STATIC? isStaticFun :: Defn -> Bool -- | Is it a function marked INLINE? isInlineFun :: 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). isProperProjection :: Defn -> Bool -- | Number of dropped initial arguments of a projection(-like) function. projectionArgs :: Definition -> Int -- | Check whether a definition uses copatterns. usesCopatterns :: HasConstInfo m => QName -> m Bool -- | Apply a function f to its first argument, producing the -- proper postfix projection if f is a projection which is not -- irrelevant. applyDef :: HasConstInfo m => ProjOrigin -> QName -> Arg Term -> m Term -- | Unfreeze a meta and its type if this is a meta again. Does not -- unfreeze deep occurrences of meta-variables or remote meta-variables. class UnFreezeMeta a unfreezeMeta :: (UnFreezeMeta a, MonadMetaSolver m) => a -> m () -- | Check whether all metas are instantiated. Precondition: argument is a -- meta (in some form) or a list of metas. class IsInstantiatedMeta a isInstantiatedMeta :: (IsInstantiatedMeta a, MonadFail m, ReadTCState m) => a -> m Bool -- | Pairs of local meta-stores. data LocalMetaStores LocalMetaStores :: LocalMetaStore -> LocalMetaStore -> LocalMetaStores -- | A MetaStore containing open meta-variables. [openMetas] :: LocalMetaStores -> LocalMetaStore -- | A MetaStore containing instantiated meta-variables. [solvedMetas] :: LocalMetaStores -> LocalMetaStore -- | Monad service class for creating, solving and eta-expanding of -- metavariables. class (MonadConstraint m, MonadReduce m, MonadAddContext m, MonadTCEnv m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) => MonadMetaSolver m -- | Generate a new meta variable with some instantiation given. For -- instance, the instantiation could be a -- PostponedTypeCheckingProblem. newMeta' :: MonadMetaSolver m => MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId -- | 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. assignV :: MonadMetaSolver m => CompareDirection -> MetaId -> Args -> Term -> CompareAs -> m () -- | Directly instantiate the metavariable. Skip pattern check, occurs -- check and frozen check. Used for eta expanding frozen metas. assignTerm' :: (MonadMetaSolver m, MonadMetaSolver m) => MetaId -> [Arg ArgName] -> Term -> m () -- | Eta-expand a local meta-variable, if it is of the specified kind. -- Don't do anything if the meta-variable is a blocked term. etaExpandMeta :: MonadMetaSolver m => [MetaKind] -> MetaId -> m () -- | Update the status of the metavariable updateMetaVar :: MonadMetaSolver m => MetaId -> (MetaVariable -> MetaVariable) -> 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. speculateMetas :: MonadMetaSolver m => m () -> m KeepMetas -> m () data KeepMetas KeepMetas :: KeepMetas RollBackMetas :: KeepMetas -- | Various kinds of metavariables. data MetaKind -- | Meta variables of record type. Records :: MetaKind -- | Meta variables of "hereditarily singleton" record type. SingletonRecords :: MetaKind -- | Meta variables of level type, if type-in-type is activated. Levels :: MetaKind -- | All possible metavariable kinds. allMetaKinds :: [MetaKind] -- | Switch off assignment of metas. dontAssignMetas :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a -- | Is the meta-variable from another top-level module? isRemoteMeta :: ReadTCState m => m (MetaId -> Bool) -- | If another meta-variable is created, then it will get this -- MetaId (unless the state is changed too much, for instance by -- setTopLevelModule). nextLocalMeta :: ReadTCState m => m MetaId -- | Run a computation and record which new metas it created. metasCreatedBy :: forall m a. ReadTCState m => m a -> m (a, LocalMetaStores) -- | Find information about the given local meta-variable, if any. lookupLocalMeta' :: ReadTCState m => MetaId -> m (Maybe MetaVariable) -- | Find information about the given local meta-variable. lookupLocalMeta :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m MetaVariable -- | Find information about the (local or remote) meta-variable, if any. -- -- If no meta-variable is found, then the reason could be that the -- dead-code elimination (eliminateDeadCode) failed to find the -- meta-variable, perhaps because some NamesIn instance is -- incorrectly defined. lookupMeta :: ReadTCState m => MetaId -> m (Maybe (Either RemoteMetaVariable MetaVariable)) -- | Find the meta-variable's instantiation. lookupMetaInstantiation :: ReadTCState m => MetaId -> m MetaInstantiation -- | Find the meta-variable's judgement. lookupMetaJudgement :: ReadTCState m => MetaId -> m (Judgement MetaId) -- | Find the meta-variable's modality. lookupMetaModality :: ReadTCState m => MetaId -> m Modality -- | The type of a term or sort meta-variable. metaType :: ReadTCState m => MetaId -> m Type -- | Update the information associated with a local meta-variable. updateMetaVarTCM :: HasCallStack => MetaId -> (MetaVariable -> MetaVariable) -> TCM () -- | Insert a new meta-variable with associated information into the local -- meta store. insertMetaVar :: MetaId -> MetaVariable -> TCM () -- | Returns the MetaPriority of the given local meta-variable. getMetaPriority :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m MetaPriority isSortMeta :: ReadTCState m => MetaId -> m Bool isSortMeta_ :: MetaVariable -> Bool isSortJudgement :: Judgement a -> Bool getMetaType :: ReadTCState m => MetaId -> m Type -- | Compute the context variables that a local meta-variable should be -- applied to, accounting for pruning. getMetaContextArgs :: MonadTCEnv m => MetaVariable -> m Args -- | Given a local meta-variable, return the type applied to the current -- context. getMetaTypeInContext :: (HasBuiltins m, HasCallStack, MonadDebug m, MonadReduce m, MonadTCEnv m, ReadTCState m) => MetaId -> m Type -- | Is it a local meta-variable that might be generalized? isGeneralizableMeta :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m DoGeneralize isInstantiatedMeta' :: (MonadFail m, ReadTCState m) => MetaId -> m (Maybe Term) -- | Returns all metavariables in a constraint. Slightly complicated by the -- fact that blocked terms are represented by two meta variables. To find -- the second one we need to look up the meta listeners for the one in -- the UnBlock constraint. This is used for the purpose of deciding if a -- metavariable is constrained or if it can be generalized over (see -- Agda.TypeChecking.Generalize). constraintMetas :: Constraint -> TCM (Set MetaId) -- | Create MetaInfo in the current environment. createMetaInfo :: (MonadTCEnv m, ReadTCState m) => m MetaInfo createMetaInfo' :: (MonadTCEnv m, ReadTCState m) => RunMetaOccursCheck -> m MetaInfo setValueMetaName :: MonadMetaSolver m => Term -> MetaNameSuggestion -> m () getMetaNameSuggestion :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m MetaNameSuggestion setMetaNameSuggestion :: MonadMetaSolver m => MetaId -> MetaNameSuggestion -> m () -- | Change the ArgInfo that will be used when generalizing over this local -- meta-variable. setMetaGeneralizableArgInfo :: MonadMetaSolver m => MetaId -> ArgInfo -> m () updateMetaVarRange :: MonadMetaSolver m => MetaId -> Range -> m () setMetaOccursCheck :: MonadMetaSolver m => MetaId -> RunMetaOccursCheck -> m () -- | Register an interaction point during scope checking. If there is no -- interaction id yet, create one. registerInteractionPoint :: forall m. MonadInteractionPoints m => Bool -> Range -> Maybe Nat -> m InteractionId -- | Find an interaction point by Range' by searching the whole map. -- Issue 3000: Don't consider solved interaction points. -- -- O(n): linear in the number of registered interaction points. findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId -- | Hook up a local meta-variable to an interaction point. connectInteractionPoint :: MonadInteractionPoints m => InteractionId -> MetaId -> m () -- | Mark an interaction point as solved. removeInteractionPoint :: MonadInteractionPoints m => InteractionId -> m () -- | Get a list of interaction ids. getInteractionPoints :: ReadTCState m => m [InteractionId] -- | Get all metas that correspond to unsolved interaction ids. getInteractionMetas :: ReadTCState m => m [MetaId] getUniqueMetasRanges :: (HasCallStack, MonadDebug m, ReadTCState m) => [MetaId] -> m [Range] getUnsolvedMetas :: (HasCallStack, MonadDebug m, ReadTCState m) => m [Range] getUnsolvedInteractionMetas :: (HasCallStack, MonadDebug m, ReadTCState m) => m [Range] -- | Get all metas that correspond to unsolved interaction ids. getInteractionIdsAndMetas :: ReadTCState m => m [(InteractionId, MetaId)] -- | Does the meta variable correspond to an interaction point? -- -- Time: O(log n) where n is the number of interaction -- metas. isInteractionMeta :: ReadTCState m => MetaId -> m (Maybe InteractionId) -- | Get the information associated to an interaction point. lookupInteractionPoint :: (MonadFail m, ReadTCState m, MonadError TCErr m) => InteractionId -> m InteractionPoint -- | Get MetaId for an interaction point. Precondition: interaction -- point is connected. lookupInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m MetaId -- | Check whether an interaction id is already associated with a meta -- variable. lookupInteractionMeta :: ReadTCState m => InteractionId -> m (Maybe MetaId) lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId -- | Generate new meta variable. newMeta :: MonadMetaSolver m => 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. newMetaTCM' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId -- | Get the Range' for an interaction point. getInteractionRange :: (MonadInteractionPoints m, MonadFail m, MonadError TCErr m) => InteractionId -> m Range -- | Get the Range' for a local meta-variable. getMetaRange :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m Range getInteractionScope :: (MonadDebug m, MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m ScopeInfo withMetaInfo' :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => MetaVariable -> m a -> m a withMetaInfo :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => Closure Range -> m a -> m a withInteractionId :: (MonadDebug m, MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m, MonadTrace m) => InteractionId -> m a -> m a withMetaId :: (HasCallStack, MonadDebug m, MonadTCEnv m, MonadTrace m, ReadTCState m) => MetaId -> m a -> m a getOpenMetas :: ReadTCState m => m [MetaId] isOpenMeta :: MetaInstantiation -> Bool -- | listenToMeta l m: register l as a listener to -- m. This is done when the type of l is blocked by m. listenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () -- | Unregister a listener. unlistenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () -- | Get the listeners for a local meta-variable. getMetaListeners :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m [Listener] clearMetaListeners :: MonadMetaSolver m => MetaId -> m () -- | Do safe eta-expansions for meta (SingletonRecords,Levels). etaExpandMetaSafe :: MonadMetaSolver m => MetaId -> m () -- | Eta expand metavariables listening on the current meta. etaExpandListeners :: MonadMetaSolver m => MetaId -> m () -- | Wake up a meta listener and let it do its thing wakeupListener :: MonadMetaSolver m => Listener -> m () solveAwakeConstraints :: MonadConstraint m => m () solveAwakeConstraints' :: MonadConstraint m => Bool -> m () -- | Freeze the given meta-variables (but only if they are open) and return -- those that were not already frozen. freezeMetas :: MonadTCState m => LocalMetaStore -> m (Set MetaId) -- | Thaw all open meta variables. unfreezeMetas :: TCM () isFrozen :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m Bool withFrozenMetas :: (MonadMetaSolver m, MonadTCState m) => m a -> m a -- | The result and associated parameters of a type-checked file, when -- invoked directly via interaction or a backend. Note that the -- constructor is not exported. data CheckResult -- | Flattened unidirectional pattern for CheckResult for -- destructuring inside the ModuleInfo field. pattern CheckResult :: Interface -> [TCWarning] -> ModuleCheckMode -> Source -> CheckResult crInterface :: CheckResult -> Interface crWarnings :: CheckResult -> [TCWarning] crMode :: CheckResult -> ModuleCheckMode -- | Ask the active backend whether a type may be erased. See issue #3732. activeBackendMayEraseType :: QName -> TCM Bool backendInteraction :: AbsolutePath -> [Backend] -> TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM () parseBackendOptions :: [Backend] -> [String] -> CommandLineOptions -> OptM ([Backend], CommandLineOptions) -- | Call the compilerMain function of the given backend. callBackend :: String -> IsMain -> CheckResult -> TCM () -- | Look for a backend of the given name. lookupBackend :: BackendName -> TCM (Maybe Backend) -- | Get the currently active backend (if any). activeBackend :: TCM (Maybe Backend) instance GHC.Generics.Generic (Agda.Compiler.Backend.Backend' opts env menv mod def) instance Control.DeepSeq.NFData Agda.Compiler.Backend.Backend instance Control.DeepSeq.NFData opts => Control.DeepSeq.NFData (Agda.Compiler.Backend.Backend' opts env menv mod def) module Agda.TypeChecking.Reduce -- | Instantiate something. Results in an open meta variable or a non meta. -- Doesn't do any reduction, and preserves blocking tags (when blocking -- meta is uninstantiated). class Instantiate t instantiate' :: Instantiate t => t -> ReduceM t instantiate :: (Instantiate a, MonadReduce m) => a -> m a -- | A variant of instantiateFull that only instantiates those -- meta-variables that satisfy the predicate. instantiateWhen :: (InstantiateFull a, MonadReduce m) => (MetaId -> ReduceM Bool) -> a -> m a -- | instantiateFull' instantiates metas everywhere (and -- recursively) but does not reduce. class InstantiateFull t instantiateFull' :: InstantiateFull t => t -> ReduceM t instantiateFull :: (InstantiateFull a, MonadReduce m) => a -> m a -- | Instantiates everything except for definitions in the signature. instantiateFullExceptForDefinitions :: MonadReduce m => Interface -> m Interface -- | Is something (an elimination of) a meta variable? Does not perform any -- reductions. class IsMeta a isMeta :: IsMeta a => a -> Maybe MetaId class Reduce t reduce' :: Reduce t => t -> ReduceM t reduceB' :: Reduce t => t -> ReduceM (Blocked t) reduce :: (Reduce a, MonadReduce m) => a -> m a reduceB :: (Reduce a, MonadReduce m) => a -> m (Blocked a) reduceWithBlocker :: (Reduce a, IsMeta a, MonadReduce m) => a -> m (Blocker, a) reduceIApply' :: (Term -> ReduceM (Blocked Term)) -> ReduceM (Blocked Term) -> [Elim] -> ReduceM (Blocked Term) -- | Reduce a non-primitive definition if it is a copy linking to another -- def. reduceDefCopy :: forall m. PureTCM m => QName -> Elims -> m (Reduced () Term) -- | Specialized version to put in boot file. reduceDefCopyTCM :: QName -> Elims -> TCM (Reduced () Term) -- | Reduce simple (single clause) definitions. reduceHead :: PureTCM m => Term -> m (Blocked Term) slowReduceTerm :: Term -> ReduceM (Blocked Term) unfoldCorecursion :: Term -> ReduceM (Blocked Term) unfoldCorecursionE :: Elim -> ReduceM (Blocked Elim) unfoldDefinitionE :: Bool -> (Term -> ReduceM (Blocked Term)) -> Term -> QName -> Elims -> ReduceM (Blocked Term) unfoldDefinitionStep :: Bool -> Term -> QName -> Elims -> ReduceM (Reduced (Blocked Term) Term) -- | Unfold a single inlined function. unfoldInlined :: PureTCM m => Term -> m Term -- | Apply a defined function to it's arguments, using the original -- clauses. appDef' :: QName -> Term -> [Clause] -> RewriteRules -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Term) Term) appDefE' :: QName -> Term -> [Clause] -> RewriteRules -> MaybeReducedElims -> ReduceM (Reduced (Blocked Term) Term) -- | Throw pattern violation if blocked or a meta. abortIfBlocked :: (MonadReduce m, MonadBlock m, IsMeta t, Reduce t) => t -> m t -- | Case on whether a term is blocked on a meta (or is a meta). That means -- it can change its shape when the meta is instantiated. ifBlocked :: (Reduce t, IsMeta t, MonadReduce m) => t -> (Blocker -> t -> m a) -> (NotBlocked -> t -> m a) -> m a isBlocked :: (Reduce t, IsMeta t, MonadReduce m) => t -> m (Maybe Blocker) -- | Only unfold definitions if this leads to simplification which means -- that a constructor/literal pattern is matched. We include reduction of -- IApply patterns, as `p i0` is akin to matcing on the i0 -- constructor of interval. class Simplify t simplify :: (Simplify a, MonadReduce m) => a -> m a simplifyBlocked' :: Simplify t => Blocked t -> ReduceM t class Normalise t normalise' :: Normalise t => t -> ReduceM t normalise :: (Normalise a, MonadReduce m) => a -> m a slowNormaliseArgs :: Term -> ReduceM Term instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull [t] instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Data.HashMap.Internal.HashMap k t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Data.Map.Internal.Map k t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Data.Strict.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Elim.Elim' t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Common.Named name t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.CompiledClause.WithArity t) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance (Agda.TypeChecking.Reduce.InstantiateFull a, Agda.TypeChecking.Reduce.InstantiateFull b) => Agda.TypeChecking.Reduce.InstantiateFull (a, b) instance (Agda.TypeChecking.Reduce.InstantiateFull a, Agda.TypeChecking.Reduce.InstantiateFull b, Agda.TypeChecking.Reduce.InstantiateFull c) => Agda.TypeChecking.Reduce.InstantiateFull (a, b, c) instance (Agda.TypeChecking.Reduce.InstantiateFull a, Agda.TypeChecking.Reduce.InstantiateFull b, Agda.TypeChecking.Reduce.InstantiateFull c, Agda.TypeChecking.Reduce.InstantiateFull d) => Agda.TypeChecking.Reduce.InstantiateFull (a, b, c, d) instance Agda.TypeChecking.Reduce.InstantiateFull GHC.Types.Bool instance Agda.TypeChecking.Reduce.InstantiateFull GHC.Types.Char instance Agda.TypeChecking.Reduce.InstantiateFull GHC.Types.Int instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Abstract.Name.ModuleName instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Abstract.Name.Name instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Scope.Base.Scope instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.ConHead instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.DBPatVar instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Type' t) instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Term instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Level instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Substitution instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.ConPatternInfo instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Pattern' a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.InstantiateFull a) => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Abs a) instance (Agda.TypeChecking.Reduce.InstantiateFull t, Agda.TypeChecking.Reduce.InstantiateFull e) => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Dom' t e) instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.Open t) instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Signature instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Section instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.InstantiateFull a) => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Definition instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Defn instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.ExtLamInfo instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.System instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.FunctionInverse instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.CompiledClause.Case a) instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Instantiation instance Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.Judgement Agda.Syntax.Common.MetaId) instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.RemoteMetaVariable instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Interface instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.Builtin a) instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Monad.Base.Candidate instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise [t] instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Data.Map.Internal.Map k t) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Data.Strict.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Common.Named name t) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Common.WithHiding t) instance (Agda.TypeChecking.Reduce.Normalise a, Agda.TypeChecking.Reduce.Normalise b) => Agda.TypeChecking.Reduce.Normalise (a, b) instance (Agda.TypeChecking.Reduce.Normalise a, Agda.TypeChecking.Reduce.Normalise b, Agda.TypeChecking.Reduce.Normalise c) => Agda.TypeChecking.Reduce.Normalise (a, b, c) instance Agda.TypeChecking.Reduce.Normalise GHC.Types.Bool instance Agda.TypeChecking.Reduce.Normalise GHC.Types.Char instance Agda.TypeChecking.Reduce.Normalise GHC.Types.Int instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.DBPatVar instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Internal.Type' t) instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Term instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Internal.Elim.Elim' t) instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Level instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.PlusLevel instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.Normalise a) => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Internal.Dom t) instance Agda.TypeChecking.Reduce.Normalise a => Agda.TypeChecking.Reduce.Normalise (Agda.TypeChecking.Monad.Base.Closure a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.Normalise a) => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.ConPatternInfo instance Agda.TypeChecking.Reduce.Normalise a => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Internal.Pattern' a) instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Monad.Base.Candidate instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify [t] instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Data.Map.Internal.Map k t) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Data.Strict.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Internal.Elim.Elim' t) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Common.Named name t) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance (Agda.TypeChecking.Reduce.Simplify a, Agda.TypeChecking.Reduce.Simplify b) => Agda.TypeChecking.Reduce.Simplify (a, b) instance (Agda.TypeChecking.Reduce.Simplify a, Agda.TypeChecking.Reduce.Simplify b, Agda.TypeChecking.Reduce.Simplify c) => Agda.TypeChecking.Reduce.Simplify (a, b, c) instance Agda.TypeChecking.Reduce.Simplify GHC.Types.Bool instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.Term instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Internal.Type' t) instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.Level instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.PlusLevel instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.Simplify a) => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Internal.Dom t) instance Agda.TypeChecking.Reduce.Simplify a => Agda.TypeChecking.Reduce.Simplify (Agda.TypeChecking.Monad.Base.Closure a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.Simplify a) => Agda.TypeChecking.Reduce.Simplify (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Reduce.Simplify Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.TypeChecking.Reduce.Simplify Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Reduce.Simplify Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Reduce.Simplify Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.TypeChecking.Reduce.Simplify Agda.TypeChecking.Monad.Base.Candidate instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.Type instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.Elim instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.Level instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.PlusLevel instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Reduce.Reduce a) => Agda.TypeChecking.Reduce.Reduce (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Reduce.Reduce t => Agda.TypeChecking.Reduce.Reduce [t] instance Agda.TypeChecking.Reduce.Reduce t => Agda.TypeChecking.Reduce.Reduce (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Reduce t => Agda.TypeChecking.Reduce.Reduce (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.Reduce.Reduce t => Agda.TypeChecking.Reduce.Reduce (Agda.Syntax.Internal.Dom t) instance (Agda.TypeChecking.Reduce.Reduce a, Agda.TypeChecking.Reduce.Reduce b) => Agda.TypeChecking.Reduce.Reduce (a, b) instance (Agda.TypeChecking.Reduce.Reduce a, Agda.TypeChecking.Reduce.Reduce b, Agda.TypeChecking.Reduce.Reduce c) => Agda.TypeChecking.Reduce.Reduce (a, b, c) instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.DeBruijnPattern instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.Term instance Agda.TypeChecking.Reduce.Reduce a => Agda.TypeChecking.Reduce.Reduce (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.Telescope instance Agda.TypeChecking.Reduce.Reduce Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Reduce.Reduce Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Reduce.Reduce e => Agda.TypeChecking.Reduce.Reduce (Data.Map.Internal.Map k e) instance Agda.TypeChecking.Reduce.Reduce Agda.TypeChecking.Monad.Base.Candidate instance Agda.TypeChecking.Reduce.Reduce Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Reduce.Reduce t => Agda.TypeChecking.Reduce.Reduce (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance Agda.TypeChecking.Reduce.IsMeta Agda.Syntax.Internal.Term instance Agda.TypeChecking.Reduce.IsMeta a => Agda.TypeChecking.Reduce.IsMeta (Agda.Syntax.Internal.Sort' a) instance Agda.TypeChecking.Reduce.IsMeta a => Agda.TypeChecking.Reduce.IsMeta (Agda.Syntax.Internal.Type'' t a) instance Agda.TypeChecking.Reduce.IsMeta a => Agda.TypeChecking.Reduce.IsMeta (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Reduce.IsMeta a => Agda.TypeChecking.Reduce.IsMeta (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Reduce.IsMeta a => Agda.TypeChecking.Reduce.IsMeta (Agda.Syntax.Internal.Level' a) instance Agda.TypeChecking.Reduce.IsMeta a => Agda.TypeChecking.Reduce.IsMeta (Agda.Syntax.Internal.PlusLevel' a) instance Agda.TypeChecking.Reduce.IsMeta Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate [t] instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Data.Map.Internal.Map k t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (GHC.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Data.Strict.Maybe.Maybe t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Abs t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Elim.Elim' t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Tele t) instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.TypeChecking.Monad.Base.IPBoundary' t) instance (Agda.TypeChecking.Reduce.Instantiate a, Agda.TypeChecking.Reduce.Instantiate b) => Agda.TypeChecking.Reduce.Instantiate (a, b) instance (Agda.TypeChecking.Reduce.Instantiate a, Agda.TypeChecking.Reduce.Instantiate b, Agda.TypeChecking.Reduce.Instantiate c) => Agda.TypeChecking.Reduce.Instantiate (a, b, c) instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Term instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Type' t) instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Level instance Agda.TypeChecking.Reduce.Instantiate t => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.PlusLevel' t) instance Agda.TypeChecking.Reduce.Instantiate a => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Blocked a) instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Blockers.Blocker instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Sort instance (Agda.TypeChecking.Reduce.Instantiate t, Agda.TypeChecking.Reduce.Instantiate e) => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Dom' t e) instance Agda.TypeChecking.Reduce.Instantiate a => Agda.TypeChecking.Reduce.Instantiate (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.Reduce.Instantiate Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.Reduce.Instantiate Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Reduce.Instantiate Agda.TypeChecking.Monad.Base.Candidate instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.EqualityView -- | Rewriting with arbitrary rules. -- -- The user specifies a relation symbol by the pragma {-# BUILTIN -- REWRITE rel #-} where rel should be of type Δ → -- (lhs rhs : A) → Set i. -- -- Then the user can add rewrite rules by the pragma {-# REWRITE q -- #-} where q should be a closed term of type Γ → rel -- us lhs rhs. -- -- We then intend to add a rewrite rule Γ ⊢ lhs ↦ rhs : B to -- the signature where B = A[us/Δ]. -- -- To this end, we normalize lhs, which should be of the form -- f ts for a Def-symbol f (postulate, -- function, data, record, constructor). Further, FV(ts) = -- dom(Γ). The rule q :: Γ ⊢ f ts ↦ rhs : B is added to the -- signature to the definition of f. -- -- When reducing a term Ψ ⊢ f vs is stuck, we try the rewrites -- for f, by trying to unify vs with ts. This -- is for now done by substituting fresh metas Xs for the bound variables -- in ts and checking equality with vs Ψ ⊢ (f -- ts)[XsΓ] = f vs : B[XsΓ] If successful (no open -- metas/constraints), we replace f vs by rhs[Xs/Γ] and -- continue reducing. module Agda.TypeChecking.Rewriting requireOptionRewriting :: TCM () -- | Check that the name given to the BUILTIN REWRITE is actually a -- relation symbol. I.e., its type should be of the form Δ → (lhs : -- A) (rhs : B) → Set ℓ. Note: we do not care about -- hiding/non-hiding of lhs and rhs. verifyBuiltinRewrite :: Term -> Type -> TCM () -- | Deconstructing a type into Δ → t → t' → core. data RelView RelView :: Telescope -> ListTel -> Dom Type -> Dom Type -> Type -> RelView -- | The whole telescope Δ, t, t'. [relViewTel] :: RelView -> Telescope -- | Δ. [relViewDelta] :: RelView -> ListTel -- | t. [relViewType] :: RelView -> Dom Type -- | t'. [relViewType'] :: RelView -> Dom Type -- | core. [relViewCore] :: RelView -> Type -- | Deconstructing a type into Δ → t → t' → core. Returns -- Nothing if not enough argument types. relView :: Type -> TCM (Maybe RelView) -- | Check the given rewrite rules and add them to the signature. addRewriteRules :: [QName] -> TCM () -- | Get domain of rewrite relation. rewriteRelationDom :: QName -> TCM (ListTel, Dom Type) -- | Check the validity of q : Γ → rel us lhs rhs as rewrite rule -- Γ ⊢ lhs ↦ rhs : B where B = A[us/Δ]. Remember that -- rel : Δ → A → A → Set i, so rel us : (lhs rhs : A[us/Δ]) -- → Set i. Returns the checked rewrite rule to be added to the -- signature. checkRewriteRule :: QName -> TCM RewriteRule -- | rewriteWith t f es rew where f : t tries to rewrite -- f es with rew, returning the reduct if successful. rewriteWith :: Type -> (Elims -> Term) -> RewriteRule -> Elims -> ReduceM (Either (Blocked Term) Term) -- | rewrite b v rules es tries to rewrite v applied to -- es with the rewrite rules rules. b is the -- default blocking tag. rewrite :: Blocked_ -> (Elims -> Term) -> RewriteRules -> Elims -> ReduceM (Reduced (Blocked Term) Term) -- | Various utility functions dealing with the non-linear, higher-order -- patterns used for rewrite rules. module Agda.TypeChecking.Rewriting.NonLinPattern -- | Turn a term into a non-linear pattern, treating the free variables as -- pattern variables. The first argument indicates the relevance we are -- working under: if this is Irrelevant, then we construct a pattern that -- never fails to match. The second argument is the number of bound -- variables (from pattern lambdas). The third argument is the type of -- the term. class PatternFrom t a b patternFrom :: PatternFrom t a b => Relevance -> Int -> t -> a -> TCM b -- | Convert from a non-linear pattern to a term. class NLPatToTerm p a nlPatToTerm :: (NLPatToTerm p a, PureTCM m) => p -> m a nlPatToTerm :: (NLPatToTerm p a, NLPatToTerm p' a', Traversable f, p ~ f p', a ~ f a', PureTCM m) => p -> m a -- | Gather the set of pattern variables of a non-linear pattern class NLPatVars a nlPatVarsUnder :: NLPatVars a => Int -> a -> IntSet nlPatVars :: NLPatVars a => a -> IntSet -- | Get all symbols that a non-linear pattern matches against class GetMatchables a getMatchables :: GetMatchables a => a -> [QName] getMatchables :: (GetMatchables a, Foldable f, GetMatchables a', a ~ f a') => a -> [QName] blockOnMetasIn :: (MonadBlock m, AllMetas t) => t -> m () assertPi :: Type -> TCM (Dom Type, Abs Type) errNotPi :: Type -> TCM a assertPath :: Type -> TCM (Sort, QName, Arg Term, Arg Term, Arg Term, Arg Term) errNotPath :: Type -> TCM a assertProjOf :: QName -> Type -> TCM (Dom Type, Abs Type) errNotProjOf :: QName -> Type -> TCM a assertConOf :: ConHead -> Type -> TCM Type errNotConOf :: ConHead -> Type -> TCM a instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables a => Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables [a] instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables a => Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables a => Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables a => Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables a => Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables (Agda.Syntax.Internal.Abs a) instance (Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables a, Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables b) => Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables (a, b) instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables Agda.Syntax.Internal.Term instance Agda.TypeChecking.Rewriting.NonLinPattern.GetMatchables Agda.TypeChecking.Monad.Base.RewriteRule instance (Data.Foldable.Foldable f, Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars a) => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars (f a) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars Agda.TypeChecking.Monad.Base.NLPat instance (Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars a, Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars b) => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars (a, b) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars a => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatVars (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm p a => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm [p] [a] instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm p a => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm (Agda.Syntax.Common.Arg p) (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm p a => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm (Agda.Syntax.Internal.Dom p) (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm p a => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm (Agda.Syntax.Internal.Elim.Elim' p) (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm p a => Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm (Agda.Syntax.Internal.Abs p) (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm Agda.Syntax.Common.Nat Agda.Syntax.Internal.Term instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm Agda.TypeChecking.Monad.Base.NLPat Agda.Syntax.Internal.Term instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm Agda.TypeChecking.Monad.Base.NLPat Agda.Syntax.Internal.Level instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm Agda.TypeChecking.Monad.Base.NLPType Agda.Syntax.Internal.Type instance Agda.TypeChecking.Rewriting.NonLinPattern.NLPatToTerm Agda.TypeChecking.Monad.Base.NLPSort Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom t a b => Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom (Agda.Syntax.Internal.Dom t) (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b) instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom (Agda.Syntax.Internal.Type, Agda.Syntax.Internal.Term) Agda.Syntax.Internal.Elims [Agda.Syntax.Internal.Elim.Elim' Agda.TypeChecking.Monad.Base.NLPat] instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom t a b => Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom t (Agda.Syntax.Internal.Dom a) (Agda.Syntax.Internal.Dom b) instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom () Agda.Syntax.Internal.Type Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom () Agda.Syntax.Internal.Sort Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom () Agda.Syntax.Internal.Level Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Rewriting.NonLinPattern.PatternFrom Agda.Syntax.Internal.Type Agda.Syntax.Internal.Term Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.NLPSort module Agda.TypeChecking.Records mkCon :: ConHead -> ConInfo -> Args -> Term -- | Order the fields of a record construction. orderFields :: forall a. HasRange a => QName -> (Arg Name -> a) -> [Arg Name] -> [(Name, a)] -> Writer [RecordFieldWarning] [a] -- | Raise generated RecordFieldWarnings as warnings. warnOnRecordFieldWarnings :: Writer [RecordFieldWarning] a -> TCM a -- | Raise generated RecordFieldWarnings as errors. failOnRecordFieldWarnings :: Writer [RecordFieldWarning] a -> TCM a -- | Order the fields of a record construction. Raise generated -- RecordFieldWarnings as warnings. orderFieldsWarn :: forall a. HasRange a => QName -> (Arg Name -> a) -> [Arg Name] -> [(Name, a)] -> TCM [a] -- | Order the fields of a record construction. Raise generated -- RecordFieldWarnings as errors. orderFieldsFail :: forall a. HasRange a => QName -> (Arg Name -> a) -> [Arg Name] -> [(Name, a)] -> TCM [a] -- | A record field assignment record{xs = es} might not mention -- all visible fields. insertMissingFields inserts placeholders -- for the missing visible fields and returns the values in order of the -- fields in the record declaration. insertMissingFields :: forall a. HasRange a => QName -> (Name -> a) -> [FieldAssignment' a] -> [Arg Name] -> Writer [RecordFieldWarning] [NamedArg a] -- | A record field assignment record{xs = es} might not mention -- all visible fields. insertMissingFields inserts placeholders -- for the missing visible fields and returns the values in order of the -- fields in the record declaration. insertMissingFieldsWarn :: forall a. HasRange a => QName -> (Name -> a) -> [FieldAssignment' a] -> [Arg Name] -> TCM [NamedArg a] -- | A record field assignment record{xs = es} might not mention -- all visible fields. insertMissingFields inserts placeholders -- for the missing visible fields and returns the values in order of the -- fields in the record declaration. insertMissingFieldsFail :: forall a. HasRange a => QName -> (Name -> a) -> [FieldAssignment' a] -> [Arg Name] -> TCM [NamedArg a] -- | Get the definition for a record. Throws an exception if the name does -- not refer to a record or the record is abstract. getRecordDef :: (HasConstInfo m, ReadTCState m, MonadError TCErr m) => QName -> m Defn -- | Get the record name belonging to a field name. getRecordOfField :: QName -> TCM (Maybe QName) -- | Get the field names of a record. getRecordFieldNames :: (HasConstInfo m, ReadTCState m, MonadError TCErr m) => QName -> m [Dom Name] getRecordFieldNames_ :: (HasConstInfo m, ReadTCState m) => QName -> m (Maybe [Dom Name]) recordFieldNames :: Defn -> [Dom Name] -- | Find all records with at least the given fields. findPossibleRecords :: [Name] -> TCM [QName] -- | Get the field types of a record. getRecordFieldTypes :: QName -> TCM Telescope -- | Get the field names belonging to a record type. getRecordTypeFields :: Type -> TCM [Dom QName] -- | Returns the given record type's constructor name (with an empty -- range). getRecordConstructor :: (HasConstInfo m, ReadTCState m, MonadError TCErr m) => QName -> m ConHead -- | Check if a name refers to a record. If yes, return record definition. isRecord :: HasConstInfo m => QName -> m (Maybe Defn) -- | Reduce a type and check whether it is a record type. Succeeds only if -- type is not blocked by a meta var. If yes, return its name, -- parameters, and definition. isRecordType :: PureTCM m => Type -> m (Maybe (QName, Args, Defn)) -- | Reduce a type and check whether it is a record type. Succeeds only if -- type is not blocked by a meta var. If yes, return its name, -- parameters, and definition. If no, return the reduced type (unless it -- is blocked). tryRecordType :: PureTCM m => Type -> m (Either (Blocked Type) (QName, Args, Defn)) -- | Get the original projection info for name. origProjection :: HasConstInfo m => QName -> m (QName, Definition, Maybe Projection) -- | getDefType f t computes the type of (possibly -- projection-(like)) function f whose first argument has type -- t. The parameters for f are extracted from -- t. Nothing if f is projection(like) but -- t is not a datarecordaxiom type. -- -- Precondition: t is reduced. -- -- See also: getConType getDefType :: PureTCM m => QName -> Type -> m (Maybe Type) -- | The analogue of piApply. If v is a value of record -- type t with field f, then projectTyped v t -- f returns the type of f v. And also the record type (as -- first result). -- -- Works also for projection-like definitions f. In this case, -- the first result is not a record type. -- -- Precondition: t is reduced. projectTyped :: PureTCM m => Term -> Type -> ProjOrigin -> QName -> m (Maybe (Dom Type, Term, Type)) -- | Typing of an elimination. data ElimType -- | Type of the argument. ArgT :: Dom Type -> ElimType ProjT :: Dom Type -> Type -> ElimType -- | The type of the record which is eliminated. [projTRec] :: ElimType -> Dom Type -- | The type of the field. [projTField] :: ElimType -> Type -- | Given a head and its type, compute the types of the eliminations. typeElims :: Type -> Term -> Elims -> TCM [ElimType] -- | Check if a name refers to an eta expandable record. -- -- The answer is no for a record type with an erased constructor unless -- the current quantity is "erased". isEtaRecord :: HasConstInfo m => QName -> m Bool isEtaCon :: HasConstInfo m => QName -> m Bool -- | Going under one of these does not count as a decrease in size for the -- termination checker. isEtaOrCoinductiveRecordConstructor :: HasConstInfo m => QName -> m Bool -- | Check if a name refers to a record which is not coinductive. -- (Projections are then size-preserving) isInductiveRecord :: QName -> TCM Bool -- | Check if a type is an eta expandable record and return the record -- identifier and the parameters. isEtaRecordType :: HasConstInfo m => Type -> m (Maybe (QName, Args)) -- | Check if a name refers to a record constructor. If yes, return record -- definition. isRecordConstructor :: HasConstInfo m => QName -> m (Maybe (QName, Defn)) -- | Check if a constructor name is the internally generated record -- constructor. -- -- Works also for abstract constructors. isGeneratedRecordConstructor :: (MonadTCEnv m, HasConstInfo m) => QName -> m Bool -- | Turn off eta for unguarded recursive records. Projections do not -- preserve guardedness. unguardedRecord :: QName -> PatternOrCopattern -> TCM () -- | Turn on eta for non-recursive and inductive guarded recursive records, -- unless user declared otherwise. Projections do not preserve -- guardedness. updateEtaForRecord :: QName -> TCM () -- | Turn on eta for inductive guarded recursive records. Projections do -- not preserve guardedness. recursiveRecord :: QName -> TCM () -- | Turn on eta for non-recursive record, unless user declared otherwise. nonRecursiveRecord :: QName -> TCM () -- | Check whether record type is marked as recursive. -- -- Precondition: record type identifier exists in signature. isRecursiveRecord :: QName -> TCM Bool -- |
--   etaExpandBoundVar i = (Δ, σ, τ)
--   
-- -- Precondition: The current context is Γ = Γ₁, x:R pars, Γ₂ -- where |Γ₂| = i and R is a eta-expandable record type -- with constructor c and fields Γ'. -- -- Postcondition: Δ = Γ₁, Γ', Γ₂[c Γ'] and Γ ⊢ σ : Δ -- and Δ ⊢ τ : Γ. etaExpandBoundVar :: Int -> TCM (Maybe (Telescope, Substitution, Substitution)) -- |
--   expandRecordVar i Γ = (Δ, σ, τ, Γ')
--   
-- -- Precondition: Γ = Γ₁, x:R pars, Γ₂ where |Γ₂| = i -- and R is a eta-expandable record type with constructor -- c and fields Γ'. -- -- Postcondition: Δ = Γ₁, Γ', Γ₂[c Γ'] and Γ ⊢ σ : Δ -- and Δ ⊢ τ : Γ. expandRecordVar :: PureTCM m => Int -> Telescope -> m (Maybe (Telescope, Substitution, Substitution, Telescope)) -- | Precondition: variable list is ordered descendingly. Can be empty. expandRecordVarsRecursively :: [Int] -> Telescope -> TCM (Telescope, Substitution, Substitution) -- |
--   curryAt v (Γ (y : R pars) -> B) n =
--        (  v -> λ Γ ys → v Γ (c ys)            {- curry   -}
--        ,  v -> λ Γ y → v Γ (p1 y) ... (pm y)  {- uncurry -}
--        , Γ (ys : As) → B[c ys / y]
--        )
--   
-- -- where n = size Γ. curryAt :: Type -> Int -> TCM (Term -> Term, Term -> Term, Type) -- | etaExpand r pars u computes the eta expansion of record value -- u at record type r pars. -- -- The first argument r should be the name of an eta-expandable -- record type. Given -- --
--   record R : Set where field x : A; y : B; .z : C
--   
-- -- and r : R, -- --
--   etaExpand R [] r = (tel, [R.x r, R.y r, R.z r])
--   
-- -- where tel is the record telescope instantiated at the -- parameters pars. etaExpandRecord :: (HasConstInfo m, MonadDebug m, ReadTCState m) => QName -> Args -> Term -> m (Telescope, Args) -- | Eta expand a record regardless of whether it's an eta-record or not. forceEtaExpandRecord :: (HasConstInfo m, MonadDebug m, ReadTCState m, MonadError TCErr m) => QName -> Args -> Term -> m (Telescope, Args) etaExpandRecord' :: (HasConstInfo m, MonadDebug m, ReadTCState m) => Bool -> QName -> Args -> Term -> m (Telescope, Args) etaExpandRecord_ :: HasConstInfo m => QName -> Args -> Defn -> Term -> m (Telescope, ConHead, ConInfo, Args) etaExpandRecord'_ :: HasConstInfo m => Bool -> QName -> Args -> Defn -> Term -> m (Telescope, ConHead, ConInfo, Args) etaExpandAtRecordType :: Type -> Term -> TCM (Telescope, Term) -- | The fields should be eta contracted already. -- -- We can eta contract if all fields f = ... are irrelevant or -- all fields f are the projection f v of the same -- value v, but we need at least one relevant field to find the -- value v. -- -- If all fields are erased, we cannot eta-contract. etaContractRecord :: HasConstInfo m => QName -> ConHead -> ConInfo -> Args -> m Term -- | Is the type a hereditarily singleton record type? May return a -- blocking metavariable. -- -- Precondition: The name should refer to a record type, and the -- arguments should be the parameters to the type. isSingletonRecord :: (PureTCM m, MonadBlock m) => QName -> Args -> m Bool isSingletonRecordModuloRelevance :: (PureTCM m, MonadBlock m) => QName -> Args -> m Bool -- | Return the unique (closed) inhabitant if exists. In case of counting -- irrelevance in, the returned inhabitant contains dummy terms. isSingletonRecord' :: forall m. (PureTCM m, MonadBlock m) => Bool -> QName -> Args -> Set QName -> m (Maybe Term) -- | Check whether a type has a unique inhabitant and return it. Can be -- blocked by a metavar. isSingletonType :: (PureTCM m, MonadBlock m) => Type -> m (Maybe Term) -- | Check whether a type has a unique inhabitant (irrelevant parts -- ignored). Can be blocked by a metavar. isSingletonTypeModuloRelevance :: (PureTCM m, MonadBlock m) => Type -> m Bool isSingletonType' :: forall m. (PureTCM m, MonadBlock m) => Bool -> Type -> Set QName -> m (Maybe Term) -- | Checks whether the given term (of the given type) is -- beta-eta-equivalent to a variable. Returns just the de Bruijn-index of -- the variable if it is, or nothing otherwise. isEtaVar :: forall m. PureTCM m => Term -> Type -> m (Maybe Int) -- | Replace projection patterns by the original projections. class NormaliseProjP a normaliseProjP :: (NormaliseProjP a, HasConstInfo m) => a -> m a instance Agda.TypeChecking.Records.NormaliseProjP Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Records.NormaliseProjP a => Agda.TypeChecking.Records.NormaliseProjP [a] instance Agda.TypeChecking.Records.NormaliseProjP a => Agda.TypeChecking.Records.NormaliseProjP (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Records.NormaliseProjP a => Agda.TypeChecking.Records.NormaliseProjP (Agda.Syntax.Common.Named_ a) instance Agda.TypeChecking.Records.NormaliseProjP (Agda.Syntax.Internal.Pattern' x) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Records.ElimType module Agda.TypeChecking.Reduce.Monad constructorForm :: HasBuiltins m => Term -> m Term enterClosure :: LensClosure a c => c -> (a -> ReduceM b) -> ReduceM b -- | Lookup the definition of a name. The result is a closed thing, all -- free variables have been abstracted over. getConstInfo :: HasConstInfo m => QName -> m Definition askR :: ReduceM ReduceEnv -- | Apply a function 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 instance Agda.TypeChecking.Monad.Builtin.HasBuiltins Agda.TypeChecking.Monad.Base.ReduceM instance Agda.TypeChecking.Monad.Context.MonadAddContext Agda.TypeChecking.Monad.Base.ReduceM instance Agda.TypeChecking.Monad.Debug.MonadDebug Agda.TypeChecking.Monad.Base.ReduceM instance Agda.TypeChecking.Monad.Signature.HasConstInfo Agda.TypeChecking.Monad.Base.ReduceM instance Agda.TypeChecking.Monad.Pure.PureTCM Agda.TypeChecking.Monad.Base.ReduceM module Agda.TypeChecking.Monad module Agda.TypeChecking.Monad.Trace interestingCall :: Call -> Bool class (MonadTCEnv m, ReadTCState m) => MonadTrace m -- | Record a function call in the trace. traceCall :: MonadTrace m => Call -> m a -> m a traceCallM :: MonadTrace m => m Call -> m a -> m a -- | 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 -- Call, we will revert to the last interesting call. traceCallCPS :: MonadTrace m => Call -> ((a -> m b) -> m b) -> (a -> m b) -> m b traceClosureCall :: MonadTrace m => Closure Call -> m a -> m a -- | Lispify and print the given highlighting information. printHighlightingInfo :: MonadTrace m => RemoveTokenBasedHighlighting -> HighlightingInfo -> m () -- | Lispify and print the given highlighting information. printHighlightingInfo :: (MonadTrace m, MonadTrans t, MonadTrace n, t n ~ m) => RemoveTokenBasedHighlighting -> HighlightingInfo -> m () getCurrentRange :: MonadTCEnv m => m Range -- | 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). setCurrentRange :: (MonadTrace m, HasRange x) => x -> m a -> m a -- | highlightAsTypeChecked rPre r m runs m and returns -- its result. Additionally, some code may be highlighted: -- -- highlightAsTypeChecked :: MonadTrace m => Range -> Range -> m a -> m a instance Agda.TypeChecking.Monad.Trace.MonadTrace m => Agda.TypeChecking.Monad.Trace.MonadTrace (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Trace.MonadTrace m => Agda.TypeChecking.Monad.Trace.MonadTrace (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Trace.MonadTrace m => Agda.TypeChecking.Monad.Trace.MonadTrace (Control.Monad.Trans.State.Lazy.StateT s m) instance (Agda.TypeChecking.Monad.Trace.MonadTrace m, GHC.Base.Monoid w) => Agda.TypeChecking.Monad.Trace.MonadTrace (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Trace.MonadTrace m => Agda.TypeChecking.Monad.Trace.MonadTrace (Control.Monad.Trans.Except.ExceptT e m) instance Agda.TypeChecking.Monad.Trace.MonadTrace Agda.TypeChecking.Monad.Base.TCM -- | Collect statistics. module Agda.TypeChecking.Monad.Statistics class ReadTCState m => MonadStatistics m modifyCounter :: MonadStatistics m => String -> (Integer -> Integer) -> m () modifyCounter :: (MonadStatistics m, MonadStatistics n, MonadTrans t, t n ~ m) => String -> (Integer -> Integer) -> m () -- | Increase specified counter by 1. tick :: MonadStatistics m => String -> m () -- | Increase specified counter by n. tickN :: MonadStatistics m => String -> Integer -> m () -- | Set the specified counter to the maximum of its current value and -- n. tickMax :: MonadStatistics m => String -> Integer -> m () -- | Get the statistics. getStatistics :: ReadTCState m => m Statistics -- | Modify the statistics via given function. modifyStatistics :: (Statistics -> Statistics) -> TCM () -- | Print the given statistics. printStatistics :: (MonadDebug m, MonadTCEnv m, HasOptions m) => Maybe TopLevelModuleName -> Statistics -> m () instance Agda.TypeChecking.Monad.Statistics.MonadStatistics m => Agda.TypeChecking.Monad.Statistics.MonadStatistics (Control.Monad.Trans.Except.ExceptT e m) instance Agda.TypeChecking.Monad.Statistics.MonadStatistics m => Agda.TypeChecking.Monad.Statistics.MonadStatistics (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Statistics.MonadStatistics m => Agda.TypeChecking.Monad.Statistics.MonadStatistics (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Statistics.MonadStatistics m => Agda.TypeChecking.Monad.Statistics.MonadStatistics (Control.Monad.Trans.State.Lazy.StateT s m) instance (Agda.TypeChecking.Monad.Statistics.MonadStatistics m, GHC.Base.Monoid w) => Agda.TypeChecking.Monad.Statistics.MonadStatistics (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Statistics.MonadStatistics Agda.TypeChecking.Monad.Base.TCM -- | Stuff for sized types that does not require modules -- Agda.TypeChecking.Reduce or -- Agda.TypeChecking.Constraints (which import -- Agda.TypeChecking.Monad). module Agda.TypeChecking.Monad.SizedTypes -- | Result of querying whether size variable i is bounded by -- another size. data BoundedSize -- | yes i : Size< t BoundedLt :: Term -> BoundedSize BoundedNo :: BoundedSize -- | Check if a type is the primSize type. The argument should be -- reduced. class IsSizeType a isSizeType :: (IsSizeType a, HasOptions m, HasBuiltins m) => a -> m (Maybe BoundedSize) 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) -- | Test whether OPTIONS --sized-types and whether the size built-ins are -- defined. haveSizedTypes :: TCM Bool -- | Test whether the SIZELT builtin is defined. haveSizeLt :: TCM Bool -- | Add polarity info to a SIZE builtin. builtinSizeHook :: String -> QName -> Type -> TCM () -- | The sort of built-in types SIZE and SIZELT. sizeSort :: Sort -- | The type of built-in types SIZE and SIZELT. sizeUniv :: Type -- | The built-in type SIZE with user-given name. sizeType_ :: QName -> Type -- | The built-in type SIZE. sizeType :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => m Type -- | The name of SIZESUC. sizeSucName :: (HasBuiltins m, HasOptions m) => m (Maybe QName) sizeSuc :: HasBuiltins m => Nat -> Term -> m Term sizeSuc_ :: QName -> Term -> Term -- | Transform list of terms into a term build from binary maximum. sizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => List1 Term -> m Term -- | A useful view on sizes. data SizeView SizeInf :: SizeView SizeSuc :: Term -> SizeView OtherSize :: Term -> SizeView -- | Expects argument to be reduced. sizeView :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => Term -> m SizeView -- | A de Bruijn index under some projections. data ProjectedVar ProjectedVar :: Int -> [(ProjOrigin, QName)] -> ProjectedVar [pvIndex] :: ProjectedVar -> Int [prProjs] :: ProjectedVar -> [(ProjOrigin, QName)] viewProjectedVar :: Term -> Maybe ProjectedVar unviewProjectedVar :: ProjectedVar -> Term type Offset = Nat -- | A deep view on sizes. data DeepSizeView DSizeInf :: DeepSizeView DSizeVar :: ProjectedVar -> Offset -> DeepSizeView DSizeMeta :: MetaId -> Elims -> Offset -> DeepSizeView DOtherSize :: Term -> DeepSizeView data SizeViewComparable a NotComparable :: SizeViewComparable a YesAbove :: DeepSizeView -> a -> SizeViewComparable a YesBelow :: DeepSizeView -> a -> SizeViewComparable a -- | sizeViewComparable v w checks whether v >= w -- (then Left) or v <= w (then Right). If -- uncomparable, it returns NotComparable. sizeViewComparable :: DeepSizeView -> DeepSizeView -> SizeViewComparable () sizeViewSuc_ :: QName -> DeepSizeView -> DeepSizeView -- | sizeViewPred k v decrements v by k (must be -- possible!). sizeViewPred :: Nat -> DeepSizeView -> DeepSizeView -- | sizeViewOffset v returns the number of successors or Nothing -- when infty. sizeViewOffset :: DeepSizeView -> Maybe Offset -- | Remove successors common to both sides. removeSucs :: (DeepSizeView, DeepSizeView) -> (DeepSizeView, DeepSizeView) -- | Turn a size view into a term. unSizeView :: SizeView -> TCM Term unDeepSizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => DeepSizeView -> m Term type SizeMaxView = List1 DeepSizeView type SizeMaxView' = [DeepSizeView] maxViewMax :: SizeMaxView -> SizeMaxView -> SizeMaxView -- | maxViewCons v ws = max v ws. It only adds v to -- ws if it is not subsumed by an element of ws. maxViewCons :: DeepSizeView -> SizeMaxView -> SizeMaxView -- | sizeViewComparableWithMax v ws tries to find w in -- ws that compares with v and singles this out. -- Precondition: v /= DSizeInv. sizeViewComparableWithMax :: DeepSizeView -> SizeMaxView -> SizeViewComparable SizeMaxView' maxViewSuc_ :: QName -> SizeMaxView -> SizeMaxView unMaxView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => SizeMaxView -> m Term instance GHC.Show.Show Agda.TypeChecking.Monad.SizedTypes.BoundedSize instance GHC.Classes.Eq Agda.TypeChecking.Monad.SizedTypes.BoundedSize instance GHC.Show.Show Agda.TypeChecking.Monad.SizedTypes.ProjectedVar instance GHC.Show.Show Agda.TypeChecking.Monad.SizedTypes.DeepSizeView instance GHC.Base.Functor Agda.TypeChecking.Monad.SizedTypes.SizeViewComparable instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.SizedTypes.DeepSizeView instance GHC.Classes.Eq Agda.TypeChecking.Monad.SizedTypes.ProjectedVar instance Agda.TypeChecking.Monad.SizedTypes.IsSizeType a => Agda.TypeChecking.Monad.SizedTypes.IsSizeType (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Monad.SizedTypes.IsSizeType a => Agda.TypeChecking.Monad.SizedTypes.IsSizeType (b, a) instance Agda.TypeChecking.Monad.SizedTypes.IsSizeType a => Agda.TypeChecking.Monad.SizedTypes.IsSizeType (Agda.Syntax.Internal.Type' a) instance Agda.TypeChecking.Monad.SizedTypes.IsSizeType Agda.Syntax.Internal.Term instance Agda.TypeChecking.Monad.SizedTypes.IsSizeType Agda.TypeChecking.Monad.Base.CompareAs module Agda.TypeChecking.Monad.Builtin class (Functor m, Applicative m, MonadFail m) => HasBuiltins m getBuiltinThing :: HasBuiltins m => String -> m (Maybe (Builtin PrimFun)) getBuiltinThing :: (HasBuiltins m, MonadTrans t, HasBuiltins n, t n ~ m) => String -> m (Maybe (Builtin PrimFun)) -- | Revert the EqualityView. -- -- Postcondition: type is reduced. class EqualityUnview a equalityUnview :: EqualityUnview a => a -> Type -- | Sort primitives. data SortKit SortKit :: QName -> QName -> QName -> (IsFibrant -> QName) -> SortKit [nameOfSet] :: SortKit -> QName [nameOfProp] :: SortKit -> QName [nameOfSSet] :: SortKit -> QName [nameOfSetOmega] :: SortKit -> IsFibrant -> QName -- | The coinductive primitives. data CoinductionKit CoinductionKit :: QName -> QName -> QName -> CoinductionKit [nameOfInf] :: CoinductionKit -> QName [nameOfSharp] :: CoinductionKit -> QName [nameOfFlat] :: CoinductionKit -> 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 () -- | Add one (more) relation symbol to the rewrite relations. bindBuiltinRewriteRelation :: QName -> TCM () -- | Get the currently registered rewrite relation symbols. getBuiltinRewriteRelations :: HasBuiltins m => m (Maybe (Set QName)) getBuiltin :: (HasBuiltins m, MonadTCError 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 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. getTerm :: HasBuiltins m => String -> String -> m Term -- | Rewrite a literal to constructor form if possible. constructorForm :: HasBuiltins m => Term -> m Term constructorForm' :: Applicative m => m Term -> m Term -> Term -> m Term primInteger :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIntegerPos :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIntegerNegSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFloat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primChar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primBool :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSigma :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primUnitUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primTrue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFalse :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primList :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primNil :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primCons :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primMaybe :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primNothing :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primJust :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIO :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primConId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIdElim :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPath :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPathP :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIntervalUniv :: (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 primLevel :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLevelZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLevelSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLevelMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primLockUniv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primSSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primStrictSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFromNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFromNeg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFromString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArgArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAbsAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primHiding :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primHidden :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primInstance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primVisible :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primRelevance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primRelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primIrrelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQuantity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQuantity0 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primQuantityω :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primModality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primModalityConstructor :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssoc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssocLeft :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssocRight :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAssocNon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPrecedence :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPrecRelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primPrecUnrelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primFixityFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primArgArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortPropLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaSortUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermVar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermExtLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermCon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermPi :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTermMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPart :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPartString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPartTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaErrorPartPatt :: (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 primAgdaTCMDeclareData :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDefineData :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDefineFun :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMGetType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMGetDefinition :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMQuoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMQuoteOmegaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMUnquoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMBlockOnMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMCommit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMIsMacro :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMWithNormalisation :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMWithReconsParams :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMFormatErrorParts :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDebugPrint :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMOnlyReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMDontReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMNoConstraints :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMRunSpeculative :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMExec :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term primAgdaTCMGetInstances :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term -- | Tries to build a CoinductionKit. coinductionKit' :: TCM CoinductionKit coinductionKit :: TCM (Maybe CoinductionKit) -- | Compute a SortKit in an environment that supports failures. -- -- When optLoadPrimitives is set to False, sortKit -- is a fallible operation, so for the uses of sortKit in fallible -- contexts (e.g. TCMT), we report a type error rather than -- exploding. sortKit :: (HasBuiltins m, MonadTCError m, HasOptions m) => m SortKit -- | Compute a SortKit in contexts that do not support failure (e.g. -- Reify). This should only be used when we are sure that the -- primitive sorts have been bound, i.e. because it is "after" type -- checking. infallibleSortKit :: HasBuiltins m => m SortKit getPrimName :: Term -> QName getBuiltinName' :: HasBuiltins m => String -> m (Maybe QName) getPrimitiveName' :: HasBuiltins m => String -> m (Maybe QName) isPrimitive :: HasBuiltins m => String -> QName -> m Bool intervalSort :: Sort intervalView' :: HasBuiltins m => m (Term -> IntervalView) intervalView :: HasBuiltins m => Term -> m IntervalView intervalUnview :: HasBuiltins m => IntervalView -> m Term intervalUnview' :: HasBuiltins m => m (IntervalView -> Term) -- | Check whether the type is actually an path (lhs ≡ rhs) and extract -- lhs, rhs, and their type. -- -- Precondition: type is reduced. pathView :: HasBuiltins m => Type -> m PathView pathView' :: HasBuiltins m => m (Type -> PathView) -- | Non dependent Path idViewAsPath :: HasBuiltins m => Type -> m PathView boldPathView :: Type -> PathView -- | Revert the PathView. -- -- Postcondition: type is reduced. pathUnview :: PathView -> Type conidView' :: HasBuiltins m => m (Term -> Term -> Maybe (Arg Term, Arg Term)) -- | Get the name of the equality type. primEqualityName :: TCM QName -- | Check whether the type is actually an equality (lhs ≡ rhs) and extract -- lhs, rhs, and their type. -- -- Precondition: type is reduced. equalityView :: Type -> TCM EqualityView -- | Primitives with typechecking constrants. constrainedPrims :: [String] getNameOfConstrained :: HasBuiltins m => String -> m (Maybe QName) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Builtin.EqualityUnview Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Monad.Builtin.EqualityUnview Agda.Syntax.Internal.EqualityTypeData instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Control.Monad.Trans.Except.ExceptT e m) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Control.Monad.Trans.Reader.ReaderT e m) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Control.Monad.Trans.State.Lazy.StateT s m) instance (Agda.TypeChecking.Monad.Builtin.HasBuiltins m, GHC.Base.Monoid w) => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.TypeChecking.Monad.Base.TCMT m) module Agda.TypeChecking.Monad.Signature -- | Add a constant to the signature. Lifts the definition to top level. addConstant :: QName -> Definition -> TCM () -- | A combination of addConstant and defaultDefn. The -- Language does not need to be supplied. addConstant' :: QName -> ArgInfo -> QName -> Type -> Defn -> TCM () -- | Set termination info of a defined function symbol. setTerminates :: MonadTCState m => QName -> Bool -> m () -- | Set CompiledClauses of a defined function symbol. setCompiledClauses :: QName -> CompiledClauses -> TCM () -- | Set SplitTree of a defined function symbol. setSplitTree :: QName -> SplitTree -> TCM () -- | Modify the clauses of a function. modifyFunClauses :: QName -> ([Clause] -> [Clause]) -> TCM () -- | Lifts clauses to the top-level and adds them to definition. Also -- adjusts the funCopatternLHS field if necessary. addClauses :: (MonadConstraint m, MonadTCState m) => QName -> [Clause] -> m () mkPragma :: String -> TCM CompilerPragma -- | Add a compiler pragma `{-# COMPILE backend name -- text #-}` addPragma :: BackendName -> QName -> String -> TCM () getUniqueCompilerPragma :: BackendName -> QName -> TCM (Maybe CompilerPragma) setFunctionFlag :: FunctionFlag -> Bool -> QName -> TCM () markStatic :: QName -> TCM () markInline :: Bool -> QName -> TCM () markInjective :: QName -> TCM () unionSignatures :: [Signature] -> Signature -- | Add a section to the signature. -- -- The current context will be stored as the cumulative module parameters -- for this section. addSection :: ModuleName -> TCM () -- | Sets the checkpoint for the given module to the current checkpoint. setModuleCheckpoint :: ModuleName -> TCM () -- | 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. getSection :: (Functor m, ReadTCState m) => ModuleName -> m (Maybe Section) -- | Lookup a section telescope. -- -- If it doesn't exist, like in hierarchical top-level modules, the -- section telescope is empty. lookupSection :: (Functor m, ReadTCState m) => ModuleName -> m Telescope -- | Add display forms for a name f copied by a module -- application. Essentially if f can reduce to -- --
--   λ xs → A.B.C.f vs
--   
-- -- by unfolding module application copies (defCopy), then we add a -- display form -- --
--   A.B.C.f vs ==> f xs
--   
addDisplayForms :: QName -> TCM () -- | Module application (followed by module parameter abstraction). applySection :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM () applySection' :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM () -- | Add a display form to a definition (could be in this or imported -- signature). addDisplayForm :: QName -> DisplayForm -> TCM () isLocal :: ReadTCState m => QName -> m Bool getDisplayForms :: (HasConstInfo m, ReadTCState m) => QName -> m [LocalDisplayForm] -- | Find all names used (recursively) by display forms of a given name. chaseDisplayForms :: QName -> TCM (Set QName) -- | Check if a display form is looping. hasLoopingDisplayForm :: QName -> TCM Bool canonicalName :: HasConstInfo m => QName -> m QName sameDef :: HasConstInfo m => QName -> QName -> m (Maybe QName) -- | Can be called on either a (co)datatype, a record type or a -- (co)constructor. whatInduction :: MonadTCM tcm => QName -> tcm Induction -- | Does the given constructor come from a single-constructor type? -- -- Precondition: The name has to refer to a constructor. singleConstructorType :: QName -> TCM Bool -- | Signature lookup errors. data SigError -- | The name is not in the signature; default error message. SigUnknown :: String -> SigError -- | The name is not available, since it is abstract. SigAbstract :: SigError -- | Standard eliminator for SigError. sigError :: (String -> a) -> a -> SigError -> a class (Functor m, Applicative m, MonadFail m, HasOptions m, MonadDebug m, MonadTCEnv m) => HasConstInfo m -- | Lookup the definition of a name. The result is a closed thing, all -- free variables have been abstracted over. getConstInfo :: HasConstInfo m => QName -> m Definition -- | Version that reports exceptions: getConstInfo' :: HasConstInfo m => QName -> m (Either SigError Definition) -- | Lookup the rewrite rules with the given head symbol. getRewriteRulesFor :: HasConstInfo m => QName -> m RewriteRules -- | Version that reports exceptions: getConstInfo' :: (HasConstInfo m, HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m (Either SigError Definition) -- | Lookup the rewrite rules with the given head symbol. getRewriteRulesFor :: (HasConstInfo m, HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m RewriteRules -- | The computation getConstInfo sometimes tweaks the returned -- Definition, depending on the current Language and the -- Language of the Definition. This variant of -- getConstInfo does not perform any tweaks. getOriginalConstInfo :: (ReadTCState m, HasConstInfo m) => QName -> m Definition defaultGetRewriteRulesFor :: (ReadTCState m, MonadTCEnv m) => QName -> m RewriteRules -- | Get the original name of the projection (the current one could be from -- a module application). getOriginalProjection :: HasConstInfo m => QName -> m QName defaultGetConstInfo :: (HasOptions m, MonadDebug m, MonadTCEnv m) => TCState -> TCEnv -> QName -> m (Either SigError Definition) getConInfo :: HasConstInfo m => ConHead -> m Definition -- | Look up the polarity of a definition. getPolarity :: HasConstInfo m => QName -> m [Polarity] -- | Look up polarity of a definition and compose with polarity represented -- by Comparison. getPolarity' :: HasConstInfo m => Comparison -> QName -> m [Polarity] -- | Set the polarity of a definition. setPolarity :: (MonadTCState m, MonadDebug m) => QName -> [Polarity] -> m () -- | Look up the forced arguments of a definition. getForcedArgs :: HasConstInfo m => QName -> m [IsForced] -- | Get argument occurrence info for argument i of definition -- d (never fails). getArgOccurrence :: QName -> Nat -> TCM Occurrence -- | Sets the defArgOccurrences for the given identifier (which -- should already exist in the signature). setArgOccurrences :: MonadTCState m => QName -> [Occurrence] -> m () modifyArgOccurrences :: MonadTCState m => QName -> ([Occurrence] -> [Occurrence]) -> m () setTreeless :: QName -> TTerm -> TCM () setCompiledArgUse :: QName -> [ArgUsage] -> TCM () getCompiled :: HasConstInfo m => QName -> m (Maybe Compiled) -- | Returns a list of length conArity. If no erasure analysis has -- been performed yet, this will be a list of Falses. getErasedConArgs :: HasConstInfo m => QName -> m [Bool] setErasedConArgs :: QName -> [Bool] -> TCM () getTreeless :: HasConstInfo m => QName -> m (Maybe TTerm) getCompiledArgUse :: HasConstInfo m => QName -> m (Maybe [ArgUsage]) -- | add data constructors to a datatype addDataCons :: QName -> [QName] -> TCM () -- | Get the mutually recursive identifiers of a symbol from the signature. getMutual :: QName -> TCM (Maybe [QName]) -- | Get the mutually recursive identifiers from a Definition. getMutual_ :: Defn -> Maybe [QName] -- | Set the mutually recursive identifiers. setMutual :: QName -> [QName] -> TCM () -- | Check whether two definitions are mutually recursive. mutuallyRecursive :: QName -> QName -> TCM Bool -- | A functiondatarecord definition is nonRecursive if it is not -- even mutually recursive with itself. definitelyNonRecursive_ :: Defn -> Bool -- | Get the number of parameters to the current module. getCurrentModuleFreeVars :: TCM Nat getDefModule :: HasConstInfo m => QName -> m (Either SigError ModuleName) -- | 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). getDefFreeVars :: (Functor m, Applicative m, ReadTCState m, MonadTCEnv m) => QName -> m Nat freeVarsToApply :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => QName -> m Args getModuleFreeVars :: (Functor m, Applicative m, MonadTCEnv m, ReadTCState m) => ModuleName -> m Nat -- | 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 Θ] moduleParamsToApply :: (Functor m, Applicative m, HasOptions m, MonadTCEnv m, ReadTCState m, MonadDebug m) => ModuleName -> m Args -- | 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. inFreshModuleIfFreeParams :: TCM a -> TCM a -- | Instantiate a closed definition with the correct part of the current -- context. instantiateDef :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => Definition -> m Definition instantiateRewriteRule :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRule -> m RewriteRule instantiateRewriteRules :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRules -> m RewriteRules -- | Give the abstract view of a definition. makeAbstract :: Definition -> Maybe Definition -- | Enter abstract mode. Abstract definition in the current module are -- transparent. inAbstractMode :: MonadTCEnv m => m a -> m a -- | Not in abstract mode. All abstract definitions are opaque. inConcreteMode :: MonadTCEnv m => m a -> m a -- | Ignore abstract mode. All abstract definitions are transparent. ignoreAbstractMode :: MonadTCEnv m => m a -> m a -- | Enter concrete or abstract mode depending on whether the given -- identifier is concrete or abstract. inConcreteOrAbstractMode :: (MonadTCEnv m, HasConstInfo m) => QName -> (Definition -> m a) -> m a -- | 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 :: MonadTCEnv m => QName -> m 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. treatAbstractly' :: QName -> TCEnv -> Bool -- | Get type of a constant, instantiated to the current context. typeOfConst :: (HasConstInfo m, ReadTCState m) => QName -> m Type -- | Get relevance of a constant. relOfConst :: HasConstInfo m => QName -> m Relevance -- | Get modality of a constant. modalityOfConst :: HasConstInfo m => QName -> m Modality -- | The number of dropped parameters for a definition. 0 except for -- projection(-like) functions and constructors. droppedPars :: Definition -> Int -- | Is it the name of a record projection? isProjection :: HasConstInfo m => QName -> m (Maybe Projection) isProjection_ :: Defn -> Maybe Projection -- | Is it the name of a non-irrelevant record projection? isRelevantProjection :: HasConstInfo m => QName -> m (Maybe Projection) isRelevantProjection_ :: Definition -> Maybe Projection -- | Is it a function marked STATIC? isStaticFun :: Defn -> Bool -- | Is it a function marked INLINE? isInlineFun :: 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). isProperProjection :: Defn -> Bool -- | Number of dropped initial arguments of a projection(-like) function. projectionArgs :: Definition -> Int -- | Check whether a definition uses copatterns. usesCopatterns :: HasConstInfo m => QName -> m Bool -- | Apply a function f to its first argument, producing the -- proper postfix projection if f is a projection which is not -- irrelevant. applyDef :: HasConstInfo m => ProjOrigin -> QName -> Arg Term -> m Term instance Agda.TypeChecking.Monad.Signature.HasConstInfo (Agda.TypeChecking.Monad.Base.TCMT GHC.Types.IO) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Agda.Utils.Update.ChangeT m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Control.Monad.Trans.Except.ExceptT err m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Control.Monad.Trans.State.Lazy.StateT s m) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Signature.HasConstInfo m) => Agda.TypeChecking.Monad.Signature.HasConstInfo (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Agda.TypeChecking.Monad.Base.BlockT m) -- | Dropping initial arguments (`parameters') from a function -- which can be easily reconstructed from its principal argument. -- -- A function which has such parameters is called ``projection-like''. -- -- The motivation for this optimization comes from the use of nested -- records. -- -- First, let us look why proper projections need not store the -- parameters: The type of a projection f is of the form f -- : Γ → R Γ → C where R is the record type and C -- is the type of the field f. Given a projection application -- p pars u we know that the type of the principal argument -- u is u : R pars thus, the parameters pars -- are redundant in the projection application if we can always infer the -- type of u. For projections, this is case, because the -- principal argument u must be neutral; otherwise, if it was a -- record value, we would have a redex, yet Agda maintains a β-normal -- form. -- -- The situation for projections can be generalized to -- ``projection-like'' functions f. Conditions: -- --
    --
  1. The type of f is of the form f : Γ → D Γ → ... -- for some type constructor D which can never reduce.
  2. --
  3. For every reduced welltyped application f pars u ..., the -- type of u is inferable.
  4. --
-- -- This then allows pars to be dropped always. -- -- Condition 2 is approximated by a bunch of criteria, for details see -- function makeProjection. -- -- Typical projection-like functions are compositions of projections -- which arise from nested records. -- -- Notes: -- --
    --
  1. This analysis could be dualized to ``constructor-like'' functions -- whose parameters are reconstructable from the target type. But such -- functions would need to be fully applied.
  2. --
  3. A more general analysis of which arguments are reconstructible can -- be found inJason C. Reed, Redundancy elimination for LF LFTMP -- 2004.
  4. --
module Agda.TypeChecking.ProjectionLike -- | View for a Def f (Apply a : es) where -- isRelevantProjection f. Used for projection-like fs. data ProjectionView -- | A projection or projection-like function, applied to its principal -- argument ProjectionView :: QName -> Arg Term -> Elims -> ProjectionView [projViewProj] :: ProjectionView -> QName [projViewSelf] :: ProjectionView -> Arg Term [projViewSpine] :: ProjectionView -> Elims -- | Just a lone projection-like function, missing its principal argument -- (from which we could infer the parameters). LoneProjectionLike :: QName -> ArgInfo -> ProjectionView -- | Not a projection or projection-like thing. NoProjection :: Term -> ProjectionView -- | Semantics of ProjectionView. unProjView :: ProjectionView -> Term -- | Top-level ProjectionView (no reduction). projView :: HasConstInfo m => Term -> m ProjectionView -- | Reduce away top-level projection like functions. (Also reduces -- projections, but they should not be there, since Internal is in -- lambda- and projection-beta-normal form.) reduceProjectionLike :: PureTCM m => Term -> m Term data ProjEliminator EvenLone :: ProjEliminator ButLone :: ProjEliminator NoPostfix :: ProjEliminator -- | Turn prefix projection-like function application into postfix ones. -- This does just one layer, such that the top spine contains the -- projection-like functions as projections. Used in -- compareElims in TypeChecking.Conversion and in -- Agda.TypeChecking.CheckInternal. -- -- If the Bool is True, a lone projection like function -- will be turned into a lambda-abstraction, expecting the principal -- argument. If the Bool is False, it will be returned -- unaltered. -- -- No precondition. Preserves constructorForm, since it really does only -- something on (applications of) projection-like functions. elimView :: PureTCM m => ProjEliminator -> Term -> m Term -- | Which Deftypes are eligible for the principle argument of a -- projection-like function? eligibleForProjectionLike :: HasConstInfo m => QName -> m Bool -- | Turn a definition into a projection if it looks like a projection. -- -- Conditions for projection-likeness of f: -- --
    --
  1. The type of f must be of the shape Γ → D Γ → C -- for D a name (Def) which is -- eligibleForProjectionLike: data record -- postulate.
  2. --
  3. The application of f should only get stuck if the principal -- argument is inferable (neutral). Thus:
  4. --
-- -- a. f cannot have absurd clauses (which are stuck even if the -- principal argument is a constructor). -- -- b. f cannot be abstract as it does not reduce outside -- abstract blocks (always stuck). -- -- c. f cannot match on other arguments than the principal -- argument. -- -- d. f cannot match deeply. -- -- e. fs body may not mention the parameters. -- -- f. A rhs of f cannot be a record expression, since this will -- be translated to copatterns by recordExpressionsToCopatterns. Thus, an -- application of f waiting for a projection can be stuck even -- when the principal argument is a constructor. -- -- g. f cannot be an irrelevant definition (Andreas, 2022-03-07, -- #5809), as those are not reduced. -- -- For internal reasons: -- --
    --
  1. f cannot be constructor headed
  2. --
  3. f cannot be recursive, since we have not implemented a -- function which goes through the bodies of the f and the -- mutually recursive functions and drops the parameters from all -- applications of f.
  4. --
-- -- Examples for these reasons: see -- testSucceedNotProjectionLike.agda makeProjection :: QName -> TCM () instance GHC.Classes.Eq Agda.TypeChecking.ProjectionLike.ProjEliminator module Agda.TypeChecking.Pretty newtype PrettyContext PrettyContext :: Context -> PrettyContext class PrettyTCM a prettyTCM :: (PrettyTCM a, MonadPretty m) => a -> m Doc type MonadPretty m = MonadAbsToCon m -- | prettyList without the brackets. prettyList_ :: (Applicative m, Semigroup (m Doc), Foldable t) => t (m Doc) -> m Doc pretty :: (Applicative m, Pretty a) => a -> m Doc nest :: Functor m => Int -> m Doc -> m Doc ($$) :: Applicative m => m Doc -> m Doc -> m Doc infixl 5 $$ (<+>) :: Applicative m => m Doc -> m Doc -> m Doc infixl 6 <+> () :: Applicative m => m Doc -> m Doc -> m Doc infixl 6 hang :: Applicative m => m Doc -> Int -> m Doc -> m Doc sep :: (Applicative m, Foldable t) => t (m Doc) -> m Doc fsep :: (Applicative m, Foldable t) => t (m Doc) -> m Doc hsep :: (Applicative m, Foldable t) => t (m Doc) -> m Doc vcat :: (Applicative m, Foldable t) => t (m Doc) -> m Doc text :: Applicative m => String -> m Doc -- | Pretty-print something paired with a (printable) node. | This -- intermediate typeclass exists to avoid UndecidableInstances. class PrettyTCMWithNode a prettyTCMWithNode :: (PrettyTCMWithNode a, PrettyTCM n, MonadPretty m) => WithNode n a -> m Doc -- | Pairing something with a node (for printing only). data WithNode n a WithNode :: n -> a -> WithNode n a type Doc = Doc comma :: Applicative m => m Doc colon :: Applicative m => m Doc equals :: Applicative m => m Doc prettyA :: (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) => a -> m Doc prettyAs :: (ToConcrete a, ConOfAbs a ~ [ce], Pretty ce, MonadAbsToCon m) => a -> m Doc multiLineText :: Applicative m => String -> m Doc pwords :: Applicative m => String -> [m Doc] fwords :: Applicative m => String -> m Doc hcat :: (Applicative m, Foldable t) => t (m Doc) -> m Doc ($+$) :: Applicative m => m Doc -> m Doc -> m Doc infixl 5 $+$ braces :: Functor m => m Doc -> m Doc dbraces :: Functor m => m Doc -> m Doc brackets :: Functor m => m Doc -> m Doc parens :: Functor m => m Doc -> m Doc parensNonEmpty :: Functor m => m Doc -> m Doc doubleQuotes :: Functor m => m Doc -> m Doc quotes :: Functor m => m Doc -> m Doc pshow :: (Applicative m, Show a) => a -> m Doc -- | Comma-separated list in brackets. prettyList :: (Applicative m, Semigroup (m Doc), Foldable t) => t (m Doc) -> m Doc punctuate :: (Applicative m, Semigroup (m Doc), Foldable t) => m Doc -> t (m Doc) -> [m Doc] -- | Pretty print with a given context precedence prettyTCMCtx :: (PrettyTCM a, MonadPretty m) => Precedence -> a -> m Doc prettyR :: (ToAbstract r, PrettyTCM (AbsOfRef r), MonadPretty m, MonadError TCErr m) => r -> m Doc -- | Proper pretty printing of patterns: prettyTCMPatterns :: MonadPretty m => [NamedArg DeBruijnPattern] -> m [Doc] prettyTCMPatternList :: MonadPretty m => [NamedArg DeBruijnPattern] -> m Doc -- | The class of semigroups (types with an associative binary operation). -- -- Instances should satisfy the following: -- -- class Semigroup a -- | An associative operation. -- --
--   >>> [1,2,3] <> [4,5,6]
--   [1,2,3,4,5,6]
--   
(<>) :: Semigroup a => a -> a -> a infixr 6 <> -- | The function runAbsToCon can target any monad that satisfies -- the constraints of MonadAbsToCon. type MonadAbsToCon m = (MonadFresh NameId m, MonadInteractionPoints m, MonadStConcreteNames m, HasOptions m, PureTCM m, IsString (m Doc), Null (m Doc), Semigroup (m Doc)) instance Agda.TypeChecking.Pretty.PrettyTCMWithNode Agda.TypeChecking.Positivity.Occurrence.Occurrence instance (Agda.TypeChecking.Pretty.PrettyTCM n, Agda.TypeChecking.Pretty.PrettyTCMWithNode e) => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n e) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Pretty.PrettyContext instance Agda.TypeChecking.Pretty.PrettyTCM GHC.Base.String instance Agda.TypeChecking.Pretty.PrettyTCM GHC.Types.Bool instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Concrete.Name.Name instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Concrete.Name.QName instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Comparison instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Literal.Literal instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Common.Nat instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Common.ProblemId instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Position.Range instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.CheckpointId instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM [a] instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (GHC.Maybe.Maybe a) instance (Agda.TypeChecking.Pretty.PrettyTCM a, Agda.TypeChecking.Pretty.PrettyTCM b) => Agda.TypeChecking.Pretty.PrettyTCM (a, b) instance (Agda.TypeChecking.Pretty.PrettyTCM a, Agda.TypeChecking.Pretty.PrettyTCM b, Agda.TypeChecking.Pretty.PrettyTCM c) => Agda.TypeChecking.Pretty.PrettyTCM (a, b, c) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Term instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Type instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Translation.InternalToAbstract.NamedClause instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Internal.Clause) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Level instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Named_ Agda.Syntax.Internal.Term) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Arg Agda.Syntax.Internal.Term) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Arg Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Arg GHC.Types.Bool) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Arg Agda.Syntax.Abstract.Expr) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Expr) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.NamedArg Agda.Syntax.Internal.Term) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.ContextEntry instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Utils.Permutation.Permutation instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Polarity instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.IsForced instance (Agda.Utils.Pretty.Pretty a, Agda.TypeChecking.Pretty.PrettyTCM a, Agda.TypeChecking.Substitute.Class.EndoSubst a) => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Substitution' a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Monad.Base.Judgement a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.NamedMeta instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Blocked a) instance (Agda.TypeChecking.Pretty.PrettyTCM k, Agda.TypeChecking.Pretty.PrettyTCM v) => Agda.TypeChecking.Pretty.PrettyTCM (Data.Map.Internal.Map k v) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Elim instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Monad.Base.MaybeReduced a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.EqualityView instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.Expr instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.TypedBinding instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.Pattern instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Common.Relevance instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Common.Quantity instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Common.Modality instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Blockers.Blocker instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.CompareAs instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.TypeCheckingProblem instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.WithHiding a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.Name.Name instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.Name.ModuleName instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Scope.Base.AbstractName instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.ConHead instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.Telescope instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Internal.DBPatVar instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Pattern' a) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Elim.Elim' Agda.TypeChecking.Monad.Base.DisplayTerm) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Elim.Elim' Agda.TypeChecking.Monad.Base.NLPat) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Type' Agda.TypeChecking.Monad.Base.NLPat) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Coverage.SplitTree.SplitTag instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Candidate instance GHC.Base.Semigroup (Agda.TypeChecking.Monad.Base.TCM Agda.TypeChecking.Pretty.Doc) module Agda.Syntax.Translation.ReflectedToAbstract type Vars = [(Name, Type)] type MonadReflectedToAbstract m = (MonadReader Vars m, MonadFresh NameId m, MonadError TCErr m, MonadTCEnv m, ReadTCState m, HasOptions m, HasBuiltins m, HasConstInfo m) -- | Adds a new unique name to the current context. NOTE: See -- chooseName in -- Agda.Syntax.Translation.AbstractToConcrete for similar logic. -- NOTE: See freshConcreteName in -- Agda.Syntax.Scope.Monad also for similar logic. withName :: MonadReflectedToAbstract m => String -> (Name -> m a) -> m a withVar :: MonadReflectedToAbstract m => String -> Type -> (Name -> m a) -> m a withNames :: MonadReflectedToAbstract m => [String] -> ([Name] -> m a) -> m a withVars :: MonadReflectedToAbstract m => [(String, Type)] -> ([Name] -> m a) -> m a -- | Returns the name and type of the variable with the given de Bruijn -- index. askVar :: MonadReflectedToAbstract m => Int -> m (Maybe (Name, Type)) askName :: MonadReflectedToAbstract m => Int -> m (Maybe Name) class ToAbstract r where { type AbsOfRef r; } toAbstract :: (ToAbstract r, MonadReflectedToAbstract m) => r -> m (AbsOfRef r) toAbstract :: (ToAbstract r, Traversable t, ToAbstract s, t s ~ r, t (AbsOfRef s) ~ AbsOfRef r) => MonadReflectedToAbstract m => r -> m (AbsOfRef r) -- | Translate reflected syntax to abstract, using the names from the -- current typechecking context. toAbstract_ :: (ToAbstract r, MonadFresh NameId m, MonadError TCErr m, MonadTCEnv m, ReadTCState m, HasOptions m, HasBuiltins m, HasConstInfo m) => r -> m (AbsOfRef r) -- | Drop implicit arguments unless --show-implicit is on. toAbstractWithoutImplicit :: (ToAbstract r, MonadFresh NameId m, MonadError TCErr m, MonadTCEnv m, ReadTCState m, HasOptions m, HasBuiltins m, HasConstInfo m) => r -> m (AbsOfRef r) mkMetaInfo :: ReadTCState m => m MetaInfo mkDef :: HasConstInfo m => QName -> m Expr mkApp :: Expr -> Expr -> Expr mkVar :: MonadReflectedToAbstract m => Int -> m (Name, Type) mkVarName :: MonadReflectedToAbstract m => Int -> m Name annotatePattern :: MonadReflectedToAbstract m => Int -> Type -> Pattern -> m Pattern -- | Check that all variables in the telescope are bound in the left-hand -- side. Since we check the telescope by attaching type annotations to -- the pattern variables there needs to be somewhere to put the -- annotation. Also, since the lhs is where the variables are actually -- bound, missing a binding for a variable that's used later in the -- telescope causes unbound variable panic (see #5044). checkClauseTelescopeBindings :: MonadReflectedToAbstract m => [(Text, Arg Type)] -> [Arg Pattern] -> m () instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Common.Named name r) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Common.Arg r) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract [Agda.Syntax.Common.Arg r] instance (Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r, Agda.Syntax.Translation.ReflectedToAbstract.AbsOfRef r GHC.Types.~ Agda.Syntax.Abstract.Expr) => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Internal.Dom r, Agda.Syntax.Abstract.Name.Name) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Abstract.Expr, Agda.Syntax.Reflected.Elim) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Abstract.Expr, Agda.Syntax.Reflected.Elims) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Reflected.Abs r) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Literal.Literal instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Reflected.Term instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Reflected.Sort instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Reflected.Pattern instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Reflected.Clause) instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract [Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Reflected.Clause] instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Utils.List1.List1 (Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Reflected.Clause)) -- | The scope monad with operations. module Agda.Syntax.Scope.Monad -- | To simplify interaction between scope checking and type checking (in -- particular when chasing imports), we use the same monad. type ScopeM = TCM printLocals :: Int -> String -> ScopeM () scopeWarning' :: CallStack -> DeclarationWarning' -> ScopeM () scopeWarning :: HasCallStack => DeclarationWarning' -> ScopeM () isDatatypeModule :: ReadTCState m => ModuleName -> m (Maybe DataOrRecordModule) getCurrentModule :: ReadTCState m => m ModuleName setCurrentModule :: MonadTCState m => ModuleName -> m () withCurrentModule :: (ReadTCState m, MonadTCState m) => ModuleName -> m a -> m a withCurrentModule' :: (MonadTrans t, Monad (t ScopeM)) => ModuleName -> t ScopeM a -> t ScopeM a getNamedScope :: ModuleName -> ScopeM Scope getCurrentScope :: ScopeM Scope -- | Create a new module with an empty scope. If the module is not new -- (e.g. duplicate import), don't erase its contents. -- (Just if it is a datatype or record module.) createModule :: Maybe DataOrRecordModule -> ModuleName -> ScopeM () -- | Apply a function to the scope map. modifyScopes :: (Map ModuleName Scope -> Map ModuleName Scope) -> ScopeM () -- | Apply a function to the given scope. modifyNamedScope :: ModuleName -> (Scope -> Scope) -> ScopeM () setNamedScope :: ModuleName -> Scope -> ScopeM () -- | Apply a monadic function to the top scope. modifyNamedScopeM :: ModuleName -> (Scope -> ScopeM (a, Scope)) -> ScopeM a -- | Apply a function to the current scope. modifyCurrentScope :: (Scope -> Scope) -> ScopeM () modifyCurrentScopeM :: (Scope -> ScopeM (a, Scope)) -> ScopeM a -- | Apply a function to the public or private name space. modifyCurrentNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> ScopeM () setContextPrecedence :: PrecedenceStack -> ScopeM () withContextPrecedence :: ReadTCState m => Precedence -> m a -> m a getLocalVars :: ReadTCState m => m LocalVars modifyLocalVars :: (LocalVars -> LocalVars) -> ScopeM () setLocalVars :: LocalVars -> ScopeM () -- | Run a computation without changing the local variables. withLocalVars :: ScopeM a -> ScopeM a -- | Run a computation outside some number of local variables and add them -- back afterwards. This lets you bind variables in the middle of the -- context and is used when binding generalizable variables (#3735). outsideLocalVars :: Int -> ScopeM a -> ScopeM a -- | Check that the newly added variable have unique names. withCheckNoShadowing :: ScopeM a -> ScopeM a checkNoShadowing :: LocalVars -> LocalVars -> ScopeM () getVarsToBind :: ScopeM LocalVars addVarToBind :: Name -> LocalVar -> ScopeM () -- | After collecting some variable names in the scopeVarsToBind, bind them -- all simultaneously. bindVarsToBind :: ScopeM () annotateDecls :: ReadTCState m => m [Declaration] -> m Declaration annotateExpr :: ReadTCState m => m Expr -> m Expr -- | Create a fresh abstract name from a concrete name. -- -- This function is used when we translate a concrete name in a binder. -- The Range' of the concrete name is saved as the -- nameBindingSite of the abstract name. freshAbstractName :: Fixity' -> Name -> ScopeM Name -- |
--   freshAbstractName_ = freshAbstractName noFixity'
--   
freshAbstractName_ :: Name -> ScopeM Name -- | Create a fresh abstract qualified name. freshAbstractQName :: Fixity' -> Name -> ScopeM QName freshAbstractQName' :: Name -> ScopeM QName -- | Create a concrete name that is not yet in scope. | NOTE: See -- chooseName in -- Agda.Syntax.Translation.AbstractToConcrete for similar logic. -- | NOTE: See withName in -- Agda.Syntax.Translation.ReflectedToAbstract for similar -- logic. freshConcreteName :: Range -> Int -> String -> ScopeM Name -- | Look up the abstract name referred to by a given concrete name. resolveName :: QName -> ScopeM ResolvedName -- | Look up the abstract name corresponding to a concrete name of a -- certain kind and/or from a given set of names. Sometimes we know -- already that we are dealing with a constructor or pattern synonym -- (e.g. when we have parsed a pattern). Then, we can ignore conflicting -- definitions of that name of a different kind. (See issue 822.) resolveName' :: KindsOfNames -> Maybe (Set Name) -> QName -> ScopeM ResolvedName tryResolveName :: forall m. (ReadTCState m, HasBuiltins m, MonadError AmbiguousNameReason m) => KindsOfNames -> Maybe (Set Name) -> QName -> m ResolvedName -- | Test if a given abstract name can appear with a suffix. Currently only -- true for the names of builtin sorts Set and Prop. canHaveSuffixTest :: HasBuiltins m => m (QName -> Bool) -- | Look up a module in the scope. resolveModule :: QName -> ScopeM AbstractModule -- | Get the fixity of a not yet bound name. getConcreteFixity :: Name -> ScopeM Fixity' -- | Get the polarities of a not yet bound name. getConcretePolarity :: Name -> ScopeM (Maybe [Occurrence]) -- | Collect the fixity/syntax declarations and polarity pragmas from the -- list of declarations and store them in the scope. computeFixitiesAndPolarities :: DoWarn -> [Declaration] -> ScopeM a -> ScopeM a -- | Get the notation of a name. The name is assumed to be in scope. getNotation :: QName -> Set Name -> ScopeM NewNotation -- | Bind a variable. bindVariable :: BindingSource -> Name -> Name -> ScopeM () -- | Temporarily unbind a variable. Used for non-recursive lets. unbindVariable :: Name -> ScopeM a -> ScopeM a -- | Bind a defined name. Must not shadow anything. bindName :: Access -> KindOfName -> Name -> QName -> ScopeM () bindName' :: Access -> KindOfName -> NameMetadata -> Name -> QName -> ScopeM () -- | Bind a name. Returns the TypeError if exists, but does not -- throw it. bindName'' :: Access -> KindOfName -> NameMetadata -> Name -> QName -> ScopeM (Maybe TypeError) -- | Rebind a name. Use with care! Ulf, 2014-06-29: Currently used to -- rebind the name defined by an unquoteDecl, which is a -- QuotableName in the body, but a DefinedName later on. rebindName :: Access -> KindOfName -> Name -> QName -> ScopeM () -- | Bind a module name. bindModule :: Access -> Name -> ModuleName -> ScopeM () -- | Bind a qualified module name. Adds it to the imports field of the -- scope. bindQModule :: Access -> QName -> ModuleName -> ScopeM () -- | Clear the scope of any no names. stripNoNames :: ScopeM () type WSM = StateT ScopeMemo ScopeM data ScopeMemo ScopeMemo :: Ren QName -> Map ModuleName (ModuleName, Bool) -> ScopeMemo [memoNames] :: ScopeMemo -> Ren QName -- | Bool: did we copy recursively? We need to track this because we don't -- copy recursively when creating new modules for reexported functions -- (issue1985), but we might need to copy recursively later. [memoModules] :: ScopeMemo -> Map ModuleName (ModuleName, Bool) memoToScopeInfo :: ScopeMemo -> ScopeCopyInfo -- | Create a new scope with the given name from an old scope. Renames -- public names in the old scope to match the new name and returns the -- renamings. copyScope :: QName -> ModuleName -> Scope -> ScopeM (Scope, ScopeCopyInfo) -- | Warn about useless fixity declarations in renaming -- directives. Monadic for the sake of error reporting. checkNoFixityInRenamingModule :: [Renaming] -> ScopeM () -- | Check that an import directive doesn't contain repeated names. verifyImportDirective :: [ImportedName] -> HidingDirective -> RenamingDirective -> ScopeM () -- | Apply an import directive and check that all the names mentioned -- actually exist. -- -- Monadic for the sake of error reporting. applyImportDirectiveM :: QName -> ImportDirective -> Scope -> ScopeM (ImportDirective, Scope) -- | Translation of ImportDirective. mapImportDir :: (Ord n1, Ord m1) => [ImportedName' (n1, n2) (m1, m2)] -> [ImportedName' (n1, n2) (m1, m2)] -> ImportDirective' n1 m1 -> ImportDirective' n2 m2 -- | A finite map for ImportedNames. data ImportedNameMap n1 n2 m1 m2 ImportedNameMap :: Map n1 n2 -> Map m1 m2 -> ImportedNameMap n1 n2 m1 m2 [inameMap] :: ImportedNameMap n1 n2 m1 m2 -> Map n1 n2 [imoduleMap] :: ImportedNameMap n1 n2 m1 m2 -> Map m1 m2 -- | Create a ImportedNameMap. importedNameMapFromList :: (Ord n1, Ord m1) => [ImportedName' (n1, n2) (m1, m2)] -> ImportedNameMap n1 n2 m1 m2 -- | Apply a ImportedNameMap. lookupImportedName :: (Ord n1, Ord m1) => ImportedNameMap n1 n2 m1 m2 -> ImportedName' n1 m1 -> ImportedName' n2 m2 -- | Translation of Renaming. mapRenaming :: (Ord n1, Ord m1) => ImportedNameMap n1 n2 m1 m2 -> ImportedNameMap n1 n2 m1 m2 -> Renaming' n1 m1 -> Renaming' n2 m2 data OpenKind LetOpenModule :: OpenKind TopOpenModule :: OpenKind noGeneralizedVarsIfLetOpen :: OpenKind -> Scope -> Scope -- | Open a module. openModule_ :: OpenKind -> QName -> ImportDirective -> ScopeM ImportDirective -- | Open a module, possibly given an already resolved module name. openModule :: OpenKind -> Maybe ModuleName -> QName -> ImportDirective -> ScopeM ImportDirective instance Agda.Syntax.Concrete.Fixity.MonadFixityError Agda.Syntax.Scope.Monad.ScopeM -- | Translating from internal syntax to abstract syntax. Enables nice -- pretty printing of internal syntax. -- -- TODO -- -- module Agda.Syntax.Translation.InternalToAbstract class Reify i where { type ReifiesTo i; } reify :: (Reify i, MonadReify m) => i -> m (ReifiesTo i) reifyWhen :: (Reify i, MonadReify m) => Bool -> i -> m (ReifiesTo i) type MonadReify m = (PureTCM m, MonadInteractionPoints m, MonadFresh NameId m) data NamedClause -- | Also tracks whether module parameters should be dropped from the -- patterns. NamedClause :: QName -> Bool -> Clause -> NamedClause -- | Assumes that pattern variables have been added to the context already. -- Picks pattern variable names from context. reifyPatterns :: MonadReify m => [NamedArg DeBruijnPattern] -> m [NamedArg Pattern] -- | Like reify but instantiates blocking metas, useful for -- reporting. reifyUnblocked :: Reify i => i -> TCM (ReifiesTo i) -- | blankNotInScope e replaces variables in expression e -- with _ if they are currently not in scope. blankNotInScope :: (MonadTCEnv m, BlankVars a) => a -> m a -- | reifyDisplayFormP tries to recursively rewrite a lhs with a -- display form. -- -- Note: we are not necessarily in the empty context upon entry! reifyDisplayFormP :: MonadReify m => QName -> Patterns -> Patterns -> m (QName, Patterns) instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.Clause instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.Expr instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.LHS instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.LHSCore instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.Pattern instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder (Agda.Syntax.Abstract.Binder' a) instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.TypedBinding instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.BindName instance Agda.Syntax.Translation.InternalToAbstract.Binder Agda.Syntax.Abstract.LetBinding instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder (Agda.Syntax.Concrete.FieldAssignment' a) instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder (Agda.Syntax.Common.Named x a) instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder [a] instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder (Agda.Utils.List1.List1 a) instance Agda.Syntax.Translation.InternalToAbstract.Binder a => Agda.Syntax.Translation.InternalToAbstract.Binder (GHC.Maybe.Maybe a) instance (Agda.Syntax.Translation.InternalToAbstract.Binder a, Agda.Syntax.Translation.InternalToAbstract.Binder b) => Agda.Syntax.Translation.InternalToAbstract.Binder (a, b) instance Agda.Syntax.Translation.InternalToAbstract.BlankVars a => Agda.Syntax.Translation.InternalToAbstract.BlankVars (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Translation.InternalToAbstract.BlankVars a => Agda.Syntax.Translation.InternalToAbstract.BlankVars (Agda.Syntax.Common.Named s a) instance Agda.Syntax.Translation.InternalToAbstract.BlankVars a => Agda.Syntax.Translation.InternalToAbstract.BlankVars [a] instance Agda.Syntax.Translation.InternalToAbstract.BlankVars a => Agda.Syntax.Translation.InternalToAbstract.BlankVars (Agda.Utils.List1.List1 a) instance Agda.Syntax.Translation.InternalToAbstract.BlankVars a => Agda.Syntax.Translation.InternalToAbstract.BlankVars (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Syntax.Translation.InternalToAbstract.BlankVars a, Agda.Syntax.Translation.InternalToAbstract.BlankVars b) => Agda.Syntax.Translation.InternalToAbstract.BlankVars (a, b) instance (Agda.Syntax.Translation.InternalToAbstract.BlankVars a, Agda.Syntax.Translation.InternalToAbstract.BlankVars b) => Agda.Syntax.Translation.InternalToAbstract.BlankVars (Data.Either.Either a b) instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.ProblemEq instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.LHS instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.LHSCore instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.Pattern instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.RHS instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Translation.InternalToAbstract.BlankVars Agda.Syntax.Abstract.TypedBinding instance (GHC.Classes.Ord k, GHC.Base.Monoid v) => GHC.Base.Semigroup (Agda.Syntax.Translation.InternalToAbstract.MonoidMap k v) instance (GHC.Classes.Ord k, GHC.Base.Monoid v) => GHC.Base.Monoid (Agda.Syntax.Translation.InternalToAbstract.MonoidMap k v) instance Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Internal.Clause) instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Translation.InternalToAbstract.NamedClause instance Agda.Syntax.Translation.InternalToAbstract.Reify GHC.Types.Bool instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Abstract.Expr instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Common.MetaId instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Literal.Literal instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Term instance Agda.Syntax.Translation.InternalToAbstract.Reify i => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Common.Named n i) instance Agda.Syntax.Translation.InternalToAbstract.Reify i => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Common.Arg i) instance Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Abstract.Name.QNamed Agda.TypeChecking.Monad.Base.System) instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Type instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Sort instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Level instance (Agda.TypeChecking.Free.Lazy.Free i, Agda.Syntax.Translation.InternalToAbstract.Reify i) => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Internal.Abs i) instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Telescope instance Agda.Syntax.Translation.InternalToAbstract.Reify i => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Internal.Dom i) instance Agda.Syntax.Translation.InternalToAbstract.Reify i => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Internal.Elim.Elim' i) instance Agda.Syntax.Translation.InternalToAbstract.Reify i => Agda.Syntax.Translation.InternalToAbstract.Reify [i] instance (Agda.Syntax.Translation.InternalToAbstract.Reify i1, Agda.Syntax.Translation.InternalToAbstract.Reify i2) => Agda.Syntax.Translation.InternalToAbstract.Reify (i1, i2) instance (Agda.Syntax.Translation.InternalToAbstract.Reify i1, Agda.Syntax.Translation.InternalToAbstract.Reify i2, Agda.Syntax.Translation.InternalToAbstract.Reify i3) => Agda.Syntax.Translation.InternalToAbstract.Reify (i1, i2, i3) instance (Agda.Syntax.Translation.InternalToAbstract.Reify i1, Agda.Syntax.Translation.InternalToAbstract.Reify i2, Agda.Syntax.Translation.InternalToAbstract.Reify i3, Agda.Syntax.Translation.InternalToAbstract.Reify i4) => Agda.Syntax.Translation.InternalToAbstract.Reify (i1, i2, i3, i4) module Agda.TypeChecking.Level data LevelKit LevelKit :: Term -> (Term -> Term) -> (Term -> Term -> Term) -> Term -> QName -> QName -> QName -> QName -> LevelKit [lvlType] :: LevelKit -> Term [lvlSuc] :: LevelKit -> Term -> Term [lvlMax] :: LevelKit -> Term -> Term -> Term [lvlZero] :: LevelKit -> Term [typeName] :: LevelKit -> QName [sucName] :: LevelKit -> QName [maxName] :: LevelKit -> QName [zeroName] :: LevelKit -> QName -- | Get the primLevel as a Type. Aborts if any of the level -- BUILTINs is undefined. levelType :: (HasBuiltins m, MonadTCError m) => m Type -- | Get the primLevel as a Type. Unsafe, crashes if the -- BUILTIN LEVEL is undefined. levelType' :: HasBuiltins m => m Type isLevelType :: PureTCM m => Type -> m Bool builtinLevelKit :: HasBuiltins m => m LevelKit -- | Raises an error if no level kit is available. requireLevels :: (HasBuiltins m, MonadTCError m) => m LevelKit -- | Checks whether level kit is fully available. haveLevels :: HasBuiltins m => m Bool unLevel :: HasBuiltins m => Term -> m Term reallyUnLevelView :: HasBuiltins m => Level -> m Term unlevelWithKit :: LevelKit -> Level -> Term unConstV :: Term -> (Term -> Term) -> Integer -> Term unPlusV :: (Term -> Term) -> PlusLevel -> Term maybePrimCon :: TCM Term -> TCM (Maybe ConHead) maybePrimDef :: TCM Term -> TCM (Maybe QName) levelView :: PureTCM m => Term -> m Level levelView' :: PureTCM m => Term -> m Level -- | Given a level l, find the maximum constant n such -- that l = n + l' levelPlusView :: Level -> (Integer, Level) -- | Given a level l, find the biggest constant n such -- that n <= l levelLowerBound :: Level -> Integer -- | Given a constant n and a level l, find the level -- l' such that l = n + l' (or Nothing if there is no -- such level). Operates on levels in canonical form. subLevel :: Integer -> Level -> Maybe Level -- | Given two levels a and b, try to decompose the first -- one as a = a' ⊔ b (for the minimal value of a'). levelMaxDiff :: Level -> Level -> Maybe Level -- | A SingleLevel is a Level that cannot be further -- decomposed as a maximum a ⊔ b. data SingleLevel' t SingleClosed :: Integer -> SingleLevel' t SinglePlus :: PlusLevel' t -> SingleLevel' t type SingleLevel = SingleLevel' Term unSingleLevel :: SingleLevel' t -> Level' t -- | Return the maximum of the given SingleLevels unSingleLevels :: [SingleLevel] -> Level levelMaxView :: Level' t -> List1 (SingleLevel' t) singleLevelView :: Level' t -> Maybe (SingleLevel' t) instance Data.Traversable.Traversable Agda.TypeChecking.Level.SingleLevel' instance Data.Foldable.Foldable Agda.TypeChecking.Level.SingleLevel' instance GHC.Base.Functor Agda.TypeChecking.Level.SingleLevel' instance GHC.Show.Show t => GHC.Show.Show (Agda.TypeChecking.Level.SingleLevel' t) instance GHC.Classes.Eq Agda.TypeChecking.Level.SingleLevel instance Agda.TypeChecking.Substitute.Class.Subst t => Agda.TypeChecking.Substitute.Class.Subst (Agda.TypeChecking.Level.SingleLevel' t) instance Agda.TypeChecking.Free.Lazy.Free t => Agda.TypeChecking.Free.Lazy.Free (Agda.TypeChecking.Level.SingleLevel' t) -- | Tools for DisplayTerm and DisplayForm. module Agda.TypeChecking.DisplayForm -- | Find a matching display form for q es. In essence this tries -- to rewrite q es with any display form q ps --> dt -- and returns the instantiated dt if successful. First match -- wins. displayForm :: MonadDisplayForm m => QName -> Elims -> m (Maybe DisplayTerm) instance Agda.TypeChecking.DisplayForm.SubstWithOrigin a => Agda.TypeChecking.DisplayForm.SubstWithOrigin [a] instance (Agda.TypeChecking.DisplayForm.SubstWithOrigin a, Agda.TypeChecking.DisplayForm.SubstWithOrigin (Agda.Syntax.Common.Arg a)) => Agda.TypeChecking.DisplayForm.SubstWithOrigin (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.DisplayForm.SubstWithOrigin (Agda.Syntax.Common.Arg Agda.Syntax.Internal.Term) instance Agda.TypeChecking.DisplayForm.SubstWithOrigin Agda.Syntax.Internal.Term instance Agda.TypeChecking.DisplayForm.SubstWithOrigin Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.TypeChecking.DisplayForm.SubstWithOrigin (Agda.Syntax.Common.Arg Agda.TypeChecking.Monad.Base.DisplayTerm) instance Agda.TypeChecking.DisplayForm.Match a => Agda.TypeChecking.DisplayForm.Match [a] instance Agda.TypeChecking.DisplayForm.Match a => Agda.TypeChecking.DisplayForm.Match (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.DisplayForm.Match a => Agda.TypeChecking.DisplayForm.Match (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.DisplayForm.Match Agda.Syntax.Internal.Term instance Agda.TypeChecking.DisplayForm.Match Agda.Syntax.Internal.Sort instance Agda.TypeChecking.DisplayForm.Match Agda.Syntax.Internal.Level -- | Extract all names and meta-variables from things. module Agda.Syntax.Internal.Names -- | Some or all of the QNames that can be found in the given thing. namesIn :: (NamesIn a, Collection QName m) => a -> m -- | Some or all of the QNames that can be found in the given thing. namesIn' :: (NamesIn a, Monoid m) => (QName -> m) -> a -> m -- | Some or all of the meta-variables that can be found in the given -- thing. metasIn :: (NamesIn a, Collection MetaId m) => a -> m -- | Some or all of the meta-variables that can be found in the given -- thing. metasIn' :: (NamesIn a, Monoid m) => (MetaId -> m) -> a -> m -- | Some or all of the names and meta-variables that can be found in the -- given thing. namesAndMetasIn :: (NamesIn a, Collection QName m1, Collection MetaId m2) => a -> (m1, m2) class NamesIn a -- | Some or all of the names and meta-variables that can be found in the -- given thing. namesAndMetasIn' :: (NamesIn a, Monoid m) => (Either QName MetaId -> m) -> a -> m -- | Some or all of the names and meta-variables that can be found in the -- given thing. namesAndMetasIn' :: (NamesIn a, Monoid m, Foldable f, NamesIn b, f b ~ a) => (Either QName MetaId -> m) -> a -> m newtype PSyn PSyn :: PatternSynDefn -> PSyn instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.Names.PSyn instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (GHC.Maybe.Maybe a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Data.Strict.Maybe.Maybe a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn [a] instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Utils.List1.List1 a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Data.Set.Internal.Set a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Data.Map.Internal.Map k a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Common.Named n a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Abs a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.TypeChecking.CompiledClause.WithArity a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.TypeChecking.Monad.Base.Open a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b) => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Dom' a b) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Tele a) instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b) => Agda.Syntax.Internal.Names.NamesIn (a, b) instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b, Agda.Syntax.Internal.Names.NamesIn c) => Agda.Syntax.Internal.Names.NamesIn (a, b, c) instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b, Agda.Syntax.Internal.Names.NamesIn c, Agda.Syntax.Internal.Names.NamesIn d) => Agda.Syntax.Internal.Names.NamesIn (a, b, c, d) instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b, Agda.Syntax.Internal.Names.NamesIn c, Agda.Syntax.Internal.Names.NamesIn d, Agda.Syntax.Internal.Names.NamesIn e) => Agda.Syntax.Internal.Names.NamesIn (a, b, c, d, e) instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b, Agda.Syntax.Internal.Names.NamesIn c, Agda.Syntax.Internal.Names.NamesIn d, Agda.Syntax.Internal.Names.NamesIn e, Agda.Syntax.Internal.Names.NamesIn f) => Agda.Syntax.Internal.Names.NamesIn (a, b, c, d, e, f) instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.CompKit instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Common.MetaId instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.ConHead instance Agda.Syntax.Internal.Names.NamesIn GHC.Types.Bool instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.Definition instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.Defn instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.Clause instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.TypeChecking.CompiledClause.Case a) instance Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Pattern' a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Type' a) instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.Sort instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.Term instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.Level instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.PlusLevel instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Literal.Literal instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Internal.Substitution' a) instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.TypeChecking.Monad.Base.Builtin a) instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.PrimFun instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.Section instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.NLPat instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.NLPType instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.NLPSort instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.RewriteRule instance (Agda.Syntax.Internal.Names.NamesIn a, Agda.Syntax.Internal.Names.NamesIn b) => Agda.Syntax.Internal.Names.NamesIn (Data.HashMap.Internal.HashMap a b) instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.System instance Agda.Syntax.Internal.Names.NamesIn Agda.TypeChecking.Monad.Base.ExtLamInfo instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.TypeChecking.Monad.Base.FunctionInverse' a) instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Treeless.TTerm instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Treeless.TAlt instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Treeless.CaseType instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Treeless.CaseInfo instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Treeless.Compiled instance Agda.Syntax.Internal.Names.NamesIn (Agda.Syntax.Abstract.Pattern' a) instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Abstract.Name.AmbiguousQName module Agda.TypeChecking.Datatypes -- | Get true constructor with record fields. getConHead :: HasConstInfo m => QName -> m (Either SigError ConHead) isConstructor :: HasConstInfo m => QName -> m Bool -- | Get true constructor with fields, expanding literals to constructors -- if possible. getConForm :: QName -> TCM (Either SigError ConHead) -- | Augment constructor with record fields (preserve constructor name). -- The true constructor might only surface via reduce. getOrigConHead :: QName -> TCM (Either SigError ConHead) -- | Get the name of the datatype constructed by a given constructor. -- Precondition: The argument must refer to a constructor getConstructorData :: HasConstInfo m => QName -> m QName -- | Is the datatype of this constructor a Higher Inductive Type? -- Precondition: The argument must refer to a constructor of a datatype -- or record. consOfHIT :: HasConstInfo m => QName -> m Bool isPathCons :: HasConstInfo m => QName -> m Bool -- | getConType c t computes the constructor parameters from type -- t and returns them plus the instantiated type of constructor -- c. This works also if t is a function type ending in -- a data/record type; the term from which c comes need not be -- fully applied -- -- Nothing if t is not a data/record type or does not -- have a constructor c. getConType :: PureTCM m => ConHead -> Type -> m (Maybe ((QName, Type, Args), Type)) -- | getFullyAppliedConType c t computes the constructor -- parameters from data type t and returns them plus the -- instantiated type of constructor c. -- -- Nothing if t is not a data/record type or does not -- have a constructor c. -- -- Precondition: t is reduced. getFullyAppliedConType :: PureTCM m => ConHead -> Type -> m (Maybe ((QName, Type, Args), Type)) data ConstructorInfo -- | Arity. DataCon :: Nat -> ConstructorInfo -- | List of field names. RecordCon :: PatternOrCopattern -> HasEta -> [Dom QName] -> ConstructorInfo -- | Return the number of non-parameter arguments to a data constructor, or -- the field names of a record constructor. -- -- For getting just the arity of constructor c, use either -- id size $ getConstructorArity c. getConstructorInfo :: HasConstInfo m => QName -> m ConstructorInfo getConstructorInfo' :: HasConstInfo m => QName -> m (Maybe ConstructorInfo) -- | Check if a name refers to a datatype or a record with a named -- constructor. isDatatype :: QName -> TCM Bool -- | Check if a name refers to a datatype or a record. isDataOrRecordType :: QName -> TCM (Maybe DataOrRecord) -- | Precodition: Term is reduced. isDataOrRecord :: Term -> TCM (Maybe QName) getNumberOfParameters :: HasConstInfo m => QName -> m (Maybe Nat) -- | This is a simplified version of isDatatype from -- Coverage, useful when we do not want to import the module. getDatatypeArgs :: HasConstInfo m => Type -> m (Maybe (QName, Args, Args)) getNotErasedConstructors :: QName -> TCM [QName] -- | Precondition: Name is a data or record type. getConstructors :: QName -> TCM [QName] -- | Nothing if not data or record type name. getConstructors' :: QName -> TCM (Maybe [QName]) -- | Nothing if not data or record definition. getConstructors_ :: Defn -> Maybe [QName] module Agda.Syntax.Abstract.Pretty showA :: (ToConcrete a, Show (ConOfAbs a), MonadAbsToCon m) => a -> m String prettyA :: (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) => a -> m Doc prettyAs :: (ToConcrete a, ConOfAbs a ~ [ce], Pretty ce, MonadAbsToCon m) => a -> m Doc -- | Variant of showA which does not insert outermost parentheses. showATop :: (ToConcrete a, Show (ConOfAbs a), MonadAbsToCon m) => a -> m String -- | Variant of prettyA which does not insert outermost parentheses. prettyATop :: (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) => a -> m Doc -- | The translation of abstract syntax to concrete syntax has two -- purposes. First it allows us to pretty print abstract syntax values -- without having to write a dedicated pretty printer, and second it -- serves as a sanity check for the concrete to abstract translation: -- translating from concrete to abstract and then back again should be -- (more or less) the identity. module Agda.Syntax.Translation.AbstractToConcrete class ToConcrete a where { type ConOfAbs a; } toConcrete :: ToConcrete a => a -> AbsToCon (ConOfAbs a) bindToConcrete :: ToConcrete a => a -> (ConOfAbs a -> AbsToCon b) -> AbsToCon b -- | Translate something in a context of the given precedence. toConcreteCtx :: ToConcrete a => Precedence -> a -> AbsToCon (ConOfAbs a) abstractToConcrete_ :: (ToConcrete a, MonadAbsToCon m) => a -> m (ConOfAbs a) abstractToConcreteScope :: (ToConcrete a, MonadAbsToCon m) => ScopeInfo -> a -> m (ConOfAbs a) abstractToConcreteHiding :: (LensHiding i, ToConcrete a, MonadAbsToCon m) => i -> a -> m (ConOfAbs a) runAbsToCon :: MonadAbsToCon m => AbsToCon c -> m c data RangeAndPragma RangeAndPragma :: Range -> Pragma -> RangeAndPragma abstractToConcreteCtx :: (ToConcrete a, MonadAbsToCon m) => Precedence -> a -> m (ConOfAbs a) withScope :: ScopeInfo -> AbsToCon a -> AbsToCon a preserveInteractionIds :: AbsToCon a -> AbsToCon a -- | The function runAbsToCon can target any monad that satisfies -- the constraints of MonadAbsToCon. type MonadAbsToCon m = (MonadFresh NameId m, MonadInteractionPoints m, MonadStConcreteNames m, HasOptions m, PureTCM m, IsString (m Doc), Null (m Doc), Semigroup (m Doc)) data AbsToCon a data Env noTakenNames :: AbsToCon a -> AbsToCon a lookupQName :: AllowAmbiguousNames -> QName -> AbsToCon QName instance Data.Traversable.Traversable Agda.Syntax.Translation.AbstractToConcrete.MaybeSection instance Data.Foldable.Foldable Agda.Syntax.Translation.AbstractToConcrete.MaybeSection instance GHC.Base.Functor Agda.Syntax.Translation.AbstractToConcrete.MaybeSection instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Translation.AbstractToConcrete.MaybeSection a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Translation.AbstractToConcrete.MaybeSection a) instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Translation.AbstractToConcrete.MaybeSection a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Expr instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Translation.AbstractToConcrete.FreshenName instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Translation.AbstractToConcrete.BindingPattern instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.SplitPattern Agda.Syntax.Abstract.Pattern) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.SplitPattern (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Pattern instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.UserPattern Agda.Syntax.Abstract.Pattern) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.UserPattern (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Declaration instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Translation.AbstractToConcrete.RangeAndPragma instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete () instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete GHC.Types.Bool instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete [a] instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Utils.List1.List1 a) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a1, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a2) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Data.Either.Either a1 a2) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a1, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a2) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (a1, a2) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a1, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a2, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a3) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (a1, a2, a3) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.Arg a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.WithHiding a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.Named name a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Name.Name instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.BindName instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Name.ModuleName instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Scope.Base.ResolvedName instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Concrete.FieldAssignment' a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Abstract.Binder' a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LamBinding instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.TypedBinding instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LetBinding instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.WhereDeclarations instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.RHS instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete p, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.RewriteEqn' qn Agda.Syntax.Abstract.BindName p a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (GHC.Maybe.Maybe Agda.Syntax.Abstract.BindName) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (GHC.Maybe.Maybe Agda.Syntax.Abstract.Name.QName) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.Constr Agda.Syntax.Abstract.Constructor) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a, Agda.Syntax.Translation.AbstractToConcrete.ConOfAbs a GHC.Types.~ Agda.Syntax.Concrete.LHS) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Abstract.Clause' a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.ModuleApplication instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.SpineLHS instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LHS instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LHSCore instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (GHC.Maybe.Maybe Agda.Syntax.Abstract.Pattern) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Common.InteractionId instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.TypeChecking.Monad.Base.NamedMeta instance GHC.Base.Functor Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance GHC.Base.Applicative Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance GHC.Base.Monad Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Control.Monad.Fail.MonadFail Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Control.Monad.Reader.Class.MonadReader Agda.Syntax.Translation.AbstractToConcrete.Env Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Base.MonadStConcreteNames Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Builtin.HasBuiltins Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.Interaction.Options.HasOptions.HasOptions Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Debug.MonadDebug Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Signature.HasConstInfo Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Context.MonadAddContext Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Base.MonadReduce Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Pure.PureTCM Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.Base.MonadFresh Agda.Syntax.Common.NameId Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints Agda.Syntax.Translation.AbstractToConcrete.AbsToCon instance Data.String.IsString (Agda.Syntax.Translation.AbstractToConcrete.AbsToCon Text.PrettyPrint.HughesPJ.Doc) instance Agda.Utils.Null.Null (Agda.Syntax.Translation.AbstractToConcrete.AbsToCon Text.PrettyPrint.HughesPJ.Doc) instance GHC.Base.Semigroup (Agda.Syntax.Translation.AbstractToConcrete.AbsToCon Text.PrettyPrint.HughesPJ.Doc) -- | A typeclass collecting all pure typechecking operations | (i.e. -- ones that do not modify the typechecking state, throw or | catch -- errors, or do IO other than debug printing). module Agda.TypeChecking.Monad.Pure class (HasBuiltins m, HasConstInfo m, MonadAddContext m, MonadDebug m, MonadReduce m, MonadTCEnv m, ReadTCState m) => PureTCM m instance Agda.TypeChecking.Monad.Pure.PureTCM Agda.TypeChecking.Monad.Base.TCM instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Control.Monad.Trans.Except.ExceptT e m) instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Control.Monad.Trans.Reader.ReaderT r m) instance (Agda.TypeChecking.Monad.Pure.PureTCM m, GHC.Base.Monoid w) => Agda.TypeChecking.Monad.Pure.PureTCM (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Pure.PureTCM m => Agda.TypeChecking.Monad.Pure.PureTCM (Control.Monad.Trans.State.Lazy.StateT s m) module Agda.TypeChecking.Monad.Context -- | Modify a Context in a computation. Warning: does not update the -- checkpoints. Use updateContext instead. unsafeModifyContext :: MonadTCEnv tcm => (Context -> Context) -> tcm a -> tcm a -- | Modify the Dom' part of context entries. modifyContextInfo :: MonadTCEnv tcm => (forall e. Dom e -> Dom e) -> tcm a -> tcm a -- | Change to top (=empty) context. Resets the checkpoints. inTopContext :: (MonadTCEnv tcm, ReadTCState tcm) => tcm a -> tcm a -- | Change to top (=empty) context, but don't update the checkpoints. -- Totally not safe! unsafeInTopContext :: (MonadTCEnv m, ReadTCState m) => m a -> m 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. unsafeEscapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a -- | Delete the last n bindings from the context. Any occurrences -- of these variables are replaced with the given err. escapeContext :: MonadAddContext m => Impossible -> Int -> m a -> m a -- | Add a new checkpoint. Do not use directly! checkpoint :: (MonadDebug tcm, MonadTCM tcm, MonadFresh CheckpointId tcm, ReadTCState tcm) => Substitution -> tcm a -> tcm a -- | Get the substitution from the context at a given checkpoint to the -- current context. checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution -- | Get the substitution from the context at a given checkpoint to the -- current context. checkpointSubstitution' :: MonadTCEnv tcm => CheckpointId -> tcm (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. getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m (Maybe Substitution) class MonadTCEnv m => MonadAddContext m -- | addCtx x arg cont add a variable to the context. -- -- Chooses an unused Name. -- -- Warning: Does not update module parameter substitution! addCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a -- | Add a let bound variable to the context addLetBinding' :: MonadAddContext m => Name -> Term -> Dom Type -> m a -> m a -- | Update the context. Requires a substitution that transports things -- living in the old context to the new. updateContext :: MonadAddContext m => Substitution -> (Context -> Context) -> m a -> m a withFreshName :: MonadAddContext m => Range -> ArgName -> (Name -> 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! addCtx :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Name -> Dom Type -> m a -> m a -- | Add a let bound variable to the context addLetBinding' :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Name -> Term -> Dom Type -> m a -> m a -- | Update the context. Requires a substitution that transports things -- living in the old context to the new. updateContext :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Substitution -> (Context -> Context) -> m a -> m a withFreshName :: (MonadAddContext m, MonadAddContext n, MonadTransControl t, t n ~ m) => Range -> ArgName -> (Name -> m a) -> m a -- | Default implementation of addCtx in terms of updateContext defaultAddCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a withFreshName_ :: MonadAddContext m => ArgName -> (Name -> m a) -> m a -- | 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. withShadowingNameTCM :: Name -> TCM b -> TCM b addRecordNameContext :: (MonadAddContext m, MonadFresh NameId m) => Dom Type -> m b -> m b -- | Various specializations of addCtx. class AddContext b addContext :: (AddContext b, MonadAddContext m) => b -> m a -> m a contextSize :: AddContext b => b -> Nat -- | Wrapper to tell addContext not to mark names as -- TypeError. Used when adding a user-provided, but already type -- checked, telescope to the context. newtype KeepNames a KeepNames :: a -> KeepNames a -- | Go under an abstraction. Do not extend context in case of -- NoAbs. underAbstraction :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b underAbstraction' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b -- | Go under an abstraction, treating NoAbs as Abs. underAbstractionAbs :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b underAbstractionAbs' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b -- | Go under an abstract without worrying about the type to add to the -- context. underAbstraction_ :: (Subst a, MonadAddContext m) => Abs a -> (a -> m b) -> m b -- | Map a monadic function on the thing under the abstraction, adding the -- abstracted variable to the context. mapAbstraction :: (Subst a, Subst b, MonadAddContext m) => Dom Type -> (a -> m b) -> Abs a -> m (Abs b) getLetBindings :: MonadTCM tcm => tcm [(Name, (Term, Dom Type))] -- | Add a let bound variable defaultAddLetBinding' :: (ReadTCState m, 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 -- | Get the current context. getContext :: MonadTCEnv m => m Context -- | Get the size of the current context. getContextSize :: (Applicative m, MonadTCEnv m) => m Nat -- | Generate [var (n - 1), ..., var 0] for all declarations in -- the 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] -- | Get the current context as a Telescope. getContextTelescope :: (Applicative m, MonadTCEnv m) => m Telescope -- | Get the names of all declarations in the context. getContextNames :: (Applicative m, MonadTCEnv m) => m [Name] -- | get type of bound variable (i.e. deBruijn index) lookupBV' :: MonadTCEnv m => Nat -> m (Maybe ContextEntry) 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 -- | 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. getVarInfo :: (MonadFail m, MonadTCEnv m) => Name -> m (Term, Dom Type) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Agda.TypeChecking.Monad.Base.BlockT m) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.TypeChecking.Monad.Context.KeepNames GHC.Base.String, Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.TypeChecking.Monad.Context.KeepNames Agda.Syntax.Internal.Telescope) instance Agda.TypeChecking.Monad.Context.AddContext a => Agda.TypeChecking.Monad.Context.AddContext [a] instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Abstract.Name.Name, Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Internal.Dom (Agda.Syntax.Abstract.Name.Name, Agda.Syntax.Internal.Type)) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Internal.Dom (GHC.Base.String, Agda.Syntax.Internal.Type)) instance Agda.TypeChecking.Monad.Context.AddContext ([Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Utils.List1.List1 Agda.Syntax.Abstract.Name.Name, Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext ([Agda.Syntax.Common.WithHiding Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Utils.List1.List1 (Agda.Syntax.Common.WithHiding Agda.Syntax.Abstract.Name.Name), Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext ([Agda.Syntax.Common.Arg Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Utils.List1.List1 (Agda.Syntax.Common.Arg Agda.Syntax.Abstract.Name.Name), Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext ([Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Utils.List1.List1 (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Name.Name), Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (GHC.Base.String, Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Data.Text.Internal.Text, Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Monad.Context.AddContext Agda.Syntax.Abstract.Name.Name instance Agda.TypeChecking.Monad.Context.AddContext GHC.Base.String instance Agda.TypeChecking.Monad.Context.AddContext Agda.Syntax.Internal.Telescope instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Control.Monad.Trans.Except.ExceptT e m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Control.Monad.Trans.State.Lazy.StateT r m) instance (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Context.MonadAddContext m) => Agda.TypeChecking.Monad.Context.MonadAddContext (Control.Monad.Trans.Writer.Lazy.WriterT w m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Agda.Utils.ListT.ListT m) instance Agda.TypeChecking.Monad.Context.MonadAddContext Agda.TypeChecking.Monad.Base.TCM module Agda.TypeChecking.Monad.Open -- | Create an open term in the current context. makeOpen :: (ReadTCState m, MonadTCEnv m) => a -> m (Open a) -- | Extract the value from an open term. The checkpoint at which it was -- created must be in scope. getOpen :: (TermSubst a, MonadTCEnv m) => Open a -> m a -- | Extract the value from an open term. If the checkpoint is no longer in -- scope use the provided function to pull the object to the most recent -- common checkpoint. The function is given the substitution from the -- common ancestor to the checkpoint of the thing. tryGetOpen :: (TermSubst a, ReadTCState m, MonadTCEnv m) => (Substitution -> a -> Maybe a) -> Open a -> m (Maybe a) -- | An Open is closed if it has checkpoint 0. isClosed :: Open a -> Bool module Agda.TypeChecking.Monad.MetaVars -- | Various kinds of metavariables. data MetaKind -- | Meta variables of record type. Records :: MetaKind -- | Meta variables of "hereditarily singleton" record type. SingletonRecords :: MetaKind -- | Meta variables of level type, if type-in-type is activated. Levels :: MetaKind -- | All possible metavariable kinds. allMetaKinds :: [MetaKind] data KeepMetas KeepMetas :: KeepMetas RollBackMetas :: KeepMetas -- | Monad service class for creating, solving and eta-expanding of -- metavariables. class (MonadConstraint m, MonadReduce m, MonadAddContext m, MonadTCEnv m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) => MonadMetaSolver m -- | Generate a new meta variable with some instantiation given. For -- instance, the instantiation could be a -- PostponedTypeCheckingProblem. newMeta' :: MonadMetaSolver m => MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId -- | 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. assignV :: MonadMetaSolver m => CompareDirection -> MetaId -> Args -> Term -> CompareAs -> m () -- | Directly instantiate the metavariable. Skip pattern check, occurs -- check and frozen check. Used for eta expanding frozen metas. assignTerm' :: (MonadMetaSolver m, MonadMetaSolver m) => MetaId -> [Arg ArgName] -> Term -> m () -- | Eta-expand a local meta-variable, if it is of the specified kind. -- Don't do anything if the meta-variable is a blocked term. etaExpandMeta :: MonadMetaSolver m => [MetaKind] -> MetaId -> m () -- | Update the status of the metavariable updateMetaVar :: MonadMetaSolver m => MetaId -> (MetaVariable -> MetaVariable) -> 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. speculateMetas :: MonadMetaSolver m => m () -> m KeepMetas -> m () -- | Switch off assignment of metas. dontAssignMetas :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a -- | Is the meta-variable from another top-level module? isRemoteMeta :: ReadTCState m => m (MetaId -> Bool) -- | If another meta-variable is created, then it will get this -- MetaId (unless the state is changed too much, for instance by -- setTopLevelModule). nextLocalMeta :: ReadTCState m => m MetaId -- | Pairs of local meta-stores. data LocalMetaStores LocalMetaStores :: LocalMetaStore -> LocalMetaStore -> LocalMetaStores -- | A MetaStore containing open meta-variables. [openMetas] :: LocalMetaStores -> LocalMetaStore -- | A MetaStore containing instantiated meta-variables. [solvedMetas] :: LocalMetaStores -> LocalMetaStore -- | Run a computation and record which new metas it created. metasCreatedBy :: forall m a. ReadTCState m => m a -> m (a, LocalMetaStores) -- | Find information about the given local meta-variable, if any. lookupLocalMeta' :: ReadTCState m => MetaId -> m (Maybe MetaVariable) -- | Find information about the given local meta-variable. lookupLocalMeta :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m MetaVariable -- | Find information about the (local or remote) meta-variable, if any. -- -- If no meta-variable is found, then the reason could be that the -- dead-code elimination (eliminateDeadCode) failed to find the -- meta-variable, perhaps because some NamesIn instance is -- incorrectly defined. lookupMeta :: ReadTCState m => MetaId -> m (Maybe (Either RemoteMetaVariable MetaVariable)) -- | Find the meta-variable's instantiation. lookupMetaInstantiation :: ReadTCState m => MetaId -> m MetaInstantiation -- | Find the meta-variable's judgement. lookupMetaJudgement :: ReadTCState m => MetaId -> m (Judgement MetaId) -- | Find the meta-variable's modality. lookupMetaModality :: ReadTCState m => MetaId -> m Modality -- | The type of a term or sort meta-variable. metaType :: ReadTCState m => MetaId -> m Type -- | Update the information associated with a local meta-variable. updateMetaVarTCM :: HasCallStack => MetaId -> (MetaVariable -> MetaVariable) -> TCM () -- | Insert a new meta-variable with associated information into the local -- meta store. insertMetaVar :: MetaId -> MetaVariable -> TCM () -- | Returns the MetaPriority of the given local meta-variable. getMetaPriority :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m MetaPriority isSortMeta :: ReadTCState m => MetaId -> m Bool isSortMeta_ :: MetaVariable -> Bool isSortJudgement :: Judgement a -> Bool getMetaType :: ReadTCState m => MetaId -> m Type -- | Compute the context variables that a local meta-variable should be -- applied to, accounting for pruning. getMetaContextArgs :: MonadTCEnv m => MetaVariable -> m Args -- | Given a local meta-variable, return the type applied to the current -- context. getMetaTypeInContext :: (HasBuiltins m, HasCallStack, MonadDebug m, MonadReduce m, MonadTCEnv m, ReadTCState m) => MetaId -> m Type -- | Is it a local meta-variable that might be generalized? isGeneralizableMeta :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m DoGeneralize -- | Check whether all metas are instantiated. Precondition: argument is a -- meta (in some form) or a list of metas. class IsInstantiatedMeta a isInstantiatedMeta :: (IsInstantiatedMeta a, MonadFail m, ReadTCState m) => a -> m Bool isInstantiatedMeta' :: (MonadFail m, ReadTCState m) => MetaId -> m (Maybe Term) -- | Returns all metavariables in a constraint. Slightly complicated by the -- fact that blocked terms are represented by two meta variables. To find -- the second one we need to look up the meta listeners for the one in -- the UnBlock constraint. This is used for the purpose of deciding if a -- metavariable is constrained or if it can be generalized over (see -- Agda.TypeChecking.Generalize). constraintMetas :: Constraint -> TCM (Set MetaId) -- | Create MetaInfo in the current environment. createMetaInfo :: (MonadTCEnv m, ReadTCState m) => m MetaInfo createMetaInfo' :: (MonadTCEnv m, ReadTCState m) => RunMetaOccursCheck -> m MetaInfo setValueMetaName :: MonadMetaSolver m => Term -> MetaNameSuggestion -> m () getMetaNameSuggestion :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m MetaNameSuggestion setMetaNameSuggestion :: MonadMetaSolver m => MetaId -> MetaNameSuggestion -> m () -- | Change the ArgInfo that will be used when generalizing over this local -- meta-variable. setMetaGeneralizableArgInfo :: MonadMetaSolver m => MetaId -> ArgInfo -> m () updateMetaVarRange :: MonadMetaSolver m => MetaId -> Range -> m () setMetaOccursCheck :: MonadMetaSolver m => MetaId -> RunMetaOccursCheck -> m () class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m freshInteractionId :: MonadInteractionPoints m => m InteractionId freshInteractionId :: (MonadInteractionPoints m, MonadTrans t, MonadInteractionPoints n, t n ~ m) => m InteractionId modifyInteractionPoints :: MonadInteractionPoints m => (InteractionPoints -> InteractionPoints) -> m () modifyInteractionPoints :: (MonadInteractionPoints m, MonadTrans t, MonadInteractionPoints n, t n ~ m) => (InteractionPoints -> InteractionPoints) -> m () -- | Register an interaction point during scope checking. If there is no -- interaction id yet, create one. registerInteractionPoint :: forall m. MonadInteractionPoints m => Bool -> Range -> Maybe Nat -> m InteractionId -- | Find an interaction point by Range' by searching the whole map. -- Issue 3000: Don't consider solved interaction points. -- -- O(n): linear in the number of registered interaction points. findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId -- | Hook up a local meta-variable to an interaction point. connectInteractionPoint :: MonadInteractionPoints m => InteractionId -> MetaId -> m () -- | Mark an interaction point as solved. removeInteractionPoint :: MonadInteractionPoints m => InteractionId -> m () -- | Get a list of interaction ids. getInteractionPoints :: ReadTCState m => m [InteractionId] -- | Get all metas that correspond to unsolved interaction ids. getInteractionMetas :: ReadTCState m => m [MetaId] getUniqueMetasRanges :: (HasCallStack, MonadDebug m, ReadTCState m) => [MetaId] -> m [Range] getUnsolvedMetas :: (HasCallStack, MonadDebug m, ReadTCState m) => m [Range] getUnsolvedInteractionMetas :: (HasCallStack, MonadDebug m, ReadTCState m) => m [Range] -- | Get all metas that correspond to unsolved interaction ids. getInteractionIdsAndMetas :: ReadTCState m => m [(InteractionId, MetaId)] -- | Does the meta variable correspond to an interaction point? -- -- Time: O(log n) where n is the number of interaction -- metas. isInteractionMeta :: ReadTCState m => MetaId -> m (Maybe InteractionId) -- | Get the information associated to an interaction point. lookupInteractionPoint :: (MonadFail m, ReadTCState m, MonadError TCErr m) => InteractionId -> m InteractionPoint -- | Get MetaId for an interaction point. Precondition: interaction -- point is connected. lookupInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m MetaId -- | Check whether an interaction id is already associated with a meta -- variable. lookupInteractionMeta :: ReadTCState m => InteractionId -> m (Maybe MetaId) lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId -- | Generate new meta variable. newMeta :: MonadMetaSolver m => 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. newMetaTCM' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId -- | Get the Range' for an interaction point. getInteractionRange :: (MonadInteractionPoints m, MonadFail m, MonadError TCErr m) => InteractionId -> m Range -- | Get the Range' for a local meta-variable. getMetaRange :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m Range getInteractionScope :: (MonadDebug m, MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m ScopeInfo withMetaInfo' :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => MetaVariable -> m a -> m a withMetaInfo :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => Closure Range -> m a -> m a withInteractionId :: (MonadDebug m, MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m, MonadTrace m) => InteractionId -> m a -> m a withMetaId :: (HasCallStack, MonadDebug m, MonadTCEnv m, MonadTrace m, ReadTCState m) => MetaId -> m a -> m a getOpenMetas :: ReadTCState m => m [MetaId] isOpenMeta :: MetaInstantiation -> Bool -- | listenToMeta l m: register l as a listener to -- m. This is done when the type of l is blocked by m. listenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () -- | Unregister a listener. unlistenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () -- | Get the listeners for a local meta-variable. getMetaListeners :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m [Listener] clearMetaListeners :: MonadMetaSolver m => MetaId -> m () -- | Do safe eta-expansions for meta (SingletonRecords,Levels). etaExpandMetaSafe :: MonadMetaSolver m => MetaId -> m () -- | Eta expand metavariables listening on the current meta. etaExpandListeners :: MonadMetaSolver m => MetaId -> m () -- | Wake up a meta listener and let it do its thing wakeupListener :: MonadMetaSolver m => Listener -> m () solveAwakeConstraints :: MonadConstraint m => m () solveAwakeConstraints' :: MonadConstraint m => Bool -> m () -- | Freeze the given meta-variables (but only if they are open) and return -- those that were not already frozen. freezeMetas :: MonadTCState m => LocalMetaStore -> m (Set MetaId) -- | Thaw all open meta variables. unfreezeMetas :: TCM () isFrozen :: (HasCallStack, MonadDebug m, ReadTCState m) => MetaId -> m Bool withFrozenMetas :: (MonadMetaSolver m, MonadTCState m) => m a -> m a -- | Unfreeze a meta and its type if this is a meta again. Does not -- unfreeze deep occurrences of meta-variables or remote meta-variables. class UnFreezeMeta a unfreezeMeta :: (UnFreezeMeta a, MonadMetaSolver m) => a -> m () instance GHC.Show.Show Agda.TypeChecking.Monad.MetaVars.MetaKind instance GHC.Enum.Bounded Agda.TypeChecking.Monad.MetaVars.MetaKind instance GHC.Enum.Enum Agda.TypeChecking.Monad.MetaVars.MetaKind instance GHC.Classes.Eq Agda.TypeChecking.Monad.MetaVars.MetaKind instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta Agda.Syntax.Internal.Type instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta Agda.Syntax.Internal.Term instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta Agda.Syntax.Internal.Level instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta a => Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta [a] instance Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta a => Agda.TypeChecking.Monad.MetaVars.UnFreezeMeta (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints m => Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints (Control.Monad.Trans.Identity.IdentityT m) instance Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints m => Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints (Control.Monad.Trans.Reader.ReaderT r m) instance Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints m => Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints (Control.Monad.Trans.State.Lazy.StateT s m) instance Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints Agda.TypeChecking.Monad.Base.TCM instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta Agda.Syntax.Internal.Term instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta Agda.Syntax.Internal.Level instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta a => Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta [a] instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta a => Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta a => Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta a => Agda.TypeChecking.Monad.MetaVars.IsInstantiatedMeta (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Monad.MetaVars.MonadMetaSolver m => Agda.TypeChecking.Monad.MetaVars.MonadMetaSolver (Control.Monad.Trans.Reader.ReaderT r m) module Agda.TypeChecking.Monad.Constraints 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 -- | Get the awake constraints getAwakeConstraints :: ReadTCState m => m Constraints dropConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () -- | Takes out all constraints matching given filter. Danger! The taken -- constraints need to be solved or put back at some point. takeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m Constraints putConstraintsToSleep :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () putAllConstraintsToSleep :: MonadConstraint m => m () data ConstraintStatus AwakeConstraint :: ConstraintStatus SleepingConstraint :: ConstraintStatus -- | 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. holdConstraints :: (ConstraintStatus -> ProblemConstraint -> Bool) -> TCM a -> TCM a takeAwakeConstraint :: MonadConstraint m => m (Maybe ProblemConstraint) takeAwakeConstraint' :: MonadConstraint m => (ProblemConstraint -> Bool) -> m (Maybe ProblemConstraint) getAllConstraints :: ReadTCState m => m Constraints withConstraint :: MonadConstraint m => (Constraint -> m a) -> ProblemConstraint -> m a buildProblemConstraint :: (MonadTCEnv m, ReadTCState m) => Set ProblemId -> Blocker -> Constraint -> m ProblemConstraint buildProblemConstraint_ :: (MonadTCEnv m, ReadTCState m) => Blocker -> Constraint -> m ProblemConstraint buildConstraint :: Blocker -> Constraint -> TCM ProblemConstraint -- | Monad service class containing methods for adding and solving -- constraints class (MonadTCEnv m, ReadTCState m, MonadError TCErr m, MonadBlock m, HasOptions m, MonadDebug m) => MonadConstraint m -- | Unconditionally add the constraint. addConstraint :: MonadConstraint m => Blocker -> Constraint -> m () -- | Add constraint as awake constraint. addAwakeConstraint :: MonadConstraint m => Blocker -> Constraint -> m () solveConstraint :: MonadConstraint m => Constraint -> m () -- | Solve awake constraints matching the predicate. If the second argument -- is True solve constraints even if already isSolvingConstraints. solveSomeAwakeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> Bool -> m () wakeConstraints :: MonadConstraint m => (ProblemConstraint -> WakeUp) -> m () stealConstraints :: MonadConstraint m => ProblemId -> m () modifyAwakeConstraints :: MonadConstraint m => (Constraints -> Constraints) -> m () modifySleepingConstraints :: MonadConstraint m => (Constraints -> Constraints) -> m () addAndUnblocker :: MonadBlock m => Blocker -> m a -> m a addOrUnblocker :: MonadBlock m => Blocker -> m a -> m a -- | Add new a constraint addConstraint' :: Blocker -> Constraint -> TCM () addAwakeConstraint' :: Blocker -> Constraint -> TCM () addConstraintTo :: Lens' Constraints TCState -> Blocker -> Constraint -> TCM () -- | Start solving constraints nowSolvingConstraints :: MonadTCEnv m => m a -> m a isSolvingConstraints :: MonadTCEnv m => m Bool -- | Add constraint if the action raises a pattern violation catchConstraint :: MonadConstraint m => Constraint -> m () -> m () isInstanceConstraint :: Constraint -> Bool shouldPostponeInstanceSearch :: (ReadTCState m, HasOptions m) => m Bool -- | Wake constraints matching the given predicate (and aren't instance -- constraints if shouldPostponeInstanceSearch). wakeConstraints' :: MonadConstraint m => (ProblemConstraint -> WakeUp) -> m () mapAwakeConstraints :: (Constraints -> Constraints) -> TCState -> TCState mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState instance GHC.Show.Show Agda.TypeChecking.Monad.Constraints.ConstraintStatus instance GHC.Classes.Eq Agda.TypeChecking.Monad.Constraints.ConstraintStatus instance Agda.TypeChecking.Monad.Constraints.MonadConstraint m => Agda.TypeChecking.Monad.Constraints.MonadConstraint (Control.Monad.Trans.Reader.ReaderT e m) module Agda.TypeChecking.Monad.Closure 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) module Agda.TypeChecking.Monad.Env -- | Get the name of the current module, if any. currentModule :: MonadTCEnv m => m ModuleName -- | Set the name of the current module. withCurrentModule :: MonadTCEnv m => ModuleName -> m a -> m a -- | Get the path of the currently checked file getCurrentPath :: MonadTCEnv m => m AbsolutePath -- | Get the number of variables bound by anonymous modules. getAnonymousVariables :: MonadTCEnv m => ModuleName -> m Nat -- | Add variables bound by an anonymous module. withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a -- | Set the current environment to the given withEnv :: MonadTCEnv m => TCEnv -> m a -> m a -- | Get the current environment getEnv :: TCM TCEnv -- | Set highlighting level withHighlightingLevel :: HighlightingLevel -> TCM a -> TCM a -- | Restore setting for ExpandLast to default. doExpandLast :: TCM a -> TCM a dontExpandLast :: TCM a -> TCM a reallyDontExpandLast :: TCM a -> TCM a -- | If the reduced did a proper match (constructor or literal pattern), -- then record this as simplification step. performedSimplification :: MonadTCEnv m => m a -> m a performedSimplification' :: MonadTCEnv m => Simplification -> m a -> m a getSimplification :: MonadTCEnv m => m Simplification -- | Lens for AllowedReductions. updateAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCEnv -> TCEnv modifyAllowedReductions :: MonadTCEnv m => (AllowedReductions -> AllowedReductions) -> m a -> m a putAllowedReductions :: MonadTCEnv m => AllowedReductions -> m a -> m a -- | Reduce Def f vs only if f is a projection. onlyReduceProjections :: MonadTCEnv m => m a -> m a -- | Allow all reductions except for non-terminating functions (default). allowAllReductions :: MonadTCEnv m => m a -> m a -- | Allow all reductions including non-terminating functions. allowNonTerminatingReductions :: MonadTCEnv m => m a -> m a -- | Allow all reductions when reducing types. Otherwise only allow inlined -- functions to be unfolded. onlyReduceTypes :: MonadTCEnv m => m a -> m a -- | Update allowed reductions when working on types typeLevelReductions :: MonadTCEnv m => m a -> m a insideDotPattern :: TCM a -> TCM a isInsideDotPattern :: TCM Bool -- | Don't use call-by-need evaluation for the given computation. callByName :: TCM a -> TCM a -- | Check that a datatype is strictly positive. module Agda.TypeChecking.Positivity type Graph n e = Graph n e -- | Check that the datatypes in the mutual block containing the given -- declarations are strictly positive. -- -- Also add information about positivity and recursivity of records to -- the signature. checkStrictlyPositive :: MutualInfo -> Set QName -> TCM () getDefArity :: Definition -> TCM Int data Item AnArg :: Nat -> Item ADef :: QName -> Item type Occurrences = Map Item [OccursWhere] -- | Used to build Occurrences and occurrence graphs. data OccurrencesBuilder Concat :: [OccurrencesBuilder] -> OccurrencesBuilder OccursAs :: Where -> OccurrencesBuilder -> OccurrencesBuilder OccursHere :: Item -> OccurrencesBuilder -- | OnlyVarsUpTo n occs discards occurrences of de Bruijn index -- >= n. OnlyVarsUpTo :: Nat -> OccurrencesBuilder -> OccurrencesBuilder -- | Used to build Occurrences and occurrence graphs. data OccurrencesBuilder' Concat' :: [OccurrencesBuilder'] -> OccurrencesBuilder' OccursAs' :: Where -> OccurrencesBuilder' -> OccurrencesBuilder' OccursHere' :: Item -> OccurrencesBuilder' -- | Removes OnlyVarsUpTo entries. preprocess :: OccurrencesBuilder -> OccurrencesBuilder' -- | An interpreter for OccurrencesBuilder. -- -- WARNING: There can be lots of sharing between the generated -- OccursWhere entries. Traversing all of these entries could be -- expensive. (See computeEdges for an example.) flatten :: OccurrencesBuilder -> Map Item Integer -- | Context for computing occurrences. data OccEnv OccEnv :: [Maybe Item] -> Maybe QName -> OccEnv -- | Items corresponding to the free variables. -- -- Potential invariant: It seems as if the list has the form -- genericReplicate n Nothing ++ map -- (Just . AnArg) is, for some n and -- is, where is is decreasing (non-strictly). [vars] :: OccEnv -> [Maybe Item] -- | Name for ∞ builtin. [inf] :: OccEnv -> Maybe QName -- | Monad for computing occurrences. type OccM = Reader OccEnv withExtendedOccEnv :: Maybe Item -> OccM a -> OccM a withExtendedOccEnv' :: [Maybe Item] -> OccM a -> OccM a -- | Running the monad getOccurrences :: (Show a, PrettyTCM a, ComputeOccurrences a) => [Maybe Item] -> a -> TCM OccurrencesBuilder class ComputeOccurrences a occurrences :: ComputeOccurrences a => a -> OccM OccurrencesBuilder occurrences :: (ComputeOccurrences a, Foldable t, ComputeOccurrences b, t b ~ a) => a -> OccM OccurrencesBuilder -- | Computes the number of occurrences of different Items in the -- given definition. -- -- WARNING: There can be lots of sharing between the OccursWhere -- entries. Traversing all of these entries could be expensive. (See -- computeEdges for an example.) computeOccurrences :: QName -> TCM (Map Item Integer) -- | Computes the occurrences in the given definition. computeOccurrences' :: QName -> TCM OccurrencesBuilder data Node DefNode :: !QName -> Node ArgNode :: !QName -> !Nat -> Node -- | Edge labels for the positivity graph. data Edge a Edge :: !Occurrence -> a -> Edge a -- | Merges two edges between the same source and target. mergeEdges :: Edge a -> Edge a -> Edge a -- | WARNING: There can be lots of sharing between the OccursWhere -- entries in the edges. Traversing all of these entries could be -- expensive. (See computeEdges for an example.) buildOccurrenceGraph :: Set QName -> TCM (Graph Node (Edge OccursWhere)) -- | Computes all non-ozero occurrence graph edges represented by -- the given OccurrencesBuilder. -- -- WARNING: There can be lots of sharing between the OccursWhere -- entries in the edges. Traversing all of these entries could be -- expensive. For instance, for the function F in -- benchmarkmiscSlowOccurrences.agda a large number of -- edges from the argument X to the function F are -- computed. These edges have polarity StrictPos, JustNeg -- or JustPos, and contain the following OccursWhere -- elements: -- -- computeEdges :: Set QName -> QName -> OccurrencesBuilder -> TCM [Edge Node (Edge OccursWhere)] instance GHC.Show.Show Agda.TypeChecking.Positivity.Item instance GHC.Classes.Ord Agda.TypeChecking.Positivity.Item instance GHC.Classes.Eq Agda.TypeChecking.Positivity.Item instance GHC.Classes.Ord Agda.TypeChecking.Positivity.Node instance GHC.Classes.Eq Agda.TypeChecking.Positivity.Node instance GHC.Base.Functor Agda.TypeChecking.Positivity.Edge instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Positivity.Edge a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.TypeChecking.Positivity.Edge a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Positivity.Edge a) instance Agda.Utils.SemiRing.SemiRing (Agda.TypeChecking.Positivity.Edge (Data.Sequence.Internal.Seq Agda.TypeChecking.Positivity.Occurrence.OccursWhere)) instance Agda.TypeChecking.Pretty.PrettyTCMWithNode (Agda.TypeChecking.Positivity.Edge Agda.TypeChecking.Positivity.Occurrence.OccursWhere) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Node instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Positivity.Node instance Agda.TypeChecking.Positivity.ComputeOccurrences Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Positivity.ComputeOccurrences Agda.Syntax.Internal.Term instance Agda.TypeChecking.Positivity.ComputeOccurrences Agda.Syntax.Internal.Level instance Agda.TypeChecking.Positivity.ComputeOccurrences Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Positivity.ComputeOccurrences Agda.Syntax.Internal.Type instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences [a] instance Agda.TypeChecking.Positivity.ComputeOccurrences a => Agda.TypeChecking.Positivity.ComputeOccurrences (GHC.Maybe.Maybe a) instance (Agda.TypeChecking.Positivity.ComputeOccurrences a, Agda.TypeChecking.Positivity.ComputeOccurrences b) => Agda.TypeChecking.Positivity.ComputeOccurrences (a, b) instance (GHC.Base.Semigroup a, GHC.Base.Monoid a) => GHC.Base.Monoid (Agda.TypeChecking.Positivity.OccM a) instance GHC.Base.Semigroup Agda.TypeChecking.Positivity.OccurrencesBuilder instance GHC.Base.Monoid Agda.TypeChecking.Positivity.OccurrencesBuilder instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Positivity.Item instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Item instance Agda.TypeChecking.Pretty.PrettyTCM (Data.Sequence.Internal.Seq Agda.TypeChecking.Positivity.Occurrence.OccursWhere) module Agda.TypeChecking.Functions -- | Expand a clause to the maximal arity, by inserting variable patterns -- and applying the body to variables. etaExpandClause :: MonadTCM tcm => Clause -> tcm Clause -- | Get the name of defined symbol of the head normal form of a term. -- Returns Nothing if no such head exists. getDef :: Term -> TCM (Maybe QName) module Agda.TypeChecking.DropArgs -- | When making a function projection-like, we drop the first n -- arguments. class DropArgs a dropArgs :: DropArgs a => Int -> a -> a instance Agda.TypeChecking.DropArgs.DropArgs a => Agda.TypeChecking.DropArgs.DropArgs (GHC.Maybe.Maybe a) instance Agda.TypeChecking.DropArgs.DropArgs Agda.Syntax.Internal.Telescope instance Agda.TypeChecking.DropArgs.DropArgs Agda.Utils.Permutation.Permutation instance Agda.TypeChecking.DropArgs.DropArgs Agda.Syntax.Internal.Clause instance Agda.TypeChecking.DropArgs.DropArgs Agda.TypeChecking.Monad.Base.FunctionInverse instance Agda.TypeChecking.DropArgs.DropArgs Agda.Syntax.Internal.Term instance Agda.TypeChecking.DropArgs.DropArgs Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.TypeChecking.DropArgs.DropArgs Agda.TypeChecking.Coverage.SplitTree.SplitTree -- | Computing the polarity (variance) of function arguments, for the sake -- of subtyping. module Agda.TypeChecking.Polarity -- | Main function of this module. computePolarity :: (HasOptions m, HasConstInfo m, HasBuiltins m, MonadTCEnv m, MonadTCState m, MonadReduce m, MonadAddContext m, MonadTCError m, MonadDebug m, MonadPretty m) => [QName] -> m () -- | What is the polarity of a function composition? composePol :: Polarity -> Polarity -> Polarity -- | Get the next polarity from a list, Invariant if empty. nextPolarity :: [Polarity] -> (Polarity, [Polarity]) -- | Replace Nonvariant by Covariant. (Arbitrary bias, but -- better than Invariant, see issue 1596). purgeNonvariant :: [Polarity] -> [Polarity] polFromOcc :: Occurrence -> Polarity instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity [a] instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Level' a) instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.PlusLevel' a) instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Type'' t a) instance (Agda.TypeChecking.Polarity.HasPolarity a, Agda.TypeChecking.Polarity.HasPolarity b) => Agda.TypeChecking.Polarity.HasPolarity (a, b) instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Polarity.HasPolarity Agda.Syntax.Internal.Term instance GHC.Base.Monad m => Agda.Utils.Singleton.Singleton Agda.TypeChecking.Monad.Base.Polarity (Agda.TypeChecking.Polarity.LeastPolarity m) instance GHC.Base.Monad m => GHC.Base.Semigroup (Agda.TypeChecking.Polarity.LeastPolarity m) instance GHC.Base.Monad m => GHC.Base.Monoid (Agda.TypeChecking.Polarity.LeastPolarity m) module Agda.TypeChecking.SizedTypes -- | Check whether a type is either not a SIZELT or a SIZELT that is -- non-empty. checkSizeLtSat :: Term -> TCM () -- | Precondition: Term is reduced and not blocked. Throws a -- patternViolation if undecided checkSizeNeverZero :: Term -> TCM Bool -- | Checks that a size variable is ensured to be > 0. E.g. -- variable i cannot be zero in context (i : Size) (j : -- Size< ↑ ↑ i) (k : Size< j) (k' : Size< k). Throws a -- patternViolation if undecided. checkSizeVarNeverZero :: Int -> TCM Bool -- | Check whether a variable in the context is bounded by a size -- expression. If x : Size< a, then a is returned. isBounded :: PureTCM m => Nat -> m BoundedSize isBoundedProjVar :: (MonadCheckInternal m, PureTCM m) => ProjectedVar -> m BoundedSize isBoundedSizeType :: PureTCM m => Type -> m BoundedSize -- | Whenever we create a bounded size meta, add a constraint expressing -- the bound. First argument is the new meta and must be a -- MetaV{}. In boundedSizeMetaHook v tel a, -- tel includes the current context. boundedSizeMetaHook :: (MonadConstraint m, MonadTCEnv m, ReadTCState m, MonadAddContext m, HasOptions m, HasBuiltins m) => Term -> Telescope -> Type -> m () -- | trySizeUniv cmp t m n x els1 y els2 is called as a last -- resort when conversion checking m cmp n : t failed -- for definitions m = x els1 and n = y els2, where the -- heads x and y are not equal. -- -- trySizeUniv accounts for subtyping between SIZELT and SIZE, -- like Size< i =< Size. -- -- If it does not succeed it reports failure of conversion check. trySizeUniv :: MonadConversion m => Comparison -> CompareAs -> Term -> Term -> QName -> Elims -> QName -> Elims -> m () -- | Compute the deep size view of a term. Precondition: sized types are -- enabled. deepSizeView :: (PureTCM m, MonadTCError m) => Term -> m DeepSizeView sizeMaxView :: PureTCM m => Term -> m SizeMaxView -- | Compare two sizes. compareSizes :: MonadConversion m => Comparison -> Term -> Term -> m () -- | Compare two sizes in max view. compareMaxViews :: MonadConversion m => Comparison -> SizeMaxView -> SizeMaxView -> m () -- | compareBelowMax u vs checks u <= max vs. -- Precondition: size vs >= 2 compareBelowMax :: MonadConversion m => DeepSizeView -> SizeMaxView -> m () compareSizeViews :: MonadConversion m => Comparison -> DeepSizeView -> DeepSizeView -> m () -- | If envAssignMetas then postpone as constraint, otherwise, fail -- hard. Failing is required if we speculatively test several -- alternatives. giveUp :: MonadConversion m => Comparison -> Type -> Term -> Term -> m () -- | Checked whether a size constraint is trivial (like X <= -- X+1). trivial :: MonadConversion m => Term -> Term -> m Bool -- | Test whether a problem consists only of size constraints. isSizeProblem :: (ReadTCState m, HasOptions m, HasBuiltins m) => ProblemId -> m Bool -- | Test whether a constraint speaks about sizes. isSizeConstraint :: (HasOptions m, HasBuiltins m) => (Comparison -> Bool) -> Closure Constraint -> m Bool mkIsSizeConstraint :: (Term -> Maybe BoundedSize) -> (Comparison -> Bool) -> Closure Constraint -> Bool isSizeConstraint_ :: (Type -> Bool) -> (Comparison -> Bool) -> Closure Constraint -> Bool -- | Take out all size constraints of the given direction (DANGER!). takeSizeConstraints :: (Comparison -> Bool) -> TCM [ProblemConstraint] -- | Find the size constraints of the matching direction. getSizeConstraints :: (Comparison -> Bool) -> TCM [ProblemConstraint] -- | Return a list of size metas and their context. getSizeMetas :: Bool -> TCM [(MetaId, Type, Telescope)] -- | Atomic size expressions. data OldSizeExpr -- | A size meta applied to de Bruijn indices. SizeMeta :: MetaId -> [Int] -> OldSizeExpr -- | A de Bruijn index. Rigid :: Int -> OldSizeExpr -- | Size constraints we can solve. data OldSizeConstraint -- | Leq a +n b represents a =< b + n. Leq a -n -- b represents a + n =< b. Leq :: OldSizeExpr -> Int -> OldSizeExpr -> OldSizeConstraint -- | Compute a set of size constraints that all live in the same context -- from constraints over terms of type size that may live in different -- contexts. -- -- cf. simplifyLevelConstraint oldComputeSizeConstraints :: [ProblemConstraint] -> TCM [OldSizeConstraint] -- | Turn a constraint over de Bruijn indices into a size constraint. oldComputeSizeConstraint :: Constraint -> TCM (Maybe OldSizeConstraint) -- | Turn a term with de Bruijn indices into a size expression with offset. -- -- Throws a patternViolation if the term isn't a proper size -- expression. oldSizeExpr :: (PureTCM m, MonadBlock m) => Term -> m (OldSizeExpr, Int) -- | Compute list of size metavariables with their arguments appearing in a -- constraint. flexibleVariables :: OldSizeConstraint -> [(MetaId, [Int])] -- | Convert size constraint into form where each meta is applied to -- indices 0,1,..,n-1 where n is the arity of that -- meta. -- -- X[σ] <= t becomes X[id] <= t[σ^-1] -- -- X[σ] ≤ Y[τ] becomes X[id] ≤ Y[τ[σ^-1]] or -- X[σ[τ^1]] ≤ Y[id] whichever is defined. If none is defined, -- we give up. oldCanonicalizeSizeConstraint :: OldSizeConstraint -> Maybe OldSizeConstraint instance GHC.Show.Show Agda.TypeChecking.SizedTypes.OldSizeExpr instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.OldSizeExpr instance GHC.Show.Show Agda.TypeChecking.SizedTypes.OldSizeConstraint instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.OldSizeConstraint instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.OldSizeExpr module Agda.TypeChecking.MetaVars -- | Find position of a value in a list. Used to change metavar argument -- indices during assignment. -- -- reverse is necessary because we are directly abstracting over -- the list. findIdx :: Eq a => [a] -> a -> Maybe Int -- | Does the given local meta-variable have a twin meta-variable? hasTwinMeta :: MetaId -> TCM Bool -- | Check whether a meta variable is a place holder for a blocked term. isBlockedTerm :: MetaId -> TCM Bool isEtaExpandable :: [MetaKind] -> MetaId -> TCM Bool -- | Performing the meta variable assignment. -- -- The instantiation should not be an InstV and the MetaId -- should point to something Open or a BlockedConst. -- Further, the meta variable may not be Frozen. assignTerm :: MonadMetaSolver m => MetaId -> [Arg ArgName] -> Term -> m () -- | Skip frozen check. Used for eta expanding frozen metas. assignTermTCM' :: MetaId -> [Arg ArgName] -> Term -> TCM () -- | Create a sort meta that cannot be instantiated with Inf (Setω). newSortMetaBelowInf :: TCM Sort -- | Create a sort meta that may be instantiated with Inf (Setω). newSortMeta :: MonadMetaSolver m => m Sort -- | Create a sort meta that may be instantiated with Inf (Setω). newSortMetaCtx :: MonadMetaSolver m => Args -> m Sort newTypeMeta' :: Comparison -> Sort -> TCM Type newTypeMeta :: Sort -> TCM Type newTypeMeta_ :: TCM Type newLevelMeta :: MonadMetaSolver m => m Level -- | newInstanceMeta s t cands creates a new instance metavariable -- of type the output type of t with name suggestion s. newInstanceMeta :: MonadMetaSolver m => MetaNameSuggestion -> Type -> m (MetaId, Term) newInstanceMetaCtx :: MonadMetaSolver m => MetaNameSuggestion -> Type -> Args -> m (MetaId, Term) -- | Create a new value meta with specific dependencies, possibly -- η-expanding in the process. newNamedValueMeta :: MonadMetaSolver m => RunMetaOccursCheck -> MetaNameSuggestion -> Comparison -> Type -> m (MetaId, Term) -- | Create a new value meta with specific dependencies without -- η-expanding. newNamedValueMeta' :: MonadMetaSolver m => RunMetaOccursCheck -> MetaNameSuggestion -> Comparison -> Type -> m (MetaId, Term) -- | Create a new metavariable, possibly η-expanding in the process. newValueMeta :: MonadMetaSolver m => RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term) newValueMetaCtx :: MonadMetaSolver m => Frozen -> RunMetaOccursCheck -> Comparison -> Type -> Telescope -> Permutation -> Args -> m (MetaId, Term) -- | Create a new value meta without η-expanding. newValueMeta' :: MonadMetaSolver m => RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term) newValueMetaCtx' :: MonadMetaSolver m => Frozen -> RunMetaOccursCheck -> Comparison -> Type -> Telescope -> Permutation -> Args -> m (MetaId, Term) newTelMeta :: MonadMetaSolver m => Telescope -> m Args type Condition = Dom Type -> Abs Type -> Bool trueCondition :: Condition newArgsMeta :: MonadMetaSolver m => Type -> m Args newArgsMeta' :: MonadMetaSolver m => Condition -> Type -> m Args newArgsMetaCtx :: Type -> Telescope -> Permutation -> Args -> TCM Args newArgsMetaCtx' :: MonadMetaSolver m => Frozen -> Condition -> Type -> Telescope -> Permutation -> Args -> m Args -- | Create a metavariable of record type. This is actually one -- metavariable for each field. newRecordMeta :: QName -> Args -> TCM Term newRecordMetaCtx :: Frozen -> QName -> Args -> Telescope -> Permutation -> Args -> TCM Term newQuestionMark :: InteractionId -> Comparison -> Type -> TCM (MetaId, Term) newQuestionMark' :: (Comparison -> Type -> TCM (MetaId, Term)) -> InteractionId -> Comparison -> Type -> TCM (MetaId, Term) -- | Construct a blocked constant if there are constraints. blockTerm :: (MonadMetaSolver m, MonadConstraint m, MonadFresh Nat m, MonadFresh ProblemId m) => Type -> m Term -> m Term blockTermOnProblem :: (MonadMetaSolver m, MonadFresh Nat m) => Type -> Term -> ProblemId -> m Term blockTypeOnProblem :: (MonadMetaSolver m, MonadFresh Nat m) => Type -> ProblemId -> m Type -- | unblockedTester t returns a Blocker for t. -- -- Auxiliary function used when creating a postponed type checking -- problem. unblockedTester :: Type -> TCM Blocker -- | Create a postponed type checking problem e : t that waits for -- type t to unblock (become instantiated or its constraints -- resolved). postponeTypeCheckingProblem_ :: TypeCheckingProblem -> TCM Term -- | Create a postponed type checking problem e : t that waits for -- conditon unblock. A new meta is created in the current -- context that has as instantiation the postponed type checking problem. -- An UnBlock constraint is added for this meta, which links to -- this meta. postponeTypeCheckingProblem :: TypeCheckingProblem -> Blocker -> TCM Term -- | Type of the term that is produced by solving the -- TypeCheckingProblem. problemType :: TypeCheckingProblem -> Type -- | Eta-expand a local meta-variable, if it is of the specified kind. -- Don't do anything if the meta-variable is a blocked term. etaExpandMetaTCM :: [MetaKind] -> MetaId -> TCM () -- | Eta expand blocking metavariables of record type, and reduce the -- blocked thing. etaExpandBlocked :: (MonadReduce m, MonadMetaSolver m, IsMeta t, Reduce t) => Blocked t -> m (Blocked t) assignWrapper :: (MonadMetaSolver m, MonadConstraint m, MonadError TCErr m, MonadDebug m, HasOptions m) => CompareDirection -> MetaId -> Elims -> Term -> m () -> m () -- | Miller pattern unification: -- -- assign dir x vs v a solves problem x vs <=(dir) v : -- a for meta x if vs are distinct variables -- (linearity check) and v depends only on these variables and -- does not contain x itself (occurs check). -- -- This is the basic story, but we have added some features: -- --
    --
  1. Pruning.
  2. --
  3. Benign cases of non-linearity.
  4. --
  5. vs may contain record patterns.
  6. --
-- -- For a reference to some of these extensions, read Andreas Abel and -- Brigitte Pientka's TLCA 2011 paper. assign :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> TCM () -- | assignMeta m x t ids u solves x ids = u for meta -- x of type t, where term u lives in a -- context of length m. Precondition: ids is linear. assignMeta :: Int -> MetaId -> Type -> [Int] -> Term -> TCM () -- | assignMeta' m x t ids u solves x = [ids]u for meta -- x of type t, where term u lives in a -- context of length m, and ids is a partial -- substitution. assignMeta' :: Int -> MetaId -> Type -> Int -> SubstCand -> Term -> TCM () -- | Check that the instantiation of the given metavariable fits the type -- of the metavariable. If the metavariable is not yet instantiated, add -- a constraint to check the instantiation later. checkMetaInst :: MetaId -> TCM () -- | Check that the instantiation of the metavariable with the given term -- is well-typed. checkSolutionForMeta :: MetaId -> MetaVariable -> Term -> Type -> TCM () -- | Given two types a and b with a <: b, -- check that a == b. checkSubtypeIsEqual :: Type -> Type -> TCM () -- | Turn the assignment problem _X args <= SizeLt u into -- _X args = SizeLt (_Y args) and constraint _Y args <= -- u. subtypingForSizeLt :: CompareDirection -> MetaId -> MetaVariable -> Type -> Args -> Term -> (Term -> TCM ()) -> TCM () -- | Eta-expand bound variables like z in X (fst z). expandProjectedVars :: (Pretty a, PrettyTCM a, NoProjectedVar a, ReduceAndEtaContract a, PrettyTCM b, TermSubst b) => a -> b -> (a -> b -> TCM c) -> TCM c -- | Eta-expand a de Bruijn index of record type in context and passed -- term(s). etaExpandProjectedVar :: (PrettyTCM a, TermSubst a) => Int -> a -> TCM c -> (a -> TCM c) -> TCM c -- | Check whether one of the meta args is a projected var. class NoProjectedVar a noProjectedVar :: NoProjectedVar a => a -> Either ProjectedVar () noProjectedVar :: (NoProjectedVar a, NoProjectedVar b, Foldable t, t b ~ a) => a -> Either ProjectedVar () -- | Normalize just far enough to be able to eta-contract maximally. class (TermLike a, TermSubst a, Reduce a) => ReduceAndEtaContract a reduceAndEtaContract :: ReduceAndEtaContract a => a -> TCM a reduceAndEtaContract :: (ReduceAndEtaContract a, Traversable f, TermLike b, Subst b, Reduce b, ReduceAndEtaContract b, f b ~ a) => a -> TCM a type FVs = VarSet type SubstCand = [(Int, Term)] " a possibly non-deterministic substitution" -- | Turn non-det substitution into proper substitution, if possible. -- Otherwise, raise the error. checkLinearity :: SubstCand -> ExceptT () TCM SubstCand type Res = [(Arg Nat, Term)] -- | Exceptions raised when substitution cannot be inverted. data InvertExcept -- | Cannot recover. CantInvert :: InvertExcept -- | A potentially neutral arg: can't invert, but can try pruning. NeutralArg :: InvertExcept -- | Try to eta-expand var to remove projs. ProjVar :: ProjectedVar -> InvertExcept -- | Check that arguments args to a metavar are in pattern -- fragment. Assumes all arguments already in whnf and eta-reduced. -- Parameters are represented as Vars so checkArgs -- really checks that all args are Vars and returns the -- "substitution" to be applied to the rhs of the equation to solve. (If -- args is considered a substitution, its inverse is returned.) -- -- The returned list might not be ordered. Linearity, i.e., whether the -- substitution is deterministic, has to be checked separately. inverseSubst :: Args -> ExceptT InvertExcept TCM SubstCand -- | Turn open metas into postulates. -- -- Preconditions: -- --
    --
  1. We are inTopContext.
  2. --
  3. envCurrentModule is set to the top-level module.
  4. --
openMetasToPostulates :: TCM () -- | Sort metas in dependency order. dependencySortMetas :: [MetaId] -> TCM (Maybe [MetaId]) instance Agda.TypeChecking.MetaVars.ReduceAndEtaContract a => Agda.TypeChecking.MetaVars.ReduceAndEtaContract [a] instance Agda.TypeChecking.MetaVars.ReduceAndEtaContract a => Agda.TypeChecking.MetaVars.ReduceAndEtaContract (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.MetaVars.ReduceAndEtaContract Agda.Syntax.Internal.Term instance Agda.TypeChecking.MetaVars.NoProjectedVar a => Agda.TypeChecking.MetaVars.NoProjectedVar (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.MetaVars.NoProjectedVar a => Agda.TypeChecking.MetaVars.NoProjectedVar [a] instance Agda.TypeChecking.MetaVars.NoProjectedVar Agda.Syntax.Internal.Term instance Agda.TypeChecking.Monad.MetaVars.MonadMetaSolver Agda.TypeChecking.Monad.Base.TCM -- | A syntactic equality check that takes meta instantiations into -- account, but does not reduce. It replaces (v, v') <- -- instantiateFull (v, v') v == v' by a more efficient routine -- which only traverses and instantiates the terms as long as they are -- equal. module Agda.TypeChecking.SyntacticEquality -- | Instantiate full as long as things are equal class SynEq a -- | Syntactic equality check for terms. If syntactic equality checking has -- fuel left, then checkSyntacticEquality behaves as if it were -- implemented in the following way (which does not match the given type -- signature), only that v and v' are only fully -- instantiated to the depth where they are equal (and the amount of fuel -- is reduced by one unit in the failure branch): -- checkSyntacticEquality v v' s f = do (v, v') <- instantiateFull (v, -- v') if v == v' then s v v' else f v v' If syntactic equality -- checking does not have fuel left, then checkSyntacticEquality -- instantiates the two terms and takes the failure branch. -- -- Note that in either case the returned values v and -- v' cannot be MetaVs that are instantiated. checkSyntacticEquality :: (Instantiate a, SynEq a, MonadReduce m) => a -> a -> (a -> a -> m b) -> (a -> a -> m b) -> m b -- | Syntactic equality check for terms without checking remaining fuel. checkSyntacticEquality' :: (Instantiate a, SynEq a, MonadReduce m) => a -> a -> (a -> a -> m b) -> (a -> a -> m b) -> m b -- | Does the syntactic equality check have any remaining fuel? syntacticEqualityFuelRemains :: MonadReduce m => m Bool instance Agda.TypeChecking.SyntacticEquality.SynEq GHC.Types.Bool instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Internal.Term instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Internal.Level instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Internal.Sort instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Internal.Type instance Agda.TypeChecking.SyntacticEquality.SynEq a => Agda.TypeChecking.SyntacticEquality.SynEq [a] instance (Agda.TypeChecking.SyntacticEquality.SynEq a, Agda.TypeChecking.SyntacticEquality.SynEq b) => Agda.TypeChecking.SyntacticEquality.SynEq (a, b) instance Agda.TypeChecking.SyntacticEquality.SynEq a => Agda.TypeChecking.SyntacticEquality.SynEq (Agda.Syntax.Internal.Elim.Elim' a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.SyntacticEquality.SynEq a) => Agda.TypeChecking.SyntacticEquality.SynEq (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.SyntacticEquality.SynEq a => Agda.TypeChecking.SyntacticEquality.SynEq (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.SyntacticEquality.SynEq a => Agda.TypeChecking.SyntacticEquality.SynEq (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Common.ArgInfo -- | This module contains the rules for Agda's sort system viewed as a pure -- type system (pts). The specification of a pts consists of a set of -- axioms of the form s1 : s2 specifying when a sort fits in -- another sort, and a set of rules of the form (s1,s2,s3) -- specifying that a pi type with domain in s1 and codomain in -- s2 itself fits into sort s3. -- -- To ensure unique principal types, the axioms and rules of Agda's pts -- are given by two partial functions univSort' and -- piSort' (see Agda.TypeChecking.Substitute). If these -- functions return Nothing, a constraint is added to ensure -- that the sort will be computed eventually. -- -- One upgrade over the standard definition of a pts is that in -- a rule (s1,s2,s3), in Agda the sort s2 can depend on -- a variable of some type in s1. This is needed to support -- Agda's universe polymorphism where we can have e.g. a function of type -- ∀ {ℓ} → Set ℓ. module Agda.TypeChecking.Sort -- | Infer the sort of another sort. If we can compute the bigger sort -- straight away, return that. Otherwise, return UnivSort s and -- add a constraint to ensure we can compute the sort eventually. inferUnivSort :: (PureTCM m, MonadConstraint m) => Sort -> m Sort sortFitsIn :: MonadConversion m => Sort -> Sort -> m () hasBiggerSort :: Sort -> TCM () -- | Infer the sort of a pi type. If we can compute the sort straight away, -- return that. Otherwise, return PiSort a s2 and add a -- constraint to ensure we can compute the sort eventually. inferPiSort :: PureTCM m => Dom Type -> Abs Sort -> m Sort -- | As inferPiSort, but for a nondependent function type. inferFunSort :: Sort -> Sort -> TCM Sort ptsRule :: Dom Type -> Abs Sort -> Sort -> TCM () -- | Non-dependent version of ptsRule ptsRule' :: Sort -> Sort -> Sort -> TCM () hasPTSRule :: Dom Type -> Abs Sort -> TCM () -- | Recursively check that an iterated function type constructed by -- telePi is well-sorted. checkTelePiSort :: Type -> TCM () ifIsSort :: (MonadReduce m, MonadBlock m) => Type -> (Sort -> m a) -> m a -> m a ifNotSort :: (MonadReduce m, MonadBlock m) => Type -> m a -> (Sort -> m a) -> m a -- | Result is in reduced form. shouldBeSort :: (PureTCM m, MonadBlock m, MonadError TCErr m) => Type -> m Sort -- | Reconstruct the sort of a term. -- -- Precondition: given term is a well-sorted type. sortOf :: forall m. (PureTCM m, MonadBlock m) => Term -> m Sort -- | Reconstruct the minimal sort of a type (ignoring the sort annotation). sortOfType :: forall m. (PureTCM m, MonadBlock m) => Type -> m Sort module Agda.TypeChecking.Conversion type MonadConversion m = (PureTCM m, MonadConstraint m, MonadMetaSolver m, MonadError TCErr m, MonadWarning m, MonadStatistics m, MonadFresh ProblemId m, MonadFresh Int m, MonadFail m) -- | Try whether a computation runs without errors or new constraints (may -- create new metas, though). Restores state upon failure. tryConversion :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) => m () -> m Bool -- | Try whether a computation runs without errors or new constraints (may -- create new metas, though). Return Just the result upon success. -- Return Nothing and restore state upon failure. tryConversion' :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) => m a -> m (Maybe a) -- | Check if to lists of arguments are the same (and all variables). -- Precondition: the lists have the same length. sameVars :: Elims -> Elims -> Bool -- | intersectVars us vs checks whether all relevant elements in -- us and vs are variables, and if yes, returns a prune -- list which says True for arguments which are different and -- can be pruned. intersectVars :: Elims -> Elims -> Maybe [Bool] -- | Run the given computation but turn any errors into blocked -- computations with the given blocker blockOnError :: MonadError TCErr m => Blocker -> m a -> m a equalTerm :: MonadConversion m => Type -> Term -> Term -> m () equalAtom :: MonadConversion m => CompareAs -> Term -> Term -> m () equalType :: MonadConversion m => Type -> Type -> m () -- | Ignore errors in irrelevant context. convError :: TypeError -> TCM () -- | Type directed equality on values. compareTerm :: forall m. MonadConversion m => Comparison -> Type -> Term -> Term -> m () -- | Type directed equality on terms or types. compareAs :: forall m. MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () -- | Try to assign meta. If meta is projected, try to eta-expand and run -- conversion check again. assignE :: MonadConversion m => CompareDirection -> MetaId -> Elims -> Term -> CompareAs -> (Term -> Term -> m ()) -> m () compareAsDir :: MonadConversion m => CompareDirection -> CompareAs -> Term -> Term -> m () compareAs' :: forall m. MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () compareTerm' :: forall m. MonadConversion m => Comparison -> Type -> Term -> Term -> m () compareAtomDir :: MonadConversion m => CompareDirection -> CompareAs -> Term -> Term -> m () -- | Compute the head type of an elimination. For projection-like functions -- this requires inferring the type of the principal argument. computeElimHeadType :: MonadConversion m => QName -> Elims -> Elims -> m Type -- | Syntax directed equality on atomic values compareAtom :: forall m. MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () -- | Check whether x xArgs cmp y yArgs compareMetas :: MonadConversion m => Comparison -> CompareAs -> MetaId -> Elims -> MetaId -> Elims -> m () -- | Check whether a1 cmp a2 and continue in context -- extended by a1. compareDom :: (MonadConversion m, Free c) => Comparison -> Dom Type -> Dom Type -> Abs b -> Abs c -> m () -> m () -> m () -> m () -> m () -> m () -> m () -- | When comparing argument spines (in compareElims) where the first -- arguments don't match, we keep going, substituting the -- anti-unification of the two terms in the telescope. More precisely: -- -- @ (u = v : A)[pid] w = antiUnify pid A u v us = vs : Δ[w/x] -- ------------------------------------------------------------- u us = v -- vs : (x : A) Δ @ -- -- The simplest case of anti-unification is to return a fresh -- metavariable (created by blockTermOnProblem), but if there's shared -- structure between the two terms we can expose that. -- -- This is really a crutch that lets us get away with things that -- otherwise would require heterogenous conversion checking. See for -- instance issue #2384. antiUnify :: MonadConversion m => ProblemId -> Type -> Term -> Term -> m Term antiUnifyArgs :: MonadConversion m => ProblemId -> Dom Type -> Arg Term -> Arg Term -> m (Arg Term) antiUnifyType :: MonadConversion m => ProblemId -> Type -> Type -> m Type antiUnifyElims :: MonadConversion m => ProblemId -> Type -> Term -> Elims -> Elims -> m Term -- | compareElims pols a v els1 els2 performs type-directed -- equality on eliminator spines. t is the type of the head -- v. compareElims :: forall m. MonadConversion m => [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> m () -- | Compare two terms in irrelevant position. This always succeeds. -- However, we can dig for solutions of irrelevant metas in the terms we -- compare. (Certainly not the systematic solution, that'd be proof -- search...) compareIrrelevant :: MonadConversion m => Type -> Term -> Term -> m () compareWithPol :: MonadConversion m => Polarity -> (Comparison -> a -> a -> m ()) -> a -> a -> m () polFromCmp :: Comparison -> Polarity -- | Type-directed equality on argument lists compareArgs :: MonadConversion m => [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> m () -- | Equality on Types compareType :: MonadConversion m => Comparison -> Type -> Type -> m () leqType :: MonadConversion m => Type -> Type -> m () -- | coerce v a b coerces v : a to type b, -- returning a v' : b with maybe extra hidden applications or -- hidden abstractions. -- -- In principle, this function can host coercive subtyping, but currently -- it only tries to fix problems with hidden function types. coerce :: (MonadConversion m, MonadTCM m) => Comparison -> Term -> Type -> Type -> m Term -- | Account for situations like k : (Size< j) <= (Size< k + -- 1) -- -- Actually, the semantics is (Size<= k) ∩ (Size< j) ⊆ rhs -- which gives a disjunctive constraint. Mmmh, looks like stuff TODO. -- -- For now, we do a cheap heuristics. coerceSize :: MonadConversion m => (Type -> Type -> m ()) -> Term -> Type -> Type -> m () compareLevel :: MonadConversion m => Comparison -> Level -> Level -> m () compareSort :: MonadConversion m => Comparison -> Sort -> Sort -> m () -- | Check that the first sort is less or equal to the second. -- -- We can put SizeUniv below Inf, but otherwise, it is -- unrelated to the other universes. leqSort :: forall m. MonadConversion m => Sort -> Sort -> m () leqLevel :: MonadConversion m => Level -> Level -> m () equalLevel :: forall m. MonadConversion m => Level -> Level -> m () -- | Check that the first sort equal to the second. equalSort :: forall m. MonadConversion m => Sort -> Sort -> m () forallFaceMaps :: MonadConversion m => Term -> (IntMap Bool -> Blocker -> Term -> m a) -> (IntMap Bool -> Substitution -> m a) -> m [a] compareInterval :: MonadConversion m => Comparison -> Type -> Term -> Term -> m () type Conj = (IntMap BoolSet, [Term]) isCanonical :: [Conj] -> Bool -- | leqInterval r q = r ≤ q in the I lattice. (∨ r_i) ≤ (∨ q_j) iff ∀ i. ∃ -- j. r_i ≤ q_j leqInterval :: MonadConversion m => [Conj] -> [Conj] -> m Bool -- | leqConj r q = r ≤ q in the I lattice, when r and q are conjuctions. ' -- (∧ r_i) ≤ (∧ q_j) iff ' (∧ r_i) ∧ (∧ q_j) = (∧ r_i) iff ' {r_i | i} ∪ -- {q_j | j} = {r_i | i} iff ' {q_j | j} ⊆ {r_i | i} leqConj :: MonadConversion m => Conj -> Conj -> m Bool -- | equalTermOnFace φ A u v = _ , φ ⊢ u = v : A equalTermOnFace :: MonadConversion m => Term -> Type -> Term -> Term -> m () compareTermOnFace :: MonadConversion m => Comparison -> Term -> Type -> Term -> Term -> m () compareTermOnFace' :: MonadConversion m => (Substitution -> Comparison -> Type -> Term -> Term -> m ()) -> Comparison -> Term -> Type -> Term -> Term -> m () bothAbsurd :: MonadConversion m => QName -> QName -> m Bool -- | Primitive functions, such as addition on builtin integers. module Agda.TypeChecking.Primitive primitiveFunctions :: Map String (TCM PrimitiveImpl) type Pred a = a -> Bool type Rel a = a -> a -> Bool type Fun a = a -> a type Op a = a -> a -> a class FromTerm a fromTerm :: FromTerm a => TCM (FromTermFunction a) type FromTermFunction a = Arg Term -> ReduceM (Reduced (MaybeReduced (Arg Term)) a) class ToTerm a toTerm :: ToTerm a => TCM (a -> Term) toTermR :: ToTerm a => TCM (a -> ReduceM Term) class PrimType a => PrimTerm a primTerm :: PrimTerm a => a -> TCM Term class PrimType a primType :: PrimType a => a -> TCM Type primType :: (PrimType a, PrimTerm a) => a -> TCM Type newtype Lvl Lvl :: Integer -> Lvl [unLvl] :: Lvl -> Integer newtype Nat Nat :: Integer -> Nat [unNat] :: Nat -> Integer -- | buildList A ts builds a list of type List A. Assumes -- that the terms ts all have type A. buildList :: TCM ([Term] -> Term) fromReducedTerm :: (Term -> Maybe a) -> TCM (FromTermFunction a) fromLiteral :: (Literal -> Maybe a) -> TCM (FromTermFunction a) -- | mkPrimInjective takes two Set0 a and b and -- a function f of type a -> b and outputs a -- primitive internalizing the fact that f is injective. mkPrimInjective :: Type -> Type -> QName -> TCM PrimitiveImpl -- | Converts MetaIds to natural numbers. metaToNat :: MetaId -> Nat primMetaToNatInjective :: TCM PrimitiveImpl primCharToNatInjective :: TCM PrimitiveImpl primStringToListInjective :: TCM PrimitiveImpl primStringFromListInjective :: TCM PrimitiveImpl primWord64ToNatInjective :: TCM PrimitiveImpl primFloatToWord64Injective :: TCM PrimitiveImpl primQNameToWord64sInjective :: TCM PrimitiveImpl getRefl :: TCM (Arg Term -> Term) -- |
--   primEraseEquality : {a : Level} {A : Set a} {x y : A} -> x ≡ y -> x ≡ y
--   
primEraseEquality :: TCM PrimitiveImpl -- | Get the ArgInfo of the principal argument of BUILTIN REFL. -- -- Returns Nothing for e.g. data Eq {a} {A : Set a} (x : A) -- : A → Set a where refl : Eq x x -- -- Returns Just ... for e.g. data Eq {a} {A : Set a} : (x y -- : A) → Set a where refl : ∀ x → Eq x x getReflArgInfo :: ConHead -> TCM (Maybe ArgInfo) -- | Used for both primForce and primForceLemma. genPrimForce :: TCM Type -> (Term -> Arg Term -> Term) -> TCM PrimitiveImpl primForce :: TCM PrimitiveImpl primForceLemma :: TCM PrimitiveImpl mkPrimLevelZero :: TCM PrimitiveImpl mkPrimLevelSuc :: TCM PrimitiveImpl mkPrimLevelMax :: TCM PrimitiveImpl mkPrimSetOmega :: IsFibrant -> TCM PrimitiveImpl primLockUniv' :: TCM PrimitiveImpl mkPrimFun1TCM :: (FromTerm a, ToTerm b) => TCM Type -> (a -> ReduceM b) -> TCM PrimitiveImpl mkPrimFun1 :: (PrimType a, FromTerm a, PrimType b, ToTerm b) => (a -> b) -> TCM PrimitiveImpl mkPrimFun2 :: (PrimType a, FromTerm a, ToTerm a, PrimType b, FromTerm b, PrimType c, ToTerm c) => (a -> b -> c) -> TCM PrimitiveImpl mkPrimFun3 :: (PrimType a, FromTerm a, ToTerm a, PrimType b, FromTerm b, ToTerm b, PrimType c, FromTerm c, PrimType d, ToTerm d) => (a -> b -> c -> d) -> TCM PrimitiveImpl mkPrimFun4 :: (PrimType a, FromTerm a, ToTerm a, PrimType b, FromTerm b, ToTerm b, PrimType c, FromTerm c, ToTerm c, PrimType d, FromTerm d, PrimType e, ToTerm e) => (a -> b -> c -> d -> e) -> TCM PrimitiveImpl instance GHC.Real.Real Agda.TypeChecking.Primitive.Nat instance GHC.Enum.Enum Agda.TypeChecking.Primitive.Nat instance GHC.Num.Num Agda.TypeChecking.Primitive.Nat instance GHC.Classes.Ord Agda.TypeChecking.Primitive.Nat instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Nat instance GHC.Classes.Ord Agda.TypeChecking.Primitive.Lvl instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Lvl instance Agda.TypeChecking.Primitive.FromTerm GHC.Num.Integer.Integer instance Agda.TypeChecking.Primitive.FromTerm Agda.TypeChecking.Primitive.Nat instance Agda.TypeChecking.Primitive.FromTerm GHC.Word.Word64 instance Agda.TypeChecking.Primitive.FromTerm Agda.TypeChecking.Primitive.Lvl instance Agda.TypeChecking.Primitive.FromTerm GHC.Types.Double instance Agda.TypeChecking.Primitive.FromTerm GHC.Types.Char instance Agda.TypeChecking.Primitive.FromTerm Data.Text.Internal.Text instance Agda.TypeChecking.Primitive.FromTerm Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Primitive.FromTerm Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Primitive.FromTerm GHC.Types.Bool instance (Agda.TypeChecking.Primitive.ToTerm a, Agda.TypeChecking.Primitive.FromTerm a) => Agda.TypeChecking.Primitive.FromTerm [a] instance Agda.TypeChecking.Primitive.FromTerm a => Agda.TypeChecking.Primitive.FromTerm (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Primitive.ToTerm Agda.TypeChecking.Primitive.Nat instance Agda.TypeChecking.Primitive.ToTerm GHC.Word.Word64 instance Agda.TypeChecking.Primitive.ToTerm Agda.TypeChecking.Primitive.Lvl instance Agda.TypeChecking.Primitive.ToTerm GHC.Types.Double instance Agda.TypeChecking.Primitive.ToTerm GHC.Types.Char instance Agda.TypeChecking.Primitive.ToTerm Data.Text.Internal.Text instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Primitive.ToTerm GHC.Num.Integer.Integer instance Agda.TypeChecking.Primitive.ToTerm GHC.Types.Bool instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Internal.Term instance Agda.TypeChecking.Primitive.ToTerm (Agda.Syntax.Internal.Dom Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Internal.Type instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.ArgInfo instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.Fixity' instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.Fixity instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.Associativity instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.FixityLevel instance (Agda.TypeChecking.Primitive.ToTerm a, Agda.TypeChecking.Primitive.ToTerm b) => Agda.TypeChecking.Primitive.ToTerm (a, b) instance Agda.TypeChecking.Primitive.ToTerm a => Agda.TypeChecking.Primitive.ToTerm [a] instance Agda.TypeChecking.Primitive.ToTerm a => Agda.TypeChecking.Primitive.ToTerm (GHC.Maybe.Maybe a) instance (Agda.TypeChecking.Primitive.PrimType a, Agda.TypeChecking.Primitive.PrimType b) => Agda.TypeChecking.Primitive.PrimType (a -> b) instance (Agda.TypeChecking.Primitive.PrimType a, Agda.TypeChecking.Primitive.PrimType b) => Agda.TypeChecking.Primitive.PrimTerm (a -> b) instance (Agda.TypeChecking.Primitive.PrimType a, Agda.TypeChecking.Primitive.PrimType b) => Agda.TypeChecking.Primitive.PrimType (a, b) instance (Agda.TypeChecking.Primitive.PrimType a, Agda.TypeChecking.Primitive.PrimType b) => Agda.TypeChecking.Primitive.PrimTerm (a, b) instance Agda.TypeChecking.Primitive.PrimType GHC.Num.Integer.Integer instance Agda.TypeChecking.Primitive.PrimTerm GHC.Num.Integer.Integer instance Agda.TypeChecking.Primitive.PrimType GHC.Word.Word64 instance Agda.TypeChecking.Primitive.PrimTerm GHC.Word.Word64 instance Agda.TypeChecking.Primitive.PrimType GHC.Types.Bool instance Agda.TypeChecking.Primitive.PrimTerm GHC.Types.Bool instance Agda.TypeChecking.Primitive.PrimType GHC.Types.Char instance Agda.TypeChecking.Primitive.PrimTerm GHC.Types.Char instance Agda.TypeChecking.Primitive.PrimType GHC.Types.Double instance Agda.TypeChecking.Primitive.PrimTerm GHC.Types.Double instance Agda.TypeChecking.Primitive.PrimType Data.Text.Internal.Text instance Agda.TypeChecking.Primitive.PrimTerm Data.Text.Internal.Text instance Agda.TypeChecking.Primitive.PrimType Agda.TypeChecking.Primitive.Nat instance Agda.TypeChecking.Primitive.PrimTerm Agda.TypeChecking.Primitive.Nat instance Agda.TypeChecking.Primitive.PrimType Agda.TypeChecking.Primitive.Lvl instance Agda.TypeChecking.Primitive.PrimTerm Agda.TypeChecking.Primitive.Lvl instance Agda.TypeChecking.Primitive.PrimType Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Primitive.PrimType Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Primitive.PrimType Agda.Syntax.Internal.Type instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Internal.Type instance Agda.TypeChecking.Primitive.PrimType Agda.Syntax.Common.Fixity' instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Common.Fixity' instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimType [a] instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimTerm [a] instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimType (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimTerm (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimType (GHC.Types.IO a) instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimTerm (GHC.Types.IO a) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Primitive.Lvl instance GHC.Real.Integral Agda.TypeChecking.Primitive.Nat instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Primitive.Nat instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Primitive.Nat module Agda.TypeChecking.Quote -- | Parse quote. quotedName :: (MonadTCError m, MonadAbsToCon m) => Expr -> m QName data QuotingKit QuotingKit :: (Term -> ReduceM Term) -> (Type -> ReduceM Term) -> (Dom Type -> ReduceM Term) -> (Definition -> ReduceM Term) -> (forall a. (a -> ReduceM Term) -> [a] -> ReduceM Term) -> QuotingKit [quoteTermWithKit] :: QuotingKit -> Term -> ReduceM Term [quoteTypeWithKit] :: QuotingKit -> Type -> ReduceM Term [quoteDomWithKit] :: QuotingKit -> Dom Type -> ReduceM Term [quoteDefnWithKit] :: QuotingKit -> Definition -> ReduceM Term [quoteListWithKit] :: QuotingKit -> forall a. (a -> ReduceM Term) -> [a] -> ReduceM Term quotingKit :: TCM QuotingKit quoteString :: String -> Term quoteName :: QName -> Term quoteNat :: Integer -> Term quoteConName :: ConHead -> Term quoteMeta :: TopLevelModuleName -> MetaId -> Term quoteTerm :: Term -> TCM Term quoteType :: Type -> TCM Term quoteDom :: Dom Type -> TCM Term quoteDefn :: Definition -> TCM Term quoteList :: [Term] -> TCM Term module Agda.TypeChecking.Primitive.Base (-->) :: Applicative m => m Type -> m Type -> m Type infixr 4 --> (.-->) :: Applicative m => m Type -> m Type -> m Type infixr 4 .--> (..-->) :: Applicative m => m Type -> m Type -> m Type infixr 4 ..--> garr :: Applicative m => (Relevance -> Relevance) -> m Type -> m Type -> m Type gpi :: (MonadAddContext m, MonadDebug m) => ArgInfo -> String -> m Type -> m Type -> m Type hPi :: (MonadAddContext m, MonadDebug m) => String -> m Type -> m Type -> m Type nPi :: (MonadAddContext m, MonadDebug m) => String -> m Type -> m Type -> m Type hPi' :: (MonadFail m, MonadAddContext m, MonadDebug m) => String -> NamesT m Type -> (NamesT m Term -> NamesT m Type) -> NamesT m Type nPi' :: (MonadFail m, MonadAddContext m, MonadDebug m) => String -> NamesT m Type -> (NamesT m Term -> NamesT m Type) -> NamesT m Type pPi' :: (MonadAddContext m, HasBuiltins m, MonadDebug m) => String -> NamesT m Term -> (NamesT m Term -> NamesT m Type) -> NamesT m Type -- | Turn a Pi type into one whose domain is annotated finite, i.e., -- one that represents a Partial element rather than an actual -- function. toFinitePi :: Type -> Type el' :: Applicative m => m Term -> m Term -> m Type el's :: Applicative m => m Term -> m Term -> m Type elInf :: Functor m => m Term -> m Type elSSet :: Functor m => m Term -> m Type nolam :: Term -> Term varM :: Applicative m => Int -> m Term gApply :: Applicative m => Hiding -> m Term -> m Term -> m Term gApply' :: Applicative m => ArgInfo -> m Term -> m Term -> m Term (<@>) :: Applicative m => m Term -> m Term -> m Term infixl 9 <@> (<#>) :: Applicative m => m Term -> m Term -> m Term infixl 9 <#> (<..>) :: Applicative m => m Term -> m Term -> m Term (<@@>) :: Applicative m => m Term -> (m Term, m Term, m Term) -> m Term list :: TCM Term -> TCM Term tMaybe :: TCM Term -> TCM Term io :: TCM Term -> TCM Term path :: TCM Term -> TCM Term el :: Functor m => m Term -> m Type -- | The universe Set0 as a type. tset :: Applicative m => m Type -- | SizeUniv as a sort. sSizeUniv :: Sort -- | SizeUniv as a type. tSizeUniv :: Applicative m => m Type -- | Abbreviation: argN = Arg defaultArgInfo. argN :: e -> Arg e domN :: e -> Dom e -- | Abbreviation: argH = hide Arg -- defaultArgInfo. argH :: e -> Arg e domH :: e -> Dom e lookupPrimitiveFunction :: String -> TCM PrimitiveImpl lookupPrimitiveFunctionQ :: QName -> TCM (String, PrimitiveImpl) getBuiltinName :: (HasBuiltins m, MonadReduce m) => String -> m (Maybe QName) -- | Convert a name in Term form back to QName. getQNameFromTerm :: MonadReduce m => Term -> MaybeT m QName isBuiltin :: (HasBuiltins m, MonadReduce m) => QName -> String -> m Bool data SigmaKit SigmaKit :: QName -> ConHead -> QName -> QName -> SigmaKit [sigmaName] :: SigmaKit -> QName [sigmaCon] :: SigmaKit -> ConHead [sigmaFst] :: SigmaKit -> QName [sigmaSnd] :: SigmaKit -> QName getSigmaKit :: (HasBuiltins m, HasConstInfo m) => m (Maybe SigmaKit) instance GHC.Show.Show Agda.TypeChecking.Primitive.Base.SigmaKit instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Base.SigmaKit -- | EDSL to construct terms without touching De Bruijn indices. -- -- e.g. given t, u :: Term, Γ ⊢ t, u : A, we can build "λ f. f t u" like -- this: -- -- runNames [] $ do -- open binds t and u to -- computations that know how to weaken themselves in -- an extended -- context -- -- -- -- -- -- lam "f" $ f -> f @ t @ u module Agda.TypeChecking.Names newtype NamesT m a NamesT :: ReaderT Names m a -> NamesT m a [unName] :: NamesT m a -> ReaderT Names m a -- | A list of variable names from a context. type Names = [String] runNamesT :: Names -> NamesT m a -> m a runNames :: Names -> NamesT Fail a -> a currentCxt :: Monad m => NamesT m Names -- | cxtSubst Γ returns the substitution needed to go from Γ to -- the current context. -- -- Fails if Γ is not a subcontext of the current one. cxtSubst :: MonadFail m => Names -> NamesT m (Substitution' a) -- | inCxt Γ t takes a t in context Γ and -- produce an action that will return t weakened to the current -- context. -- -- Fails whenever cxtSubst Γ would. inCxt :: (MonadFail m, Subst a) => Names -> a -> NamesT m a -- | Closed terms cl' :: Applicative m => a -> NamesT m a cl :: Monad m => m a -> NamesT m a -- | Open terms in the current context. open :: (MonadFail m, Subst a) => a -> NamesT m (NamesT m a) -- | Monadic actions standing for variables. -- -- b is quantified over so the same variable can be used e.g. -- both as a pattern and as an expression. type Var m = forall b. (Subst b, DeBruijn b) => NamesT m b -- | bind n f provides f with a fresh variable, which can -- be used in any extended context. -- -- Returns an Abs which binds the extra variable. bind :: MonadFail m => ArgName -> ((forall b. (Subst b, DeBruijn b) => NamesT m b) -> NamesT m a) -> NamesT m (Abs a) -- | Like bind but returns a bare term. bind' :: MonadFail m => ArgName -> ((forall b. (Subst b, DeBruijn b) => NamesT m b) -> NamesT m a) -> NamesT m a glam :: MonadFail m => ArgInfo -> ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term lam :: MonadFail m => ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term ilam :: MonadFail m => ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term data AbsN a AbsN :: [ArgName] -> a -> AbsN a [absNName] :: AbsN a -> [ArgName] [unAbsN] :: AbsN a -> a -- | Will crash on NoAbs toAbsN :: Abs (AbsN a) -> AbsN a absAppN :: Subst a => AbsN a -> [SubstArg a] -> a type ArgVars m = (forall b. (Subst b, DeBruijn b) => [NamesT m (Arg b)]) type Vars m = (forall b. (Subst b, DeBruijn b) => [NamesT m b]) bindN :: MonadFail m => [ArgName] -> (Vars m -> NamesT m a) -> NamesT m (AbsN a) bindNArg :: MonadFail m => [Arg ArgName] -> (ArgVars m -> NamesT m a) -> NamesT m (AbsN a) glamN :: (Functor m, MonadFail m) => [Arg ArgName] -> (NamesT m Args -> NamesT m Term) -> NamesT m Term applyN :: (Monad m, Subst a) => NamesT m (AbsN a) -> [NamesT m (SubstArg a)] -> NamesT m a applyN' :: (Monad m, Subst a) => NamesT m (AbsN a) -> NamesT m [SubstArg a] -> NamesT m a abstractN :: (MonadFail m, Abstract a) => NamesT m Telescope -> (Vars m -> NamesT m a) -> NamesT m a abstractT :: (MonadFail m, Abstract a) => String -> NamesT m Type -> (Var m -> NamesT m a) -> NamesT m a lamTel :: Monad m => NamesT m (Abs [Term]) -> NamesT m [Term] appTel :: Monad m => NamesT m [Term] -> NamesT m Term -> NamesT m [Term] instance (Agda.TypeChecking.Monad.Builtin.HasBuiltins m, Agda.TypeChecking.Monad.Signature.HasConstInfo m, Agda.TypeChecking.Monad.Context.MonadAddContext m, Agda.TypeChecking.Monad.Base.MonadReduce m) => Agda.TypeChecking.Monad.Pure.PureTCM (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Agda.TypeChecking.Names.NamesT m) instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Base.MonadTCM m => Agda.TypeChecking.Monad.Base.MonadTCM (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.TypeChecking.Names.NamesT m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Agda.TypeChecking.Names.NamesT m) instance Agda.Interaction.Options.HasOptions.HasOptions m => Agda.Interaction.Options.HasOptions.HasOptions (Agda.TypeChecking.Names.NamesT m) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Agda.TypeChecking.Names.NamesT m) instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Agda.TypeChecking.Names.NamesT m) instance Control.Monad.Trans.Class.MonadTrans Agda.TypeChecking.Names.NamesT instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Agda.TypeChecking.Names.NamesT m) instance GHC.Base.Monad m => GHC.Base.Monad (Agda.TypeChecking.Names.NamesT m) instance GHC.Base.Applicative m => GHC.Base.Applicative (Agda.TypeChecking.Names.NamesT m) instance GHC.Base.Functor m => GHC.Base.Functor (Agda.TypeChecking.Names.NamesT m) instance Data.Traversable.Traversable Agda.TypeChecking.Names.AbsN instance Data.Foldable.Foldable Agda.TypeChecking.Names.AbsN instance GHC.Base.Functor Agda.TypeChecking.Names.AbsN instance Agda.TypeChecking.Substitute.Class.Subst a => Agda.TypeChecking.Substitute.Class.Subst (Agda.TypeChecking.Names.AbsN a) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.TypeChecking.Names.NamesT m) module Agda.TypeChecking.Errors prettyError :: MonadTCM tcm => TCErr -> tcm String tcErrString :: TCErr -> String prettyTCWarnings' :: [TCWarning] -> TCM [String] prettyTCWarnings :: [TCWarning] -> TCM String -- | Turns warnings, if any, into errors. tcWarningsToError :: [TCWarning] -> TCM () -- | Depending which flags are set, one may happily ignore some warnings. applyFlagsToTCWarningsPreserving :: HasOptions m => Set WarningName -> [TCWarning] -> m [TCWarning] applyFlagsToTCWarnings :: HasOptions m => [TCWarning] -> m [TCWarning] getAllUnsolvedWarnings :: (MonadFail m, ReadTCState m, MonadWarning m) => m [TCWarning] getAllWarningsPreserving :: (MonadFail m, ReadTCState m, MonadWarning m) => Set WarningName -> WhichWarnings -> m [TCWarning] -- | Collect all warnings that have accumulated in the state. getAllWarnings :: (MonadFail m, ReadTCState m, MonadWarning m) => WhichWarnings -> m [TCWarning] getAllWarningsOfTCErr :: TCErr -> TCM [TCWarning] -- | Drops the filename component of the qualified name. dropTopLevelModule :: QName -> TCM QName -- | Produces a function which drops the filename component of the -- qualified name. topLevelModuleDropper :: (MonadDebug m, MonadTCEnv m, ReadTCState m) => m (QName -> QName) stringTCErr :: String -> TCErr explainWhyInScope :: forall m. MonadPretty m => WhyInScopeData -> m Doc class Verbalize a verbalize :: Verbalize a => a -> String instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.TypeError instance Agda.TypeChecking.Errors.Verbalize a => Agda.TypeChecking.Errors.Verbalize (Agda.TypeChecking.Errors.Indefinite a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.UnificationFailure instance Agda.TypeChecking.Errors.Verbalize Agda.Syntax.Common.Hiding instance Agda.TypeChecking.Errors.Verbalize Agda.Syntax.Common.Relevance instance Agda.TypeChecking.Errors.Verbalize Agda.Syntax.Common.Quantity instance Agda.TypeChecking.Errors.Verbalize Agda.Syntax.Common.Cohesion instance Agda.TypeChecking.Errors.Verbalize Agda.Syntax.Common.Modality instance Agda.TypeChecking.Errors.PrettyUnequal Agda.Syntax.Internal.Term instance Agda.TypeChecking.Errors.PrettyUnequal Agda.Syntax.Internal.Type instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.TCErr instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.SplitError instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.NegativeUnification module Agda.TypeChecking.Pretty.Call sayWhere :: MonadPretty m => HasRange a => a -> m Doc -> m Doc sayWhen :: MonadPretty m => Range -> Maybe (Closure Call) -> m Doc -> m Doc instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.CallInfo instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Call -- | Implementations of the basic primitives of Cubical Agda: The interval -- and its operations. module Agda.TypeChecking.Primitive.Cubical.Base -- | Checks that the correct variant of Cubical Agda is activated. Note -- that --erased-cubical "counts as" --cubical in -- erased contexts. requireCubical :: Cubical -> String -> TCM () -- | Our good friend the interval type. primIntervalType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Type -- | Implements both the min connection and conjunction on -- the cofibration classifier. primIMin' :: TCM PrimitiveImpl -- | Implements both the max connection and disjunction on -- the cofibration classifier. primIMax' :: TCM PrimitiveImpl -- | primDepIMin expresses that cofibrations are closed under -- Σ. Thus, it serves as a dependent version of primIMin -- (which, recall, implements _∧_). This is required for the -- construction of the Kan operations in Id. primDepIMin' :: TCM PrimitiveImpl -- | Negation on the interval. Negation satisfies De Morgan's laws, and -- their implementation is handled here. primINeg' :: TCM PrimitiveImpl -- | A helper for evaluating max on the interval in TCM&co. imax :: HasBuiltins m => m Term -> m Term -> m Term -- | A helper for evaluating min on the interval in TCM&co. imin :: HasBuiltins m => m Term -> m Term -> m Term -- | A helper for evaluating neg on the interval in TCM&co. ineg :: HasBuiltins m => m Term -> m Term data Command DoTransp :: Command DoHComp :: Command -- | Our Kan operations are transp and hcomp. The -- KanOperation record stores the data associated with a Kan operation on -- arbitrary types: A cofibration and an element of that type. data KanOperation -- | A transport problem consists of a cofibration, marking where the -- transport is constant, and a term to move from the fibre over i0 to -- the fibre over i1. TranspOp :: Blocked (Arg Term) -> Arg Term -> KanOperation -- | When this cofibration holds, the transport must definitionally be the -- identity. This is handled generically by primTransHComp but -- specific Kan operations may still need it. [kanOpCofib] :: KanOperation -> Blocked (Arg Term) -- | This is the term in A i0 which we are transporting. [kanOpBase] :: KanOperation -> Arg Term -- | A composition problem consists of a partial element and a base. -- Semantically, this is justified by the types being Kan fibrations, -- i.e., having the lifting property against trivial cofibrations. While -- the specified cofibration may not be trivial, (φ ∨ ~ r) for r ∉ φ is -- *always* a trivial cofibration. HCompOp :: Blocked (Arg Term) -> Arg Term -> Arg Term -> KanOperation -- | When this cofibration holds, the transport must definitionally be the -- identity. This is handled generically by primTransHComp but -- specific Kan operations may still need it. [kanOpCofib] :: KanOperation -> Blocked (Arg Term) -- | The partial element itself [kanOpSides] :: KanOperation -> Arg Term -- | This is the term in A i0 which we are transporting. [kanOpBase] :: KanOperation -> Arg Term -- | The built-in name associated with a particular Kan operation. kanOpName :: KanOperation -> String -- | For the Kan operations in Glue and hcomp {Type}, we -- optimise evaluation a tiny bit by differentiating the term produced -- when evaluating a Kan operation by itself vs evaluating it under -- unglue. data TermPosition Head :: TermPosition Eliminated :: TermPosition -- | If we're computing a Kan operation for one of the "unstable" type -- formers (Glue, hcomp {Type}), this tells us whether -- the type will reduce further, and whether we should care. -- -- When should we care? When we're in the Head -- TermPosition. When will the type reduce further? When -- φ, its formula, is not i1. headStop :: PureTCM m => TermPosition -> m Term -> m Bool -- | Are we looking at a family of things, or at a single thing? data FamilyOrNot a IsFam :: a -> FamilyOrNot a [famThing] :: FamilyOrNot a -> a IsNot :: a -> FamilyOrNot a [famThing] :: FamilyOrNot a -> a familyOrNot :: IsString p => FamilyOrNot a -> p -- | Build a partial element. The type of the resulting partial element can -- depend on the computed extent, which we denote by φ here. -- Note that φ is the n-ary disjunction of all the ψs. combineSys :: HasBuiltins m => NamesT m Term -> NamesT m Term -> [(NamesT m Term, NamesT m Term)] -> NamesT m Term -- | Build a partial element, and compute its extent. See combineSys -- for the details. combineSys' :: forall m. HasBuiltins m => NamesT m Term -> NamesT m Term -> [(NamesT m Term, NamesT m Term)] -> NamesT m (Term, Term) -- | Helper function for constructing the type of fibres of a function over -- a given point. fiber :: (HasBuiltins m, HasConstInfo m) => NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -- | Helper function for constructing the filler of a given composition -- problem. hfill :: (HasBuiltins m, HasConstInfo m) => NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -- | Decompose an interval expression φ : I into a set of possible -- assignments for the variables mentioned in φ, together any -- leftover neutral terms that could not be put into IntervalView -- form. decomposeInterval' :: HasBuiltins m => Term -> m [(IntMap BoolSet, [Term])] -- | Decompose an interval expression i : I as in -- decomposeInterval', but discard any inconsistent mappings. decomposeInterval :: HasBuiltins m => Term -> m [(IntMap Bool, [Term])] reduce2Lam :: Term -> ReduceM (Blocked Term) -- | Are we looking at an application of the Sub type? If so, -- return: * The type we're an extension of * The extent * The partial -- element. isCubicalSubtype :: PureTCM m => Type -> m (Maybe (Term, Term, Term, Term)) instance GHC.Show.Show Agda.TypeChecking.Primitive.Cubical.Base.Command instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Cubical.Base.Command instance Data.Traversable.Traversable Agda.TypeChecking.Primitive.Cubical.Base.FamilyOrNot instance Data.Foldable.Foldable Agda.TypeChecking.Primitive.Cubical.Base.FamilyOrNot instance GHC.Base.Functor Agda.TypeChecking.Primitive.Cubical.Base.FamilyOrNot instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Primitive.Cubical.Base.FamilyOrNot a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Primitive.Cubical.Base.FamilyOrNot a) instance GHC.Show.Show Agda.TypeChecking.Primitive.Cubical.Base.TermPosition instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Cubical.Base.TermPosition instance Agda.TypeChecking.Reduce.Reduce a => Agda.TypeChecking.Reduce.Reduce (Agda.TypeChecking.Primitive.Cubical.Base.FamilyOrNot a) module Agda.TypeChecking.Primitive.Cubical -- | A Type that either has sort Type l or is a closed -- definition. Such a type supports some version of transp. In particular -- we want to allow the Interval as a ClosedType. data CType ClosedType :: Sort -> QName -> CType LType :: LType -> CType -- | A Type with sort Type l Such a type supports both -- hcomp and transp. data LType LEl :: Level -> Term -> LType data TranspError CannotTransp :: Closure (Abs Type) -> TranspError [errorType] :: TranspError -> Closure (Abs Type) type LM m a = NamesT (ExceptT (Closure (Abs Type)) m) a primPOr :: TCM PrimitiveImpl primPartial' :: TCM PrimitiveImpl primPartialP' :: TCM PrimitiveImpl primSubOut' :: TCM PrimitiveImpl primTrans' :: TCM PrimitiveImpl primHComp' :: TCM PrimitiveImpl -- | Construct a helper for CCHM composition, with a string indicating what -- function uses it. mkComp :: HasBuiltins m => String -> NamesT m (NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term) -- | Construct an application of buitlinComp. Use instead of mkComp -- if reducing directly to hcomp + transport would be problematic. mkCompLazy :: HasBuiltins m => String -> NamesT m (NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term) -- | Implementation of Kan operations for Pi types. The implementation of -- transp and hcomp for Pi types has many -- commonalities, so most of it is shared between the two cases. doPiKanOp :: KanOperation -> ArgName -> FamilyOrNot (Dom Type, Abs Type) -> ReduceM (Maybe Term) -- | Compute Kan operations in a type of dependent paths. doPathPKanOp :: KanOperation -> FamilyOrNot (Arg Term) -> FamilyOrNot (Arg Term, Arg Term, Arg Term) -> ReduceM (Reduced MaybeReducedArgs Term) redReturnNoSimpl :: a -> ReduceM (Reduced a' a) primTransHComp :: Command -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) -- | CCHM primComp is implemented in terms of hcomp and -- transport. The definition of it comes from mkComp. primComp :: TCM PrimitiveImpl primFaceForall' :: TCM PrimitiveImpl -- | Tries to primTransp a whole telescope of arguments, following -- the rule for Σ types. If a type in the telescope does not support -- transp, transpTel throws it as an exception. transpTel :: Abs Telescope -> Term -> Args -> ExceptT (Closure (Abs Type)) TCM Args transpTel' :: (PureTCM m, MonadError TCErr m) => Bool -> Abs Telescope -> Term -> Args -> ExceptT (Closure (Abs Type)) m Args transpSysTel' :: forall m. (PureTCM m, MonadError TCErr m) => Bool -> Abs Telescope -> [(Term, Abs [Term])] -> Term -> Args -> ExceptT (Closure (Abs Type)) m Args -- | Like transpTel but performing a transpFill. trFillTel :: Abs Telescope -> Term -> Args -> Term -> ExceptT (Closure (Abs Type)) TCM Args trFillTel' :: (PureTCM m, MonadError TCErr m) => Bool -> Abs Telescope -> Term -> Args -> Term -> ExceptT (Closure (Abs Type)) m Args pathTelescope :: forall m. (PureTCM m, MonadError TCErr m) => Telescope -> [Arg Term] -> [Arg Term] -> m Telescope pathTelescope' :: forall m. (PureTCM m, MonadError (Closure Type) m) => Telescope -> [Arg Term] -> [Arg Term] -> m Telescope tryTranspError :: TCM a -> TCM (Either (Closure (Abs Type)) a) transpPathPTel' :: NamesT TCM (Abs (Abs Telescope)) -> [NamesT TCM Term] -> [NamesT TCM Term] -> NamesT TCM Term -> [NamesT TCM Term] -> NamesT TCM [Arg Term] transpPathTel' :: NamesT TCM (Abs Telescope) -> [NamesT TCM Term] -> [NamesT TCM Term] -> NamesT TCM Term -> [NamesT TCM Term] -> NamesT TCM [Arg Term] trFillPathTel' :: NamesT TCM (Abs Telescope) -> [NamesT TCM Term] -> [NamesT TCM Term] -> NamesT TCM Term -> [NamesT TCM Term] -> NamesT TCM Term -> NamesT TCM [Arg Term] trFillPathPTel' :: NamesT TCM (Abs (Abs Telescope)) -> [NamesT TCM Term] -> [NamesT TCM Term] -> NamesT TCM Term -> [NamesT TCM Term] -> NamesT TCM Term -> NamesT TCM [Arg Term] expTelescope :: Type -> Telescope -> Telescope -- | Γ, Δ^I, i : I |- expS |Δ| : Γ, Δ expS :: Nat -> Substitution fromLType :: LType -> Type lTypeLevel :: LType -> Level toLType :: MonadReduce m => Type -> m (Maybe LType) fromCType :: CType -> Type toCType :: MonadReduce m => Type -> m (Maybe CType) hcomp :: (HasBuiltins m, MonadError TCErr m, MonadReduce m, MonadPretty m) => NamesT m Type -> [(NamesT m Term, NamesT m Term)] -> NamesT m Term -> NamesT m Term transpSys :: (HasBuiltins m, MonadError TCErr m, MonadReduce m) => NamesT m (Abs Type) -> [(NamesT m Term, NamesT m Term)] -> NamesT m Term -> NamesT m Term -> NamesT m Term debugClause :: String -> Clause -> TCM () instance GHC.Show.Show Agda.TypeChecking.Primitive.Cubical.LType instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Cubical.LType instance GHC.Show.Show Agda.TypeChecking.Primitive.Cubical.CType instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Cubical.CType instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Primitive.Cubical.CType instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Primitive.Cubical.CType instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Primitive.Cubical.LType instance GHC.Exception.Type.Exception Agda.TypeChecking.Primitive.Cubical.TranspError instance GHC.Show.Show Agda.TypeChecking.Primitive.Cubical.TranspError -- | Implementation of the primitives relating to Cubical identity types. module Agda.TypeChecking.Primitive.Cubical.Id -- | Primitive elimination rule for the cubical identity types. Unlike J, -- idElim makes explicit the structure of Swan's identity types -- as being pairs of a cofibration and a path. Moreover, it records that -- the path is definitionally refl under that cofibration. primIdElim' :: TCM PrimitiveImpl -- | Introduction form for the cubical identity types. primConId' :: TCM PrimitiveImpl -- | Extract the underlying cofibration from an inhabitant of the cubical -- identity types. -- -- TODO (Amy, 2022-08-17): Projecting a cofibration from a Kan type -- violates the cubical phase distinction. primIdFace' :: TCM PrimitiveImpl -- | Extract the underlying path from an inhabitant of the cubical identity -- types. primIdPath' :: TCM PrimitiveImpl doIdKanOp :: KanOperation -> FamilyOrNot (Arg Term) -> FamilyOrNot (Arg Term, Arg Term, Arg Term) -> ReduceM (Maybe (Reduced t Term)) module Agda.TypeChecking.Primitive.Cubical.HCompU -- | Perform the Kan operations for an hcomp {A = Type} {φ} u u0 -- type. doHCompUKanOp :: PureTCM m => KanOperation -> FamilyOrNot (Arg Term, Arg Term, Arg Term, Arg Term) -> TermPosition -> m (Maybe Term) -- | The implementation of prim_glueU, the introduction form for -- hcomp types. prim_glueU' :: TCM PrimitiveImpl -- | The implementation of prim_unglueU, the elimination form for -- hcomp types. prim_unglueU' :: TCM PrimitiveImpl module Agda.TypeChecking.Primitive.Cubical.Glue -- | Define a "ghcomp" version of gcomp. Normal comp looks like: -- -- comp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u -- ] (forward A 0 u0) -- -- So for "gcomp" we compute: -- -- gcomp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i -- u, ~ phi -> forward A 0 u0 ] (forward A 0 u0) -- -- The point of this is that gcomp does not produce any empty systems (if -- phi = 0 it will reduce to "forward A 0 u". mkGComp :: HasBuiltins m => String -> NamesT m (NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term) -- | Perform the Kan operations for a Glue φ A (T , e) type. doGlueKanOp :: PureTCM m => KanOperation -> FamilyOrNot (Arg Term, Arg Term, Arg Term, Arg Term, Arg Term, Arg Term) -> TermPosition -> m (Maybe Term) primGlue' :: TCM PrimitiveImpl -- | The implementation of prim_glue, the introduction form for -- Glue types. prim_glue' :: TCM PrimitiveImpl -- | The implementation of prim_unglue, the elimination form for -- Glue types. prim_unglue' :: TCM PrimitiveImpl -- | Lenses for CommandLineOptions and PragmaOptions. -- -- Add as needed. -- -- Nothing smart happening here. module Agda.Interaction.Options.Lenses class LensPragmaOptions a getPragmaOptions :: LensPragmaOptions a => a -> PragmaOptions setPragmaOptions :: LensPragmaOptions a => PragmaOptions -> a -> a mapPragmaOptions :: LensPragmaOptions a => (PragmaOptions -> PragmaOptions) -> a -> a lensPragmaOptions :: LensPragmaOptions a => Lens' PragmaOptions a modifyPragmaOptions :: MonadTCState m => (PragmaOptions -> PragmaOptions) -> m () class LensVerbosity a getVerbosity :: LensVerbosity a => a -> Verbosity setVerbosity :: LensVerbosity a => Verbosity -> a -> a mapVerbosity :: LensVerbosity a => (Verbosity -> Verbosity) -> a -> a modifyVerbosity :: MonadTCState m => (Verbosity -> Verbosity) -> m () putVerbosity :: MonadTCState m => Verbosity -> m () class LensCommandLineOptions a getCommandLineOptions :: LensCommandLineOptions a => a -> CommandLineOptions setCommandLineOptions :: LensCommandLineOptions a => CommandLineOptions -> a -> a mapCommandLineOptions :: LensCommandLineOptions a => (CommandLineOptions -> CommandLineOptions) -> a -> a modifyCommandLineOptions :: MonadTCState m => (CommandLineOptions -> CommandLineOptions) -> m () type SafeMode = Bool class LensSafeMode a getSafeMode :: LensSafeMode a => a -> SafeMode setSafeMode :: LensSafeMode a => SafeMode -> a -> a mapSafeMode :: LensSafeMode a => (SafeMode -> SafeMode) -> a -> a modifySafeMode :: MonadTCState m => (SafeMode -> SafeMode) -> m () putSafeMode :: MonadTCState m => SafeMode -> m () -- | These builtins may use postulates, and are still considered --safe builtinModulesWithSafePostulates :: Set FilePath -- | These builtins may not use postulates under --safe. They are not -- automatically unsafe, but will be if they use an unsafe feature. builtinModulesWithUnsafePostulates :: Set FilePath primitiveModules :: Set FilePath builtinModules :: Set FilePath isPrimitiveModule :: MonadIO m => FilePath -> m Bool isBuiltinModule :: MonadIO m => FilePath -> m Bool isBuiltinModuleWithSafePostulates :: MonadIO m => FilePath -> m Bool class LensIncludePaths a getIncludePaths :: LensIncludePaths a => a -> [FilePath] setIncludePaths :: LensIncludePaths a => [FilePath] -> a -> a mapIncludePaths :: LensIncludePaths a => ([FilePath] -> [FilePath]) -> a -> a getAbsoluteIncludePaths :: LensIncludePaths a => a -> [AbsolutePath] setAbsoluteIncludePaths :: LensIncludePaths a => [AbsolutePath] -> a -> a mapAbsoluteIncludePaths :: LensIncludePaths a => ([AbsolutePath] -> [AbsolutePath]) -> a -> a modifyIncludePaths :: MonadTCState m => ([FilePath] -> [FilePath]) -> m () putIncludePaths :: MonadTCState m => [FilePath] -> m () modifyAbsoluteIncludePaths :: MonadTCState m => ([AbsolutePath] -> [AbsolutePath]) -> m () putAbsoluteIncludePaths :: MonadTCState m => [AbsolutePath] -> m () type PersistentVerbosity = Verbosity class LensPersistentVerbosity a getPersistentVerbosity :: LensPersistentVerbosity a => a -> PersistentVerbosity setPersistentVerbosity :: LensPersistentVerbosity a => PersistentVerbosity -> a -> a mapPersistentVerbosity :: LensPersistentVerbosity a => (PersistentVerbosity -> PersistentVerbosity) -> a -> a modifyPersistentVerbosity :: MonadTCState m => (PersistentVerbosity -> PersistentVerbosity) -> m () putPersistentVerbosity :: MonadTCState m => PersistentVerbosity -> m () instance Agda.Interaction.Options.Lenses.LensPersistentVerbosity Agda.Interaction.Options.Base.PragmaOptions instance Agda.Interaction.Options.Lenses.LensPersistentVerbosity Agda.Interaction.Options.Base.CommandLineOptions instance Agda.Interaction.Options.Lenses.LensPersistentVerbosity Agda.TypeChecking.Monad.Base.PersistentTCState instance Agda.Interaction.Options.Lenses.LensPersistentVerbosity Agda.TypeChecking.Monad.Base.TCState instance Agda.Interaction.Options.Lenses.LensIncludePaths Agda.Interaction.Options.Base.CommandLineOptions instance Agda.Interaction.Options.Lenses.LensIncludePaths Agda.TypeChecking.Monad.Base.PersistentTCState instance Agda.Interaction.Options.Lenses.LensIncludePaths Agda.TypeChecking.Monad.Base.TCState instance Agda.Interaction.Options.Lenses.LensSafeMode Agda.Interaction.Options.Base.PragmaOptions instance Agda.Interaction.Options.Lenses.LensSafeMode Agda.Interaction.Options.Base.CommandLineOptions instance Agda.Interaction.Options.Lenses.LensSafeMode Agda.TypeChecking.Monad.Base.PersistentTCState instance Agda.Interaction.Options.Lenses.LensSafeMode Agda.TypeChecking.Monad.Base.TCState instance Agda.Interaction.Options.Lenses.LensCommandLineOptions Agda.TypeChecking.Monad.Base.PersistentTCState instance Agda.Interaction.Options.Lenses.LensCommandLineOptions Agda.TypeChecking.Monad.Base.TCState instance Agda.Interaction.Options.Lenses.LensVerbosity Agda.Interaction.Options.Base.PragmaOptions instance Agda.Interaction.Options.Lenses.LensVerbosity Agda.TypeChecking.Monad.Base.TCState instance Agda.Interaction.Options.Lenses.LensPragmaOptions Agda.Interaction.Options.Base.CommandLineOptions instance Agda.Interaction.Options.Lenses.LensPragmaOptions Agda.TypeChecking.Monad.Base.TCState -- | The occurs check for unification. Does pruning on the fly. -- -- When hitting a meta variable: -- -- module Agda.TypeChecking.MetaVars.Occurs modifyOccursCheckDefs :: (Set QName -> Set QName) -> TCM () -- | Set the names of definitions to be looked at to the defs in the -- current mutual block. initOccursCheck :: MetaVariable -> TCM () -- | Is a def in the list of stuff to be checked? defNeedsChecking :: QName -> TCM Bool -- | Remove a def from the list of defs to be looked at. tallyDef :: QName -> TCM () -- | Extra environment for the occurs check. (Complements FreeEnv'.) data OccursExtra OccursExtra :: UnfoldStrategy -> VarMap -> MetaId -> Nat -> OccursExtra [occUnfold] :: OccursExtra -> UnfoldStrategy -- | The allowed variables with their variance. [occVars] :: OccursExtra -> VarMap -- | The meta we want to solve. [occMeta] :: OccursExtra -> MetaId -- | The size of the typing context upon invocation. [occCxtSize] :: OccursExtra -> Nat type OccursCtx = FreeEnv' () OccursExtra AllowedVar type OccursM = ReaderT OccursCtx TCM -- | The passed modality is the one of the current context. type AllowedVar = Modality -> All -- | Check whether a free variable is allowed in the context as specified -- by the modality. variableCheck :: VarMap -> Maybe Variable -> AllowedVar -- | Occurs check fails if a defined name is not available since it was -- declared in irrelevant or erased context. definitionCheck :: QName -> OccursM () metaCheck :: MetaId -> OccursM MetaId -- | Construct a test whether a de Bruijn index is allowed or needs to be -- pruned. allowedVars :: OccursM (Nat -> Bool) -- | Unfold definitions during occurs check? This effectively runs the -- occurs check on the normal form. data UnfoldStrategy YesUnfold :: UnfoldStrategy NoUnfold :: UnfoldStrategy defArgs :: OccursM a -> OccursM a -- | For a path constructor `c : ... -> Path D a b`, we have that e.g. -- `c es i0` reduces to a. So we have to consider its arguments -- as flexible when we do not actually unfold. conArgs :: Elims -> OccursM a -> OccursM a unfoldB :: (Instantiate t, Reduce t) => t -> OccursM (Blocked t) unfold :: (Instantiate t, Reduce t) => t -> OccursM t -- | Leave the strongly rigid position. weakly :: OccursM a -> OccursM a strongly :: OccursM a -> OccursM a flexibly :: OccursM a -> OccursM a patternViolation' :: MonadTCM m => Blocker -> Int -> String -> m a abort :: Blocker -> TypeError -> OccursM a -- | Extended occurs check. class Occurs t occurs :: Occurs t => t -> OccursM t metaOccurs :: Occurs t => MetaId -> t -> TCM () occurs :: (Occurs t, Traversable f, Occurs a, f a ~ t) => t -> OccursM t metaOccurs :: (Occurs t, Foldable f, Occurs a, f a ~ t) => MetaId -> t -> TCM () -- | When assigning m xs := v, check that m does not -- occur in v and that the free variables of v are -- contained in xs. occursCheck :: (Occurs a, InstantiateFull a, PrettyTCM a) => MetaId -> VarMap -> a -> TCM a metaOccursQName :: MetaId -> QName -> TCM () -- | prune m' vs xs attempts to remove all arguments from -- vs whose free variables are not contained in xs. If -- successful, m' is solved by the new, pruned meta variable and -- we return True else False. -- -- Issue 1147: If any of the meta args vs is matchable, e.g., is -- a constructor term, we cannot prune, because the offending variables -- could be removed by reduction for a suitable instantiation of the meta -- variable. prune :: (PureTCM m, MonadMetaSolver m) => MetaId -> Args -> (Nat -> Bool) -> m PruneResult -- | hasBadRigid xs v = Just True iff one of the rigid variables -- in v is not in xs. Actually we can only prune if a -- bad variable is in the head. See issue 458. Or in a non-eliminateable -- position (see succeed/PruningNonMillerPattern). -- -- hasBadRigid xs v = Nothing means that we cannot prune at all -- as one of the meta args is matchable. (See issue 1147.) hasBadRigid :: PureTCM m => (Nat -> Bool) -> Term -> ExceptT () m Bool -- | Check whether a term Def f es is finally stuck. Currently, we -- give only a crude approximation. isNeutral :: HasConstInfo m => Blocked t -> QName -> Elims -> m Bool -- | Check whether any of the variables (given as de Bruijn indices) occurs -- *definitely* in the term in a rigid position. Reduces the term -- successively to remove variables in dead subterms. This fixes issue -- 1386. rigidVarsNotContainedIn :: (PureTCM m, AnyRigid a) => a -> (Nat -> Bool) -> m Bool -- | Collect the *definitely* rigid variables in a monoid. We need to -- successively reduce the expression to do this. class AnyRigid a anyRigid :: (AnyRigid a, PureTCM tcm) => (Nat -> tcm Bool) -> a -> tcm Bool data PruneResult -- | the kill list is empty or only Falses NothingToPrune :: PruneResult -- | there is no possible kill (because of type dep.) PrunedNothing :: PruneResult -- | managed to kill some args in the list PrunedSomething :: PruneResult -- | all prescribed kills where performed PrunedEverything :: PruneResult -- | killArgs [k1,...,kn] X prunes argument i from -- metavar X if ki==True. Pruning is carried out -- whenever > 0 arguments can be pruned. killArgs :: MonadMetaSolver m => [Bool] -> MetaId -> m PruneResult -- | killedType [((x1,a1),k1)..((xn,an),kn)] b = ([k'1..k'n],t') -- (ignoring Dom). Let t' = (xs:as) -> b. Invariant: -- k'i == True iff ki == True and pruning the -- ith argument from type b is possible without -- creating unbound variables. t' is type t after -- pruning all k'i==True. killedType :: MonadReduce m => [(Dom (ArgName, Type), Bool)] -> Type -> m ([Arg Bool], Type) reallyNotFreeIn :: MonadReduce m => IntSet -> Type -> m (IntSet, Type) -- | Instantiate a meta variable with a new one that only takes the -- arguments which are not pruneable. performKill :: MonadMetaSolver m => [Arg Bool] -> MetaId -> Type -> m () instance GHC.Show.Show Agda.TypeChecking.MetaVars.Occurs.UnfoldStrategy instance GHC.Classes.Eq Agda.TypeChecking.MetaVars.Occurs.UnfoldStrategy instance GHC.Show.Show Agda.TypeChecking.MetaVars.Occurs.PruneResult instance GHC.Classes.Eq Agda.TypeChecking.MetaVars.Occurs.PruneResult instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.Term instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid Agda.Syntax.Internal.Term instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid Agda.Syntax.Internal.Type instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid Agda.Syntax.Internal.Sort instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid Agda.Syntax.Internal.Level instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid Agda.Syntax.Internal.PlusLevel instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.MetaVars.Occurs.AnyRigid a) => Agda.TypeChecking.MetaVars.Occurs.AnyRigid (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid a => Agda.TypeChecking.MetaVars.Occurs.AnyRigid (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid a => Agda.TypeChecking.MetaVars.Occurs.AnyRigid (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid a => Agda.TypeChecking.MetaVars.Occurs.AnyRigid (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.MetaVars.Occurs.AnyRigid a => Agda.TypeChecking.MetaVars.Occurs.AnyRigid [a] instance (Agda.TypeChecking.MetaVars.Occurs.AnyRigid a, Agda.TypeChecking.MetaVars.Occurs.AnyRigid b) => Agda.TypeChecking.MetaVars.Occurs.AnyRigid (a, b) instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.TypeChecking.Monad.Base.Defn instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.Clause instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.Level instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.Type instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.Sort instance Agda.TypeChecking.MetaVars.Occurs.Occurs a => Agda.TypeChecking.MetaVars.Occurs.Occurs (Agda.Syntax.Internal.Elim.Elim' a) instance (Agda.TypeChecking.MetaVars.Occurs.Occurs a, Agda.TypeChecking.Substitute.Class.Subst a) => Agda.TypeChecking.MetaVars.Occurs.Occurs (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.MetaVars.Occurs.Occurs a => Agda.TypeChecking.MetaVars.Occurs.Occurs (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.MetaVars.Occurs.Occurs a => Agda.TypeChecking.MetaVars.Occurs.Occurs (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.MetaVars.Occurs.Occurs a => Agda.TypeChecking.MetaVars.Occurs.Occurs [a] instance Agda.TypeChecking.MetaVars.Occurs.Occurs a => Agda.TypeChecking.MetaVars.Occurs.Occurs (GHC.Maybe.Maybe a) instance (Agda.TypeChecking.MetaVars.Occurs.Occurs a, Agda.TypeChecking.MetaVars.Occurs.Occurs b) => Agda.TypeChecking.MetaVars.Occurs.Occurs (a, b) instance (Agda.TypeChecking.MetaVars.Occurs.Occurs a, Agda.TypeChecking.MetaVars.Occurs.Occurs b, Agda.TypeChecking.MetaVars.Occurs.Occurs c) => Agda.TypeChecking.MetaVars.Occurs.Occurs (a, b, c) instance Agda.TypeChecking.Free.Lazy.IsVarSet () Agda.TypeChecking.MetaVars.Occurs.AllowedVar -- | Measure CPU time for individual phases of the Agda pipeline. module Agda.TypeChecking.Monad.Benchmark -- | Monad with access to benchmarking data. class (Ord (BenchPhase m), Functor m, MonadIO m) => MonadBench m type BenchPhase m getBenchmark :: MonadBench m => m (Benchmark (BenchPhase m)) -- | When profile options are set or changed, we need to turn benchmarking -- on or off. updateBenchmarkingStatus :: TCM () -- | Bill a computation to a specific account. Works even if the -- computation is aborted by an exception. billTo :: MonadBench m => Account (BenchPhase m) -> m c -> m c -- | Bill a pure computation to a specific account. billPureTo :: MonadBench m => Account (BenchPhase m) -> c -> m c -- | Bill a CPS function to an account. Can't handle exceptions. billToCPS :: MonadBench m => Account (BenchPhase m) -> ((b -> m c) -> m c) -> (b -> m c) -> m c -- | Resets the account and the timing information. reset :: MonadBench m => m () -- | Prints the accumulated benchmark results. Does nothing if no benchmark -- profiling is enabled. print :: MonadTCM tcm => tcm () -- | Free variable check that reduces the subject to make certain variables -- not free. Used when pruning metavariables in -- Agda.TypeChecking.MetaVars.Occurs. module Agda.TypeChecking.Free.Reduce class (PrecomputeFreeVars a, Subst a) => ForceNotFree a -- | Try to enforce a set of variables not occurring in a given type. -- Returns a possibly reduced version of the type and for each of the -- given variables whether it is either not free, or maybe free depending -- on some metavariables. forceNotFree :: (ForceNotFree a, Reduce a, MonadReduce m) => IntSet -> a -> m (IntMap IsFree, a) -- | Checks if the given term contains any free variables that are in the -- given set of variables, possibly reducing the term in the process. -- Returns `Right Nothing` if there are such variables, `Right (Just v')` -- if there are none (where v' is the possibly reduced version of the -- given term) or `Left b` if the problem is blocked on a meta. reallyFree :: (MonadReduce m, Reduce a, ForceNotFree a) => IntSet -> a -> m (Either Blocked_ (Maybe a)) -- | A variable can either not occur (NotFree) or it does occur -- (MaybeFree). In the latter case, the occurrence may disappear -- depending on the instantiation of some set of metas. data IsFree MaybeFree :: MetaSet -> IsFree NotFree :: IsFree instance GHC.Show.Show Agda.TypeChecking.Free.Reduce.IsFree instance GHC.Classes.Eq Agda.TypeChecking.Free.Reduce.IsFree instance (Agda.TypeChecking.Reduce.Reduce a, Agda.TypeChecking.Free.Reduce.ForceNotFree a) => Agda.TypeChecking.Free.Reduce.ForceNotFree (Agda.Syntax.Common.Arg a) instance (Agda.TypeChecking.Reduce.Reduce a, Agda.TypeChecking.Free.Reduce.ForceNotFree a, Agda.TypeChecking.Substitute.Class.TermSubst a) => Agda.TypeChecking.Free.Reduce.ForceNotFree (Agda.Syntax.Internal.Dom a) instance (Agda.TypeChecking.Reduce.Reduce a, Agda.TypeChecking.Free.Reduce.ForceNotFree a) => Agda.TypeChecking.Free.Reduce.ForceNotFree (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Free.Reduce.ForceNotFree a => Agda.TypeChecking.Free.Reduce.ForceNotFree [a] instance (Agda.TypeChecking.Reduce.Reduce a, Agda.TypeChecking.Free.Reduce.ForceNotFree a) => Agda.TypeChecking.Free.Reduce.ForceNotFree (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Free.Reduce.ForceNotFree Agda.Syntax.Internal.Type instance Agda.TypeChecking.Free.Reduce.ForceNotFree Agda.Syntax.Internal.Term instance Agda.TypeChecking.Free.Reduce.ForceNotFree Agda.Syntax.Internal.Level instance Agda.TypeChecking.Free.Reduce.ForceNotFree Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Free.Reduce.ForceNotFree Agda.Syntax.Internal.Sort module Agda.TypeChecking.Constraints addConstraintTCM :: Blocker -> Constraint -> TCM () wakeConstraintsTCM :: (ProblemConstraint -> WakeUp) -> TCM () -- | Add all constraints belonging to the given problem to the current -- problem(s). stealConstraintsTCM :: ProblemId -> TCM () -- | Don't allow the argument to produce any blocking constraints. -- -- WARNING: this does not mean that the given computation cannot -- constrain the solution space further. It can well do so, by solving -- metas. noConstraints :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) => m a -> m a -- | Run a computation that should succeeds without constraining the -- solution space, i.e., not add any information about meta-variables. nonConstraining :: (HasOptions m, MonadConstraint m, MonadDebug m, MonadError TCErr m, MonadFresh ProblemId m, MonadTCEnv m, MonadWarning m) => m a -> m a -- | Create a fresh problem for the given action. newProblem :: (MonadFresh ProblemId m, MonadConstraint m) => m a -> m (ProblemId, a) newProblem_ :: (MonadFresh ProblemId m, MonadConstraint m) => m a -> m ProblemId ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b ifNoConstraints_ :: TCM () -> TCM a -> (ProblemId -> TCM a) -> TCM a -- | guardConstraint c blocker tries to solve blocker -- first. If successful without constraints, it moves on to solve -- c, otherwise it adds a c to the constraint pool, -- blocked by the problem generated by blocker. guardConstraint :: Constraint -> TCM () -> TCM () whenConstraints :: TCM () -> TCM () -> TCM () -- | Wake up the constraints depending on the given meta. wakeupConstraints :: MonadMetaSolver m => MetaId -> m () -- | Wake up all constraints not blocked on a problem. wakeupConstraints_ :: TCM () -- | Solve awake constraints matching the predicate. If the second argument -- is True solve constraints even if already isSolvingConstraints. solveSomeAwakeConstraintsTCM :: (ProblemConstraint -> Bool) -> Bool -> TCM () solveConstraintTCM :: Constraint -> TCM () solveConstraint_ :: Constraint -> TCM () checkTypeCheckingProblem :: TypeCheckingProblem -> TCM Term debugConstraints :: TCM () instance Agda.TypeChecking.Monad.Constraints.MonadConstraint Agda.TypeChecking.Monad.Base.TCM module Agda.TypeChecking.Rules.Term -- | Check that an expression is a type. isType :: Expr -> Sort -> TCM Type -- | Check that an expression is a type. * If c == CmpEq, the -- given sort must be the minimal sort. * If c == CmpLeq, the -- given sort may be any bigger sort. isType' :: Comparison -> Expr -> Sort -> TCM Type -- | Check that an expression is a type and infer its (minimal) sort. isType_ :: Expr -> TCM Type checkLevel :: NamedArg Expr -> TCM Level -- | Ensure that a (freshly created) function type does not inhabit -- SizeUniv. Precondition: When noFunctionsIntoSize t -- tBlame is called, we are in the context of tBlame in -- order to print it correctly. Not being in context of t should -- not matter, as we are only checking whether its sort reduces to -- SizeUniv. -- -- Currently UNUSED since SizeUniv is turned off (as of 2016). -- -- Check that an expression is a type which is equal to a given type. isTypeEqualTo :: Expr -> Type -> TCM Type leqType_ :: Type -> Type -> TCM () checkGeneralizeTelescope :: GeneralizeTelescope -> ([Maybe Name] -> Telescope -> TCM a) -> TCM a -- | Type check a (module) telescope. Binds the variables defined by the -- telescope. checkTelescope :: Telescope -> (Telescope -> TCM a) -> TCM a -- | Type check the telescope of a dependent function type. Binds the -- resurrected variables defined by the telescope. The returned telescope -- is unmodified (not resurrected). checkPiTelescope :: Telescope -> (Telescope -> TCM a) -> TCM a -- | Flag to control resurrection on domains. data LamOrPi -- | We are checking a module telescope. We pass into the type world to -- check the domain type. This resurrects the whole context. LamNotPi :: LamOrPi -- | We are checking a telescope in a Pi-type. We stay in the term world, -- but add resurrected domains to the context to check the remaining -- domains and codomain of the Pi-type. PiNotLam :: LamOrPi -- | Type check a telescope. Binds the variables defined by the telescope. checkTelescope' :: LamOrPi -> Telescope -> (Telescope -> TCM a) -> TCM a -- | Check the domain of a function type. Used in -- checkTypedBindings and to typecheck A.Fun cases. checkDomain :: (LensLock a, LensModality a) => LamOrPi -> List1 a -> Expr -> TCM Type checkPiDomain :: (LensLock a, LensModality a) => List1 a -> Expr -> TCM Type -- | Check a typed binding and extends the context with the bound -- variables. The telescope passed to the continuation is valid in the -- original context. -- -- Parametrized by a flag wether we check a typed lambda or a Pi. This -- flag is needed for irrelevance. checkTypedBindings :: LamOrPi -> TypedBinding -> (Telescope -> TCM a) -> TCM a -- | After a typed binding has been checked, add the patterns it binds addTypedPatterns :: List1 (NamedArg Binder) -> TCM a -> TCM a -- | Check a tactic attribute. Should have type Term → TC ⊤. checkTacticAttribute :: LamOrPi -> Expr -> TCM Term checkPath :: TypedBinding -> Expr -> Type -> TCM Term -- | Type check a lambda expression. "checkLambda bs e ty" means ( bs -> -- e) : ty checkLambda :: Comparison -> TypedBinding -> Expr -> Type -> TCM Term checkLambda' :: Comparison -> TypedBinding -> List1 (NamedArg Binder) -> Expr -> Expr -> Type -> TCM Term -- | Check that modality info in lambda is compatible with modality coming -- from the function type. If lambda has no user-given modality, copy -- that of function type. lambdaModalityCheck :: (LensAnnotation dom, LensModality dom) => dom -> ArgInfo -> TCM ArgInfo -- | Check that irrelevance info in lambda is compatible with irrelevance -- coming from the function type. If lambda has no user-given relevance, -- copy that of function type. lambdaIrrelevanceCheck :: LensRelevance dom => dom -> ArgInfo -> TCM ArgInfo -- | Check that quantity info in lambda is compatible with quantity coming -- from the function type. If lambda has no user-given quantity, copy -- that of function type. lambdaQuantityCheck :: LensQuantity dom => dom -> ArgInfo -> TCM ArgInfo lambdaAnnotationCheck :: LensAnnotation dom => dom -> ArgInfo -> TCM ArgInfo -- | Check that cohesion info in lambda is compatible with cohesion coming -- from the function type. If lambda has no user-given cohesion, copy -- that of function type. lambdaCohesionCheck :: LensCohesion dom => dom -> ArgInfo -> TCM ArgInfo lambdaAddContext :: Name -> ArgName -> Dom Type -> TCM a -> TCM a -- | Checking a lambda whose domain type has already been checked. checkPostponedLambda :: Comparison -> Arg (List1 (WithHiding Name), Maybe Type) -> Expr -> Type -> TCM Term checkPostponedLambda0 :: Comparison -> Arg ([WithHiding Name], Maybe Type) -> Expr -> Type -> TCM Term -- | Insert hidden lambda until the hiding info of the domain type matches -- the expected hiding info. Throws WrongHidingInLambda insertHiddenLambdas :: Hiding -> Type -> (Blocker -> Type -> TCM Term) -> (Type -> TCM Term) -> TCM Term -- | checkAbsurdLambda i h e t checks absurd lambda against type -- t. Precondition: e = AbsurdLam i h checkAbsurdLambda :: Comparison -> ExprInfo -> Hiding -> Expr -> Type -> TCM Term -- | checkExtendedLambda i di erased qname cs e t check pattern -- matching lambda. Precondition: e = ExtendedLam i di erased qname -- cs checkExtendedLambda :: Comparison -> ExprInfo -> DefInfo -> Erased -> QName -> List1 Clause -> Expr -> Type -> TCM Term -- | Run a computation. -- -- -- -- Note that the returned meta might only exists in the state where the -- error was thrown, thus, be an invalid MetaId in the current -- state. catchIlltypedPatternBlockedOnMeta :: TCM a -> ((TCErr, Blocker) -> TCM a) -> TCM a -- | Picks up record field assignments from modules that export a -- definition that has the same name as the missing field. expandModuleAssigns :: [Either Assign ModuleName] -> [Name] -> TCM Assigns -- | checkRecordExpression fs e t checks record construction -- against type t. Precondition e = Rec _ fs. checkRecordExpression :: Comparison -> RecordAssigns -> Expr -> Type -> TCM Term -- |
--   checkRecordUpdate cmp ei recexpr fs e t
--   
-- -- Preconditions: e = RecUpdate ei recexpr fs and t is -- reduced. checkRecordUpdate :: Comparison -> ExprInfo -> Expr -> Assigns -> Expr -> Type -> TCM Term checkLiteral :: Literal -> Type -> TCM Term -- | Remove top layers of scope info of expression and set the scope -- accordingly in the TCState. scopedExpr :: Expr -> TCM Expr -- | Type check an expression. checkExpr :: Expr -> Type -> TCM Term checkExpr' :: Comparison -> Expr -> Type -> TCM Term doQuoteTerm :: Comparison -> Term -> Type -> TCM Term -- | Unquote a TCM computation in a given hole. unquoteM :: Expr -> Term -> Type -> TCM () -- | Run a tactic `tac : Term → TC ⊤` in a hole (second argument) of the -- type given by the third argument. Runs the continuation if successful. unquoteTactic :: Term -> Term -> Type -> TCM () -- | Check an interaction point without arguments. checkQuestionMark :: (Comparison -> Type -> TCM (MetaId, Term)) -> Comparison -> Type -> MetaInfo -> InteractionId -> TCM Term -- | Check an underscore without arguments. checkUnderscore :: Comparison -> Type -> MetaInfo -> TCM Term -- | Type check a meta variable. checkMeta :: (Comparison -> Type -> TCM (MetaId, Term)) -> Comparison -> Type -> MetaInfo -> TCM Term -- | Infer the type of a meta variable. If it is a new one, we create a new -- meta for its type. inferMeta :: (Comparison -> Type -> TCM (MetaId, Term)) -> MetaInfo -> TCM (Elims -> Term, Type) -- | Type check a meta variable. If its type is not given, we return its -- type, or a fresh one, if it is a new meta. If its type is given, we -- check that the meta has this type, and we return the same type. checkOrInferMeta :: (Comparison -> Type -> TCM (MetaId, Term)) -> Maybe (Comparison, Type) -> MetaInfo -> TCM (Term, Type) -- | Turn a domain-free binding (e.g. lambda) into a domain-full one, by -- inserting an underscore for the missing type. domainFree :: ArgInfo -> Binder' Name -> LamBinding -- | Check arguments whose value we already know. -- -- This function can be used to check user-supplied parameters we have -- already computed by inference. -- -- Precondition: The type t of the head has enough domains. checkKnownArguments :: [NamedArg Expr] -> Args -> Type -> TCM (Args, Type) -- | Check an argument whose value we already know. checkKnownArgument :: NamedArg Expr -> Args -> Type -> TCM (Args, Type) -- | Check a single argument. checkNamedArg :: NamedArg Expr -> Type -> TCM Term -- | Infer the type of an expression. Implemented by checking against a -- meta variable. Except for neutrals, for them a polymorphic type is -- inferred. inferExpr :: Expr -> TCM (Term, Type) inferExpr' :: ExpandHidden -> Expr -> TCM (Term, Type) defOrVar :: Expr -> Bool -- | Used to check aliases f = e. Switches off ExpandLast -- for the checking of top-level application. checkDontExpandLast :: Comparison -> Expr -> Type -> TCM Term -- | Check whether a de Bruijn index is bound by a module telescope. isModuleFreeVar :: Int -> TCM Bool -- | Infer the type of an expression, and if it is of the form {tel} -- -> D vs for some datatype D then insert the hidden -- arguments. Otherwise, leave the type polymorphic. inferExprForWith :: Arg Expr -> TCM (Term, Type) checkLetBindings :: Foldable t => t LetBinding -> TCM a -> TCM a checkLetBinding :: LetBinding -> TCM a -> TCM a instance GHC.Show.Show Agda.TypeChecking.Rules.Term.LamOrPi instance GHC.Classes.Eq Agda.TypeChecking.Rules.Term.LamOrPi module Agda.TypeChecking.Unquote agdaTermType :: TCM Type agdaTypeType :: TCM Type qNameType :: TCM Type data Dirty Dirty :: Dirty Clean :: Dirty type UnquoteState = (Dirty, TCState) type UnquoteM = ReaderT Context (StateT UnquoteState (WriterT [QName] (ExceptT UnquoteError TCM))) type UnquoteRes a = Either UnquoteError ((a, UnquoteState), [QName]) unpackUnquoteM :: UnquoteM a -> Context -> UnquoteState -> TCM (UnquoteRes a) packUnquoteM :: (Context -> UnquoteState -> TCM (UnquoteRes a)) -> UnquoteM a runUnquoteM :: UnquoteM a -> TCM (Either UnquoteError (a, [QName])) liftU1 :: (TCM (UnquoteRes a) -> TCM (UnquoteRes b)) -> UnquoteM a -> UnquoteM b liftU2 :: (TCM (UnquoteRes a) -> TCM (UnquoteRes b) -> TCM (UnquoteRes c)) -> UnquoteM a -> UnquoteM b -> UnquoteM c inOriginalContext :: UnquoteM a -> UnquoteM a isCon :: ConHead -> TCM Term -> UnquoteM Bool isDef :: QName -> TCM Term -> UnquoteM Bool reduceQuotedTerm :: Term -> UnquoteM Term class Unquote a unquote :: Unquote a => Term -> UnquoteM a unquoteN :: Unquote a => Arg Term -> UnquoteM a choice :: Monad m => [(m Bool, m a)] -> m a -> m a ensureDef :: QName -> UnquoteM QName ensureCon :: QName -> UnquoteM QName pickName :: Type -> String unquoteString :: Term -> UnquoteM String unquoteNString :: Arg Term -> UnquoteM Text data ErrorPart StrPart :: String -> ErrorPart TermPart :: Expr -> ErrorPart PattPart :: Pattern -> ErrorPart NamePart :: QName -> ErrorPart -- | We do a little bit of work here to make it possible to generate nice -- layout for multi-line error messages. Specifically we split the parts -- into lines (indicated by n in a string part) and vcat all the lines. prettyErrorParts :: [ErrorPart] -> TCM Doc -- | Argument should be a term of type Term → TCM A for some A. -- Returns the resulting term of type A. The second argument is -- the term for the hole, which will typically be a metavariable. This is -- passed to the computation (quoted). unquoteTCM :: Term -> Term -> UnquoteM Term evalTCM :: Term -> UnquoteM Term type ExeArg = Text type StdIn = Text type StdOut = Text type StdErr = Text -- | Raise an error if the --allow-exec option was not specified. requireAllowExec :: TCM () -- | Convert an ExitCode to an Agda natural number. exitCodeToNat :: ExitCode -> Nat -- | Call a trusted executable with the given arguments and input. -- -- Returns the exit code, stdout, and stderr. tcExec :: ExeName -> [ExeArg] -> StdIn -> TCM Term -- | Raise an error if the trusted executable cannot be found. raiseExeNotTrusted :: ExeName -> Map ExeName FilePath -> TCM a raiseExeNotFound :: ExeName -> FilePath -> TCM a raiseExeNotExecutable :: ExeName -> FilePath -> TCM a instance GHC.Classes.Eq Agda.TypeChecking.Unquote.Dirty instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Unquote.ErrorPart instance Agda.TypeChecking.Unquote.Unquote Agda.TypeChecking.Unquote.ErrorPart instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Common.Modality instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Common.ArgInfo instance Agda.TypeChecking.Unquote.Unquote a => Agda.TypeChecking.Unquote.Unquote (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Reflected.Elim instance Agda.TypeChecking.Unquote.Unquote GHC.Types.Bool instance Agda.TypeChecking.Unquote.Unquote GHC.Num.Integer.Integer instance Agda.TypeChecking.Unquote.Unquote GHC.Word.Word64 instance Agda.TypeChecking.Unquote.Unquote GHC.Types.Double instance Agda.TypeChecking.Unquote.Unquote GHC.Types.Char instance Agda.TypeChecking.Unquote.Unquote Data.Text.Internal.Text instance Agda.TypeChecking.Unquote.Unquote a => Agda.TypeChecking.Unquote.Unquote [a] instance (Agda.TypeChecking.Unquote.Unquote a, Agda.TypeChecking.Unquote.Unquote b) => Agda.TypeChecking.Unquote.Unquote (a, b) instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Common.Hiding instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Common.Relevance instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Common.Quantity instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Unquote.Unquote a => Agda.TypeChecking.Unquote.Unquote (Agda.Syntax.Reflected.Abs a) instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Unquote.Unquote a => Agda.TypeChecking.Unquote.Unquote (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Reflected.Sort instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Literal.Literal instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Reflected.Term instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Reflected.Pattern instance Agda.TypeChecking.Unquote.Unquote Agda.Syntax.Reflected.Clause module Agda.TypeChecking.Rules.Def checkFunDef :: Delayed -> DefInfo -> QName -> [Clause] -> TCM () checkMacroType :: Type -> TCM () -- | A single clause without arguments and without type signature is an -- alias. isAlias :: [Clause] -> Type -> Maybe (Expr, Maybe Expr, MetaId) -- | Check a trivial definition of the form f = e checkAlias :: Type -> ArgInfo -> Delayed -> DefInfo -> QName -> Expr -> Maybe Expr -> TCM () -- | Type check a definition by pattern matching. checkFunDef' :: Type -> ArgInfo -> Delayed -> Maybe ExtLamInfo -> Maybe QName -> DefInfo -> QName -> [Clause] -> TCM () -- | Type check a definition by pattern matching. checkFunDefS :: Type -> ArgInfo -> Delayed -> Maybe ExtLamInfo -> Maybe QName -> DefInfo -> QName -> Maybe Substitution -> [Clause] -> TCM () -- | Set funTerminates according to termination info in -- TCEnv, which comes from a possible termination pragma. useTerPragma :: Definition -> TCM Definition -- | Modify all the LHSCore of the given RHS. (Used to insert patterns for -- rewrite or the inspect idiom) mapLHSCores :: (LHSCore -> LHSCore) -> RHS -> RHS -- | Insert some names into the with-clauses LHS of the given RHS. (Used -- for the inspect idiom) insertNames :: [Arg (Maybe BindName)] -> RHS -> RHS insertInspects :: [Arg (Maybe BindName)] -> LHSCore -> LHSCore -- | Insert some with-patterns into the with-clauses LHS of the given RHS. -- (Used for rewrite) insertPatterns :: [Arg Pattern] -> RHS -> RHS -- | Insert with-patterns before the trailing with patterns. If there are -- none, append the with-patterns. insertPatternsLHSCore :: [Arg Pattern] -> LHSCore -> LHSCore -- | Parameters for creating a with-function. data WithFunctionProblem NoWithFunction :: WithFunctionProblem WithFunction :: QName -> QName -> Type -> Telescope -> Telescope -> Telescope -> [Arg (Term, EqualityView)] -> Type -> [NamedArg DeBruijnPattern] -> Nat -> Permutation -> Permutation -> Permutation -> [Clause] -> Substitution -> WithFunctionProblem -- | Parent function name. [wfParentName] :: WithFunctionProblem -> QName -- | With function name. [wfName] :: WithFunctionProblem -> QName -- | Type of the parent function. [wfParentType] :: WithFunctionProblem -> Type -- | Context of the parent patterns. [wfParentTel] :: WithFunctionProblem -> Telescope -- | Types of arguments to the with function before the with expressions -- (needed vars). [wfBeforeTel] :: WithFunctionProblem -> Telescope -- | Types of arguments to the with function after the with expressions -- (unneeded vars). [wfAfterTel] :: WithFunctionProblem -> Telescope -- | With and rewrite expressions and their types. [wfExprs] :: WithFunctionProblem -> [Arg (Term, EqualityView)] -- | Type of the right hand side. [wfRHSType] :: WithFunctionProblem -> Type -- | Parent patterns. [wfParentPats] :: WithFunctionProblem -> [NamedArg DeBruijnPattern] -- | Number of module parameters in parent patterns [wfParentParams] :: WithFunctionProblem -> Nat -- | Permutation resulting from splitting the telescope into needed and -- unneeded vars. [wfPermSplit] :: WithFunctionProblem -> Permutation -- | Permutation reordering the variables in the parent pattern. [wfPermParent] :: WithFunctionProblem -> Permutation -- | Final permutation (including permutation for the parent clause). [wfPermFinal] :: WithFunctionProblem -> Permutation -- | The given clauses for the with function [wfClauses] :: WithFunctionProblem -> [Clause] -- | Subtsitution to generate call for the parent. [wfCallSubst] :: WithFunctionProblem -> Substitution checkSystemCoverage :: QName -> [Int] -> Type -> [Clause] -> TCM System data ClausesPostChecks CPC :: IntSet -> ClausesPostChecks -- | Which argument indexes have a partial split. [cpcPartialSplits] :: ClausesPostChecks -> IntSet -- | The LHS part of checkClause. checkClauseLHS :: Type -> Maybe Substitution -> SpineClause -> (LHSResult -> TCM a) -> TCM a -- | Type check a function clause. checkClause :: Type -> Maybe Substitution -> SpineClause -> TCM (Clause, ClausesPostChecks) -- | Generate the abstract pattern corresponding to Refl getReflPattern :: TCM Pattern -- | Type check the with and rewrite lhss and/or the rhs. checkRHS :: LHSInfo -> QName -> [NamedArg Pattern] -> Type -> LHSResult -> RHS -> TCM (Maybe Term, WithFunctionProblem) checkWithRHS :: QName -> QName -> Type -> LHSResult -> [Arg (Term, EqualityView)] -> [Clause] -> TCM (Maybe Term, WithFunctionProblem) -- | Invoked in empty context. checkWithFunction :: [Name] -> WithFunctionProblem -> TCM (Maybe Term) -- | Type check a where clause. checkWhere :: WhereDeclarations -> TCM a -> TCM a -- | Enter a new section during type-checking. newSection :: ModuleName -> GeneralizeTelescope -> TCM a -> TCM a -- | Set the current clause number. atClause :: QName -> Int -> Type -> Maybe Substitution -> SpineClause -> TCM a -> TCM a instance GHC.Base.Semigroup Agda.TypeChecking.Rules.Def.ClausesPostChecks instance GHC.Base.Monoid Agda.TypeChecking.Rules.Def.ClausesPostChecks module Agda.TypeChecking.With -- | Split pattern variables according to with-expressions. splitTelForWith :: Telescope -> Type -> [Arg (Term, EqualityView)] -> (Telescope, Telescope, Permutation, Type, [Arg (Term, EqualityView)]) -- | Abstract with-expressions vs to generate type for with-helper -- function. -- -- Each EqualityType, coming from a rewrite, will turn -- into 2 abstractions. withFunctionType :: Telescope -> [Arg (Term, EqualityView)] -> Telescope -> Type -> [(Int, (Term, Term))] -> TCM (Type, Nat) countWithArgs :: [EqualityView] -> Nat -- | From a list of with and rewrite expressions and -- their types, compute the list of final with expressions -- (after expanding the rewrites). withArguments :: [Arg (Term, EqualityView)] -> TCM [Arg Term] -- | Compute the clauses for the with-function given the original patterns. buildWithFunction :: [Name] -> QName -> QName -> Type -> Telescope -> [NamedArg DeBruijnPattern] -> Nat -> Substitution -> Permutation -> Nat -> Nat -> [SpineClause] -> TCM [SpineClause] -- |
--   stripWithClausePatterns cxtNames parent f t Δ qs np π ps = ps'
--   
-- -- Example: -- --
--   record Stream (A : Set) : Set where
--     coinductive
--     constructor delay
--     field       force : A × Stream A
--   
--   record SEq (s t : Stream A) : Set where
--     coinductive
--     field
--       ~force : let a , as = force s
--                    b , bs = force t
--                in  a ≡ b × SEq as bs
--   
--   test : (s : Nat × Stream Nat) (t : Stream Nat) → SEq (delay s) t → SEq t (delay s)
--   ~force (test (a     , as) t p) with force t
--   ~force (test (suc n , as) t p) | b , bs = ?
--   
-- -- With function: -- --
--   f : (t : Stream Nat) (w : Nat × Stream Nat) (a : Nat) (as : Stream Nat)
--       (p : SEq (delay (a , as)) t) → (fst w ≡ a) × SEq (snd w) as
--   
--   Δ  = t a as p   -- reorder to bring with-relevant (= needed) vars first
--   π  = a as t p → Δ
--   qs = (a     , as) t p ~force
--   ps = (suc n , as) t p ~force
--   ps' = (suc n) as t p
--   
-- -- Resulting with-function clause is: -- --
--   f t (b , bs) (suc n) as t p
--   
-- -- Note: stripWithClausePatterns factors ps through -- qs, thus -- --
--   ps = qs[ps']
--   
-- -- where [..] is to be understood as substitution. The -- projection patterns have vanished from ps' (as they -- are already in qs). stripWithClausePatterns :: [Name] -> QName -> QName -> Type -> Telescope -> [NamedArg DeBruijnPattern] -> Nat -> Permutation -> [NamedArg Pattern] -> TCM ([ProblemEq], [NamedArg Pattern]) -- | Construct the display form for a with function. It will display -- applications of the with function as applications to the original -- function. For instance, -- --
--   aux a b c
--   
--   
-- -- as -- --
--   f (suc a) (suc b) | c
--   
--   
withDisplayForm :: QName -> QName -> Telescope -> Telescope -> Nat -> [NamedArg DeBruijnPattern] -> Permutation -> Permutation -> TCM DisplayForm patsToElims :: [NamedArg DeBruijnPattern] -> [Elim' DisplayTerm] module Agda.TypeChecking.Telescope.Path -- | In an ambient context Γ, telePiPath f lams Δ t bs builds a -- type that can be telViewPathBoundaryP'ed into (TelV Δ t, -- bs'). Γ.Δ ⊢ t bs = [(i,u_i)] Δ = Δ0,(i : I),Δ1 ∀ b ∈ {0,1}. Γ.Δ0 | -- lams Δ1 (u_i .b) : (telePiPath f Δ1 t bs)(i = b) -- kinda: see lams Γ -- ⊢ telePiPath f Δ t bs telePiPath :: (Abs Type -> Abs Type) -> ([Arg ArgName] -> Term -> Term) -> Telescope -> Type -> Boundary -> TCM Type -- | telePiPath_ Δ t [(i,u)] Δ ⊢ t i ∈ Δ Δ ⊢ u_b : t for b ∈ {0,1} telePiPath_ :: Telescope -> Type -> [(Int, (Term, Term))] -> TCM Type -- | arity of the type, including both Pi and Path. Does not reduce the -- type. arityPiPath :: Type -> TCM Int -- | Collect the interval copattern variables as list of de Bruijn indices. class IApplyVars p iApplyVars :: IApplyVars p => p -> [Int] -- | Check whether a type is the built-in interval type. isInterval :: (MonadTCM m, MonadReduce m) => Type -> m Bool instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn a => Agda.TypeChecking.Telescope.Path.IApplyVars (Agda.Syntax.Internal.Pattern' a) instance Agda.TypeChecking.Telescope.Path.IApplyVars p => Agda.TypeChecking.Telescope.Path.IApplyVars (Agda.Syntax.Common.NamedArg p) instance Agda.TypeChecking.Telescope.Path.IApplyVars p => Agda.TypeChecking.Telescope.Path.IApplyVars [p] module Agda.TypeChecking.Rules.LHS.Problem type FlexibleVars = [FlexibleVar Nat] -- | When we encounter a flexible variable in the unifier, where did it -- come from? The alternatives are ordered such that we will assign the -- higher one first, i.e., first we try to assign a DotFlex, -- then... data FlexibleVarKind -- | From a record pattern (ConP). Saves the FlexibleVarKind -- of its subpatterns. RecordFlex :: [FlexibleVarKind] -> FlexibleVarKind -- | From a hidden formal argument or underscore (WildP). ImplicitFlex :: FlexibleVarKind -- | From a dot pattern (DotP). DotFlex :: FlexibleVarKind -- | From a non-record constructor or literal (ConP or LitP). OtherFlex :: FlexibleVarKind -- | Flexible variables are equipped with information where they come from, -- in order to make a choice which one to assign when two flexibles are -- unified. data FlexibleVar a FlexibleVar :: ArgInfo -> IsForced -> FlexibleVarKind -> Maybe Int -> a -> FlexibleVar a [flexArgInfo] :: FlexibleVar a -> ArgInfo [flexForced] :: FlexibleVar a -> IsForced [flexKind] :: FlexibleVar a -> FlexibleVarKind [flexPos] :: FlexibleVar a -> Maybe Int [flexVar] :: FlexibleVar a -> a allFlexVars :: [IsForced] -> Telescope -> FlexibleVars data FlexChoice ChooseLeft :: FlexChoice ChooseRight :: FlexChoice ChooseEither :: FlexChoice ExpandBoth :: FlexChoice class ChooseFlex a chooseFlex :: ChooseFlex a => a -> a -> FlexChoice -- | A user pattern together with an internal term that it should be equal -- to after splitting is complete. Special cases: * User pattern is a -- variable but internal term isn't: this will be turned into an as -- pattern. * User pattern is a dot pattern: this pattern won't trigger -- any splitting but will be checked for equality after all splitting is -- complete and as patterns have been bound. * User pattern is an absurd -- pattern: emptiness of the type will be checked after splitting is -- complete. * User pattern is an annotated wildcard: type annotation -- will be checked after splitting is complete. data ProblemEq ProblemEq :: Pattern -> Term -> Dom Type -> ProblemEq [problemInPat] :: ProblemEq -> Pattern [problemInst] :: ProblemEq -> Term [problemType] :: ProblemEq -> Dom Type -- | The user patterns we still have to split on. data Problem a Problem :: [ProblemEq] -> [NamedArg Pattern] -> (LHSState a -> TCM a) -> Problem a -- | User patterns which are typed (including the ones generated from -- implicit arguments). [_problemEqs] :: Problem a -> [ProblemEq] -- | List of user patterns which could not yet be typed. Example: f : -- (b : Bool) -> if b then Nat else Nat -> Nat f true = zero f -- false zero = zero f false (suc n) = n In this sitation, for -- clause 2, we construct an initial problem problemEqs = [false = -- b] problemRestPats = [zero] As we instantiate b to -- false, the targetType reduces to Nat -> -- Nat and we can move pattern zero over to -- problemEqs. [_problemRestPats] :: Problem a -> [NamedArg Pattern] -- | The code that checks the RHS. [_problemCont] :: Problem a -> LHSState a -> TCM a problemEqs :: Lens' [ProblemEq] (Problem a) problemRestPats :: Lens' [NamedArg Pattern] (Problem a) problemCont :: Lens' (LHSState a -> TCM a) (Problem a) problemInPats :: Problem a -> [Pattern] data AsBinding AsB :: Name -> Term -> Type -> Modality -> AsBinding data DotPattern Dot :: Expr -> Term -> Dom Type -> DotPattern data AbsurdPattern Absurd :: Range -> Type -> AbsurdPattern data AnnotationPattern Ann :: Expr -> Type -> AnnotationPattern -- | State worked on during the main loop of checking a lhs. [Ulf Norell's -- PhD, page. 35] data LHSState a LHSState :: Telescope -> [NamedArg DeBruijnPattern] -> Problem a -> Arg Type -> ![Maybe Int] -> !Bool -> LHSState a -- | The types of the pattern variables. [_lhsTel] :: LHSState a -> Telescope -- | Patterns after splitting. The de Bruijn indices refer to positions in -- the list of abstract syntax patterns in the problem, counted from the -- back (right-to-left). [_lhsOutPat] :: LHSState a -> [NamedArg DeBruijnPattern] -- | User patterns of supposed type delta. [_lhsProblem] :: LHSState a -> Problem a -- | Type eliminated by problemRestPats in the problem. Can be -- Irrelevant to indicate that we came by an irrelevant projection -- and, hence, the rhs must be type-checked in irrelevant mode. [_lhsTarget] :: LHSState a -> Arg Type -- | have we splitted with a PartialFocus? [_lhsPartialSplit] :: LHSState a -> ![Maybe Int] -- | Have we split on any indexed inductive types? [_lhsIndexedSplit] :: LHSState a -> !Bool lhsTel :: Lens' Telescope (LHSState a) lhsOutPat :: Lens' [NamedArg DeBruijnPattern] (LHSState a) lhsProblem :: Lens' (Problem a) (LHSState a) lhsTarget :: Lens' (Arg Type) (LHSState a) data LeftoverPatterns LeftoverPatterns :: IntMap [(Name, PatVarPosition)] -> [AsBinding] -> [DotPattern] -> [AbsurdPattern] -> [AnnotationPattern] -> [Pattern] -> LeftoverPatterns [patternVariables] :: LeftoverPatterns -> IntMap [(Name, PatVarPosition)] [asPatterns] :: LeftoverPatterns -> [AsBinding] [dotPatterns] :: LeftoverPatterns -> [DotPattern] [absurdPatterns] :: LeftoverPatterns -> [AbsurdPattern] [typeAnnotations] :: LeftoverPatterns -> [AnnotationPattern] [otherPatterns] :: LeftoverPatterns -> [Pattern] -- | Classify remaining patterns after splitting is complete into pattern -- variables, as patterns, dot patterns, and absurd patterns. -- Precondition: there are no more constructor patterns. getLeftoverPatterns :: forall m. PureTCM m => [ProblemEq] -> m LeftoverPatterns -- | Build a renaming for the internal patterns using variable names from -- the user patterns. If there are multiple user names for the same -- internal variable, the unused ones are returned as as-bindings. Names -- that are not also module parameters are preferred over those that are. getUserVariableNames :: Telescope -> IntMap [(Name, PatVarPosition)] -> ([Maybe Name], [AsBinding]) instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Problem.FlexibleVarKind instance GHC.Classes.Eq Agda.TypeChecking.Rules.LHS.Problem.FlexibleVarKind instance Data.Traversable.Traversable Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar instance Data.Foldable.Foldable Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar instance GHC.Base.Functor Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Problem.FlexChoice instance GHC.Classes.Eq Agda.TypeChecking.Rules.LHS.Problem.FlexChoice instance GHC.Show.Show (Agda.TypeChecking.Rules.LHS.Problem.Problem a) instance GHC.Classes.Eq Agda.TypeChecking.Rules.LHS.Problem.PatVarPosition instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Problem.PatVarPosition instance GHC.Base.Semigroup Agda.TypeChecking.Rules.LHS.Problem.LeftoverPatterns instance Agda.Utils.Null.Null Agda.TypeChecking.Rules.LHS.Problem.LeftoverPatterns instance GHC.Base.Monoid Agda.TypeChecking.Rules.LHS.Problem.LeftoverPatterns instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.LeftoverPatterns instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Rules.LHS.Problem.PatVarPosition instance Agda.TypeChecking.Substitute.Class.Subst (Agda.TypeChecking.Rules.LHS.Problem.Problem a) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Rules.LHS.Problem.LHSState a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.AnnotationPattern instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Rules.LHS.Problem.AbsurdPattern instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.AbsurdPattern instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Rules.LHS.Problem.DotPattern instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.DotPattern instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Rules.LHS.Problem.AsBinding instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.AsBinding instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Rules.LHS.Problem.AsBinding instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Rules.LHS.Problem.AsBinding instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex Agda.TypeChecking.Rules.LHS.Problem.FlexibleVarKind instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex a => Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex [a] instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex a => Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex Agda.Syntax.Common.ArgInfo instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex Agda.TypeChecking.Monad.Base.IsForced instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex Agda.Syntax.Common.Hiding instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex Agda.Syntax.Common.Origin instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex GHC.Types.Int instance Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex a => Agda.TypeChecking.Rules.LHS.Problem.ChooseFlex (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance GHC.Base.Semigroup Agda.TypeChecking.Rules.LHS.Problem.FlexChoice instance GHC.Base.Monoid Agda.TypeChecking.Rules.LHS.Problem.FlexChoice instance Agda.Syntax.Common.LensArgInfo (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance Agda.Syntax.Common.LensHiding (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance Agda.Syntax.Common.LensOrigin (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance Agda.Syntax.Common.LensModality (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a) instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.ProblemEq module Agda.TypeChecking.Rules.LHS.Implicit implicitP :: ArgInfo -> NamedArg Pattern -- | Insert implicit patterns in a list of patterns. Even if -- DontExpandLast, trailing SIZELT patterns are inserted. insertImplicitPatterns :: (PureTCM m, MonadError TCErr m, MonadFresh NameId m, MonadTrace m) => ExpandHidden -> [NamedArg Pattern] -> Telescope -> m [NamedArg Pattern] -- | Insert trailing SizeLt patterns, if any. insertImplicitSizeLtPatterns :: PureTCM m => Type -> m [NamedArg Pattern] -- | Insert implicit patterns in a list of patterns. Even if -- DontExpandLast, trailing SIZELT patterns are inserted. insertImplicitPatternsT :: (PureTCM m, MonadError TCErr m, MonadFresh NameId m, MonadTrace m) => ExpandHidden -> [NamedArg Pattern] -> Type -> m [NamedArg Pattern] -- | Functions for inserting implicit arguments at the right places. module Agda.TypeChecking.Implicit -- | Insert implicit binders in a list of binders, but not at the end. insertImplicitBindersT :: (PureTCM m, MonadError TCErr m, MonadFresh NameId m, MonadTrace m) => [NamedArg Binder] -> Type -> m [NamedArg Binder] -- | Insert implicit binders in a list of binders, but not at the end. insertImplicitBindersT1 :: (PureTCM m, MonadError TCErr m, MonadFresh NameId m, MonadTrace m) => List1 (NamedArg Binder) -> Type -> m (List1 (NamedArg Binder)) -- | implicitArgs n expand t generates up to n implicit -- argument metas (unbounded if n<0), as long as t -- is a function type and expand holds on the hiding info of its -- domain. implicitArgs :: (PureTCM m, MonadMetaSolver m, MonadTCM m) => Int -> (Hiding -> Bool) -> Type -> m (Args, Type) -- | implicitNamedArgs n expand t generates up to n named -- implicit arguments metas (unbounded if n<0), as long as -- t is a function type and expand holds on the hiding -- and name info of its domain. implicitNamedArgs :: (PureTCM m, MonadMetaSolver m, MonadTCM m) => Int -> (Hiding -> ArgName -> Bool) -> Type -> m (NamedArgs, Type) -- | Create a metavariable according to the Hiding info. newMetaArg :: (PureTCM m, MonadMetaSolver m) => ArgInfo -> ArgName -> Comparison -> Type -> m (MetaId, Term) -- | Create a questionmark according to the Hiding info. newInteractionMetaArg :: ArgInfo -> ArgName -> Comparison -> Type -> TCM (MetaId, Term) -- | Possible results of insertImplicit. data ImplicitInsertion -- | Success: this many implicits have to be inserted (list can be empty). ImpInsert :: [Dom ()] -> ImplicitInsertion -- | Error: hidden argument where there should have been a non-hidden -- argument. BadImplicits :: ImplicitInsertion -- | Error: bad named argument. NoSuchName :: ArgName -> ImplicitInsertion pattern NoInsertNeeded :: ImplicitInsertion -- | If the next given argument is a and the expected arguments -- are ts insertImplicit' a ts returns the prefix of -- ts that precedes a. -- -- If a is named but this name does not appear in ts, -- the NoSuchName exception is thrown. insertImplicit :: NamedArg e -> [Dom a] -> ImplicitInsertion -- | If the next given argument is a and the expected arguments -- are ts insertImplicit' a ts returns the prefix of -- ts that precedes a. -- -- If a is named but this name does not appear in ts, -- the NoSuchName exception is thrown. insertImplicit' :: NamedArg e -> [Dom ArgName] -> ImplicitInsertion instance GHC.Show.Show Agda.TypeChecking.Implicit.ImplicitInsertion -- | Compile-time irrelevance. -- -- In type theory with compile-time irrelevance à la Pfenning (LiCS -- 2001), variables in the context are annotated with relevance -- attributes. @ Γ = r₁x₁:A₁, ..., rⱼxⱼ:Aⱼ To handle -- irrelevant projections, we also record the current relevance attribute -- in the judgement. For instance, this attribute is equal to to -- Irrelevant if we are in an irrelevant position, like an -- irrelevant argument. Γ ⊢r t : A Only relevant -- variables can be used: @ -- -- (Relevant x : A) ∈ Γ -------------------- Γ ⊢r x : A @ Irrelevant -- global declarations can only be used if r = Irrelevant@. -- -- When we enter a r'-relevant function argument, we compose the -- r with r' and (left-)divide the attributes in the -- context by r'. @ Γ ⊢r t : (r' x : A) → B r' Γ ⊢(r'·r) u : -- A --------------------------------------------------------- Γ ⊢r t u : -- B[u/x] No surprises for abstraction: @ -- -- Γ, (r' x : A) ⊢r : B ----------------------------- Γ ⊢r λxt : (r' x : -- A) → B @@ -- -- This is different for runtime irrelevance (erasure) which is -- `flat', meaning that once one is in an irrelevant context, -- all new assumptions will be usable, since they are turned relevant -- once entering the context. See Conor McBride (WadlerFest 2016), for a -- type system in this spirit: -- -- We use such a rule for runtime-irrelevance: @ Γ, (q q') x : A ⊢q t -- : B ------------------------------ Γ ⊢q λxt : (q' x : A) → B @ -- -- Conor's system is however set up differently, with a very different -- variable rule: -- -- @@ -- -- (q x : A) ∈ Γ -------------- Γ ⊢q x : A -- -- Γ, (q·p) x : A ⊢q t : B ----------------------------- Γ ⊢q λxt : (p x -- : A) → B -- -- Γ ⊢q t : (p x : A) → B Γ' ⊢qp u : A -- ------------------------------------------------- Γ + Γ' ⊢q t u : -- B[u/x] @@ module Agda.TypeChecking.Irrelevance -- | Prepare parts of a parameter telescope for abstraction in constructors -- and projections. hideAndRelParams :: (LensHiding a, LensRelevance a) => a -> a -- | Modify the context whenever going from the l.h.s. (term side) of the -- typing judgement to the r.h.s. (type side). workOnTypes :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a -- | Internal workhorse, expects value of --experimental-irrelevance flag -- as argument. workOnTypes' :: MonadTCEnv m => Bool -> m a -> m a -- | (Conditionally) wake up irrelevant variables and make them relevant. -- For instance, in an irrelevant function argument otherwise irrelevant -- variables may be used, so they are awoken before type checking the -- argument. -- -- Also allow the use of irrelevant definitions. applyRelevanceToContext :: (MonadTCEnv tcm, LensRelevance r) => r -> tcm a -> tcm a -- | (Conditionally) wake up irrelevant variables and make them relevant. -- For instance, in an irrelevant function argument otherwise irrelevant -- variables may be used, so they are awoken before type checking the -- argument. -- -- Precondition: Relevance /= Relevant applyRelevanceToContextOnly :: MonadTCEnv tcm => Relevance -> tcm a -> tcm a -- | Apply relevance rel the the relevance annotation of the -- (typing/equality) judgement. This is part of the work done when going -- into a rel-context. -- -- Precondition: Relevance /= Relevant applyRelevanceToJudgementOnly :: MonadTCEnv tcm => Relevance -> tcm a -> tcm a -- | Like applyRelevanceToContext, but only act on context if -- --irrelevant-projections. See issue #2170. applyRelevanceToContextFunBody :: (MonadTCM tcm, LensRelevance r) => r -> tcm a -> tcm a -- | Sets the current quantity (unless the given quantity is 1). applyQuantityToContext :: (MonadTCEnv tcm, LensQuantity q) => q -> tcm a -> tcm a -- | Apply quantity q the the quantity annotation of the -- (typing/equality) judgement. This is part of the work done when going -- into a q-context. -- -- Precondition: Quantity /= Quantity1 applyQuantityToJudgementOnly :: MonadTCEnv tcm => Quantity -> tcm a -> tcm a -- | Apply inverse composition with the given cohesion to the typing -- context. applyCohesionToContext :: (MonadTCEnv tcm, LensCohesion m) => m -> tcm a -> tcm a applyCohesionToContextOnly :: MonadTCEnv tcm => Cohesion -> tcm a -> tcm a -- | Can we split on arguments of the given cohesion? splittableCohesion :: (HasOptions m, LensCohesion a) => a -> m Bool -- | (Conditionally) wake up irrelevant variables and make them relevant. -- For instance, in an irrelevant function argument otherwise irrelevant -- variables may be used, so they are awoken before type checking the -- argument. -- -- Also allow the use of irrelevant definitions. -- -- This function might also do something for other modalities. applyModalityToContext :: (MonadTCEnv tcm, LensModality m) => m -> tcm a -> tcm a -- | (Conditionally) wake up irrelevant variables and make them relevant. -- For instance, in an irrelevant function argument otherwise irrelevant -- variables may be used, so they are awoken before type checking the -- argument. -- -- This function might also do something for other modalities, but not -- for quantities. -- -- Precondition: Modality /= Relevant applyModalityToContextOnly :: MonadTCEnv tcm => Modality -> tcm a -> tcm a -- | Apply modality m the the modality annotation of the -- (typing/equality) judgement. This is part of the work done when going -- into a m-context. -- -- Precondition: Modality /= Relevant applyModalityToJudgementOnly :: MonadTCEnv tcm => Modality -> tcm a -> tcm a -- | Like applyModalityToContext, but only act on context (for -- Relevance) if --irrelevant-projections. See issue #2170. applyModalityToContextFunBody :: (MonadTCM tcm, LensModality r) => r -> tcm a -> tcm a -- | Wake up irrelevant variables and make them relevant. This is used when -- type checking terms in a hole, in which case you want to be able to -- (for instance) infer the type of an irrelevant variable. In the course -- of type checking an irrelevant function argument -- applyRelevanceToContext is used instead, which also sets the -- context relevance to Irrelevant. This is not the right thing to -- do when type checking interactively in a hole since it also marks all -- metas created during type checking as irrelevant (issue #2568). -- -- Also set the current quantity to 0. wakeIrrelevantVars :: MonadTCEnv tcm => tcm a -> tcm a -- | Check whether something can be used in a position of the given -- relevance. -- -- This is a substitute for double-checking that only makes sure -- relevances are correct. See issue #2640. -- -- Used in unifier ( unifyStep Solution{}). -- -- At the moment, this implements McBride-style irrelevance, where -- Pfenning-style would be the most accurate thing. However, these two -- notions only differ how they handle bound variables in a term. Here, -- we are only concerned in the free variables, used meta-variables, and -- used (irrelevant) definitions. class UsableRelevance a usableRel :: (UsableRelevance a, ReadTCState m, HasConstInfo m, MonadTCEnv m, MonadAddContext m, MonadDebug m) => Relevance -> a -> m Bool -- | Check whether something can be used in a position of the given -- modality. -- -- This is a substitute for double-checking that only makes sure -- modalities are correct. See issue #2640. -- -- Used in unifier ( unifyStep Solution{}). -- -- This uses McBride-style modality checking. It does not differ from -- Pfenning-style if we are only interested in the modality of the free -- variables, used meta-variables, and used definitions. class UsableModality a usableMod :: (UsableModality a, ReadTCState m, HasConstInfo m, MonadTCEnv m, MonadAddContext m, MonadDebug m, MonadReduce m, MonadError Blocker m) => Modality -> a -> m Bool usableModAbs :: (Subst a, MonadAddContext m, UsableModality a, ReadTCState m, HasConstInfo m, MonadReduce m, MonadError Blocker m) => ArgInfo -> Modality -> Abs a -> m Bool usableAtModality' :: MonadConstraint TCM => Maybe Sort -> WhyCheckModality -> Modality -> Term -> TCM () usableAtModality :: MonadConstraint TCM => WhyCheckModality -> Modality -> Term -> TCM () -- | Is a type a proposition? (Needs reduction.) isPropM :: (LensSort a, PrettyTCM a, PureTCM m, MonadBlock m) => a -> m Bool isIrrelevantOrPropM :: (LensRelevance a, LensSort a, PrettyTCM a, PureTCM m, MonadBlock m) => a -> m Bool -- | Is a type fibrant (i.e. Type, Prop)? isFibrant :: (LensSort a, PureTCM m, MonadBlock m) => a -> m Bool -- | Cofibrant types are those that could be the domain of a fibrant pi -- type. (Notion by C. Sattler). isCoFibrantSort :: (LensSort a, PureTCM m, MonadBlock m) => a -> m Bool instance Agda.TypeChecking.Irrelevance.UsableModality Agda.Syntax.Internal.Term instance Agda.TypeChecking.Irrelevance.UsableRelevance a => Agda.TypeChecking.Irrelevance.UsableModality (Agda.Syntax.Internal.Type' a) instance Agda.TypeChecking.Irrelevance.UsableModality Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Irrelevance.UsableModality Agda.Syntax.Internal.Level instance Agda.TypeChecking.Irrelevance.UsableModality a => Agda.TypeChecking.Irrelevance.UsableModality [a] instance (Agda.TypeChecking.Irrelevance.UsableModality a, Agda.TypeChecking.Irrelevance.UsableModality b) => Agda.TypeChecking.Irrelevance.UsableModality (a, b) instance Agda.TypeChecking.Irrelevance.UsableModality a => Agda.TypeChecking.Irrelevance.UsableModality (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Irrelevance.UsableModality a => Agda.TypeChecking.Irrelevance.UsableModality (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Irrelevance.UsableModality a => Agda.TypeChecking.Irrelevance.UsableModality (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Irrelevance.UsableRelevance Agda.Syntax.Internal.Term instance Agda.TypeChecking.Irrelevance.UsableRelevance a => Agda.TypeChecking.Irrelevance.UsableRelevance (Agda.Syntax.Internal.Type' a) instance Agda.TypeChecking.Irrelevance.UsableRelevance Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Irrelevance.UsableRelevance Agda.Syntax.Internal.Level instance Agda.TypeChecking.Irrelevance.UsableRelevance Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Irrelevance.UsableRelevance a => Agda.TypeChecking.Irrelevance.UsableRelevance [a] instance (Agda.TypeChecking.Irrelevance.UsableRelevance a, Agda.TypeChecking.Irrelevance.UsableRelevance b) => Agda.TypeChecking.Irrelevance.UsableRelevance (a, b) instance (Agda.TypeChecking.Irrelevance.UsableRelevance a, Agda.TypeChecking.Irrelevance.UsableRelevance b, Agda.TypeChecking.Irrelevance.UsableRelevance c) => Agda.TypeChecking.Irrelevance.UsableRelevance (a, b, c) instance Agda.TypeChecking.Irrelevance.UsableRelevance a => Agda.TypeChecking.Irrelevance.UsableRelevance (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Irrelevance.UsableRelevance a => Agda.TypeChecking.Irrelevance.UsableRelevance (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Irrelevance.UsableRelevance a => Agda.TypeChecking.Irrelevance.UsableRelevance (Agda.Syntax.Internal.Dom a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Irrelevance.UsableRelevance a) => Agda.TypeChecking.Irrelevance.UsableRelevance (Agda.Syntax.Internal.Abs a) -- | Tools to manipulate patterns in abstract syntax in the TCM (type -- checking monad). module Agda.TypeChecking.Patterns.Abstract -- | Expand literal integer pattern into suc/zero constructor patterns. expandLitPattern :: (MonadError TCErr m, MonadTCEnv m, ReadTCState m, HasBuiltins m) => Pattern -> m Pattern -- | Expand away (deeply) all pattern synonyms in a pattern. expandPatternSynonyms' :: forall e. Pattern' e -> TCM (Pattern' e) class ExpandPatternSynonyms a expandPatternSynonyms :: ExpandPatternSynonyms a => a -> TCM a expandPatternSynonyms :: (ExpandPatternSynonyms a, Traversable f, ExpandPatternSynonyms b, f b ~ a) => a -> TCM a instance Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms a => Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms a => Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms [a] instance Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms a => Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms a => Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms (Agda.Syntax.Common.Named n a) instance Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms a => Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms (Agda.Syntax.Concrete.FieldAssignment' a) instance Agda.TypeChecking.Patterns.Abstract.ExpandPatternSynonyms (Agda.Syntax.Abstract.Pattern' e) -- | Compute eta short normal forms. module Agda.TypeChecking.EtaContract data BinAppView App :: Term -> Arg Term -> BinAppView NoApp :: Term -> BinAppView binAppView :: Term -> BinAppView -- | Contracts all eta-redexes it sees without reducing. etaContract :: (MonadTCEnv m, HasConstInfo m, HasOptions m, TermLike a) => a -> m a etaOnce :: (MonadTCEnv m, HasConstInfo m, HasOptions m) => Term -> m Term -- | If record constructor, call eta-contraction function. etaCon :: (MonadTCEnv m, HasConstInfo m, HasOptions m) => ConHead -> ConInfo -> Elims -> (QName -> ConHead -> ConInfo -> Args -> m Term) -> m Term -- | Try to contract a lambda-abstraction Lam i (Abs x b). etaLam :: (MonadTCEnv m, HasConstInfo m, HasOptions m) => ArgInfo -> ArgName -> Term -> m Term -- | Functions for abstracting terms over other terms. module Agda.TypeChecking.Abstract -- | abstractType a v b[v] = b where a : v. abstractType :: Type -> Term -> Type -> TCM Type -- | piAbstractTerm NotHidden v a b[v] = (w : a) -> b[w] -- piAbstractTerm Hidden v a b[v] = {w : a} -> b[w] piAbstractTerm :: ArgInfo -> Term -> Type -> Type -> TCM Type -- |
--   piAbstract (v, a) b[v] = (w : a) -> b[w]
--   
-- -- For the inspect idiom, it does something special: @piAbstract (v, a) -- b[v] = (w : a) {w' : Eq a w v} -> b[w] -- -- For rewrite, it does something special: piAbstract (prf, -- Eq a v v') b[v,prf] = (w : a) (w' : Eq a w v') -> b[w,w'] piAbstract :: Arg (Term, EqualityView) -> Type -> TCM Type -- | isPrefixOf u v = Just es if v == u applyE es. class IsPrefixOf a isPrefixOf :: IsPrefixOf a => a -> a -> Maybe Elims abstractTerm :: Type -> Term -> Type -> Term -> TCM Term class AbsTerm a -- |
--   subst u . absTerm u == id
--   
absTerm :: AbsTerm a => Term -> a -> a -- | This swaps var 0 and var 1. swap01 :: TermSubst a => a -> a class EqualSy a equalSy :: EqualSy a => a -> a -> Bool instance Agda.TypeChecking.Abstract.IsPrefixOf Agda.Syntax.Internal.Elims instance Agda.TypeChecking.Abstract.IsPrefixOf Agda.Syntax.Internal.Args instance Agda.TypeChecking.Abstract.IsPrefixOf Agda.Syntax.Internal.Term instance Agda.TypeChecking.Abstract.EqualSy a => Agda.TypeChecking.Abstract.EqualSy [a] instance Agda.TypeChecking.Abstract.EqualSy Agda.Syntax.Internal.Term instance Agda.TypeChecking.Abstract.EqualSy Agda.Syntax.Internal.Level instance Agda.TypeChecking.Abstract.EqualSy Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Abstract.EqualSy Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Abstract.EqualSy Agda.Syntax.Internal.Type instance Agda.TypeChecking.Abstract.EqualSy a => Agda.TypeChecking.Abstract.EqualSy (Agda.Syntax.Internal.Elim.Elim' a) instance (Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Abstract.EqualSy a) => Agda.TypeChecking.Abstract.EqualSy (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Abstract.EqualSy Agda.Syntax.Common.ArgInfo instance Agda.TypeChecking.Abstract.EqualSy a => Agda.TypeChecking.Abstract.EqualSy (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Abstract.EqualSy a => Agda.TypeChecking.Abstract.EqualSy (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Abstract.AbsTerm Agda.Syntax.Internal.Term instance Agda.TypeChecking.Abstract.AbsTerm Agda.Syntax.Internal.Type instance Agda.TypeChecking.Abstract.AbsTerm Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Abstract.AbsTerm Agda.Syntax.Internal.Level instance Agda.TypeChecking.Abstract.AbsTerm Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Abstract.AbsTerm a => Agda.TypeChecking.Abstract.AbsTerm (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Abstract.AbsTerm a => Agda.TypeChecking.Abstract.AbsTerm (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Abstract.AbsTerm a => Agda.TypeChecking.Abstract.AbsTerm (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Abstract.AbsTerm a => Agda.TypeChecking.Abstract.AbsTerm [a] instance Agda.TypeChecking.Abstract.AbsTerm a => Agda.TypeChecking.Abstract.AbsTerm (GHC.Maybe.Maybe a) instance (Agda.TypeChecking.Substitute.Class.TermSubst a, Agda.TypeChecking.Abstract.AbsTerm a) => Agda.TypeChecking.Abstract.AbsTerm (Agda.Syntax.Internal.Abs a) instance (Agda.TypeChecking.Abstract.AbsTerm a, Agda.TypeChecking.Abstract.AbsTerm b) => Agda.TypeChecking.Abstract.AbsTerm (a, b) -- | A bidirectional type checker for internal syntax. -- -- Performs checking on unreduced terms. With the exception that -- projection-like function applications have to be reduced since they -- break bidirectionality. module Agda.TypeChecking.CheckInternal type MonadCheckInternal m = MonadConversion m -- | Entry point for e.g. checking WithFunctionType. checkType :: MonadCheckInternal m => Type -> m () -- | Check a type and infer its sort. -- -- Necessary because of PTS rule (SizeUniv, Set i, Set i) but -- SizeUniv is not included in any Set i. -- -- This algorithm follows Abel, Coquand, Dybjer, MPC 08, Verifying a -- Semantic βη-Conversion Test for Martin-Löf Type Theory checkType' :: MonadCheckInternal m => Type -> m Sort -- | Check if sort is well-formed. checkSort :: MonadCheckInternal m => Action m -> Sort -> m Sort -- | Entry point for term checking. checkInternal :: MonadCheckInternal m => Term -> Comparison -> Type -> m () checkInternal' :: MonadCheckInternal m => Action m -> Term -> Comparison -> Type -> m Term checkInternalType' :: MonadCheckInternal m => Action m -> Type -> m Type -- | checkInternal traverses the whole Term, and we can use -- this traversal to modify the term. data Action m Action :: (Type -> Term -> m Term) -> (Type -> Term -> m Term) -> (Modality -> Modality -> Modality) -> (Term -> m Term) -> Action m -- | Called on each subterm before the checker runs. [preAction] :: Action m -> Type -> Term -> m Term -- | Called on each subterm after the type checking. [postAction] :: Action m -> Type -> Term -> m Term -- | Called for each ArgInfo. The first Modality is from -- the type, the second from the term. [modalityAction] :: Action m -> Modality -> Modality -> Modality -- | Called for bringing projection-like funs in post-fix form [elimViewAction] :: Action m -> Term -> m Term -- | The default action is to not change the Term at all. defaultAction :: PureTCM m => Action m eraseUnusedAction :: Action TCM -- | Infer type of a neutral term. infer :: MonadCheckInternal m => Term -> m Type -- | Returns both the real term (first) and the transformed term (second). -- The transformed term is not necessarily a valid term, so it must not -- be used in types. inferSpine' :: MonadCheckInternal m => Action m -> Type -> Term -> Term -> Elims -> m ((Term, Term), Type) -- | Result is in reduced form. shouldBeSort :: (PureTCM m, MonadBlock m, MonadError TCErr m) => Type -> m Sort -- | Solving size constraints under hypotheses. -- -- The size solver proceeds as follows: -- --
    --
  1. Get size constraints, cluster into connected components.
  2. --
-- -- All size constraints that mention the same metas go into the same -- cluster. Each cluster can be solved by itself. -- -- Constraints that do not fit our format are ignored. We check whether -- our computed solution fulfills them as well in the last step. -- --
    --
  1. Find a joint context for each cluster.
  2. --
-- -- Each constraint comes with its own typing context, which contains size -- hypotheses j : Size< i. We need to find a common super -- context in which all constraints of a cluster live, and raise all -- constraints to this context. -- -- There might not be a common super context. Then we are screwed, since -- our solver is not ready to deal with such a situation. We will -- blatantly refuse to solve this cluster and blame it on the user. -- --
    --
  1. Convert the joint context into a hypothesis graph.
  2. --
-- -- This is straightforward. Each de Bruijn index becomes a rigid -- variable, each typing assumption j : Size< i becomes an -- arc. -- --
    --
  1. Convert the constraints into a constraint graph.
  2. --
-- -- Here we need to convert MetaVs into flexible variables. -- --
    --
  1. Run the solver
  2. --
  3. Convert the solution into meta instantiations.
  4. --
  5. Double-check whether the constraints are solved.
  6. --
module Agda.TypeChecking.SizedTypes.Solve type CC = ProblemConstraint -- | Flag to control the behavior of size solver. data DefaultToInfty -- | Instantiate all unconstrained size variables to ∞. DefaultToInfty :: DefaultToInfty -- | Leave unconstrained size variables unsolved. DontDefaultToInfty :: DefaultToInfty -- | Solve size constraints involving hypotheses. solveSizeConstraints :: DefaultToInfty -> TCM () -- | TODO: this does not actually work! -- -- We would like to use a constraint c created in context -- Δ from module N in the current context Γ -- and current module M. -- -- Δ is module tel Δ₁ of N extended by some -- local bindings Δ₂. Γ is the current context. The -- module parameter substitution from current M to N be -- Γ ⊢ σ : Δ₁. -- -- If M == N, we do not need the parameter substitution. We try -- raising. -- -- We first strengthen Δ ⊢ c to live in Δ₁ and obtain -- c₁ = strengthen Δ₂ c. We then transport c₁ to -- Γ and obtain c₂ = applySubst σ c₁. -- -- This works for different modules, but if M == N we should not -- strengthen and then weaken, because strengthening is a partial -- operation. We should rather lift the substitution σ by -- Δ₂ and then raise by Γ₂ - Δ₂. This "raising" might -- be a strengthening if Γ₂ is shorter than Δ₂. -- -- (TODO: If the module substitution does not exist, because N -- is not a parent of M, we cannot use the constraint, as it has -- been created in an unrelated context.) castConstraintToCurrentContext' :: Closure Constraint -> MaybeT TCM Constraint -- | A hazardous hack, may the Gods have mercy on us. -- -- To cast to the current context, we match the context of the given -- constraint by CtxId, and as fallback, by variable name -- (douh!). -- -- This hack lets issue 2046 go through. castConstraintToCurrentContext :: ProblemConstraint -> MaybeT TCM ProblemConstraint -- | Return the size metas occurring in the simplified constraints. A -- constraint like ↑ _j =< ∞ : Size simplifies to nothing, so -- _j would not be in this set. solveSizeConstraints_ :: DefaultToInfty -> [CC] -> TCM (Set MetaId) -- | Solve a cluster of constraints sharing some metas. solveCluster :: DefaultToInfty -> List1 (CC, HypSizeConstraint) -> TCM () -- | Collect constraints from a typing context, looking for SIZELT -- hypotheses. getSizeHypotheses :: Context -> TCM [(Nat, SizeConstraint)] -- | Convert size constraint into form where each meta is applied to -- indices n-1,...,1,0 where n is the arity of that -- meta. -- -- X[σ] <= t becomes X[id] <= t[σ^-1] -- -- X[σ] ≤ Y[τ] becomes X[id] ≤ Y[τ[σ^-1]] or -- X[σ[τ^1]] ≤ Y[id] whichever is defined. If none is defined, -- we give up. -- -- Cf. SizedTypes.oldCanonicalizeSizeConstraint. -- -- Fixes (the rather artificial) issue 300. But it is unsound when pruned -- metas occur and triggers issue 1914. Thus we deactivate it. This needs -- to be properly implemented, possibly using the metaPermuatation of -- each meta variable. canonicalizeSizeConstraint :: SizeConstraint -> Maybe SizeConstraint -- | Identifiers for rigid variables. data NamedRigid NamedRigid :: String -> Int -> NamedRigid -- | Name for printing in debug messages. [rigidName] :: NamedRigid -> String -- | De Bruijn index. [rigidIndex] :: NamedRigid -> Int -- | Size metas in size expressions. data SizeMeta SizeMeta :: MetaId -> [Int] -> SizeMeta [sizeMetaId] :: SizeMeta -> MetaId -- | De Bruijn indices. [sizeMetaArgs] :: SizeMeta -> [Int] -- | Size expression with de Bruijn indices. type DBSizeExpr = SizeExpr' NamedRigid SizeMeta type SizeConstraint = Constraint' NamedRigid SizeMeta -- | Size constraint with de Bruijn indices. data HypSizeConstraint HypSizeConstraint :: Context -> [Nat] -> [SizeConstraint] -> SizeConstraint -> HypSizeConstraint [sizeContext] :: HypSizeConstraint -> Context -- | DeBruijn indices [sizeHypIds] :: HypSizeConstraint -> [Nat] -- | Living in Context. [sizeHypotheses] :: HypSizeConstraint -> [SizeConstraint] -- | Living in Context. [sizeConstraint] :: HypSizeConstraint -> SizeConstraint -- | Turn a constraint over de Bruijn indices into a size constraint. computeSizeConstraint :: ProblemConstraint -> TCM (Maybe HypSizeConstraint) -- | Turn a term into a size expression. -- -- Returns Nothing if the term isn't a proper size expression. sizeExpr :: Term -> TCM (Maybe DBSizeExpr) -- | Turn a de size expression into a term. unSizeExpr :: HasBuiltins m => DBSizeExpr -> m Term instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Solve.DefaultToInfty instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Solve.DefaultToInfty instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Solve.DefaultToInfty instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Solve.NamedRigid instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Solve.SizeMeta instance Agda.TypeChecking.SizedTypes.Syntax.Flexs Agda.TypeChecking.SizedTypes.Solve.HypSizeConstraint instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.SizedTypes.Solve.HypSizeConstraint instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.SizedTypes.Solve.SizeConstraint instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.SizedTypes.Solve.SizeConstraint instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Solve.SizeMeta instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Solve.SizeMeta instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Solve.SizeMeta instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.SizedTypes.Solve.SizeMeta instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.SizedTypes.Solve.SizeMeta instance Agda.TypeChecking.Substitute.Class.Subst (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' Agda.TypeChecking.SizedTypes.Solve.NamedRigid Agda.TypeChecking.SizedTypes.Solve.SizeMeta) instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Solve.NamedRigid instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Solve.NamedRigid instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Solve.NamedRigid instance Agda.TypeChecking.SizedTypes.Utils.Plus Agda.TypeChecking.SizedTypes.Solve.NamedRigid GHC.Types.Int Agda.TypeChecking.SizedTypes.Solve.NamedRigid module Agda.TypeChecking.SizedTypes.WarshallSolver type Graph r f a = Graph (Node r f) a type Edge' r f a = Edge (Node r f) a type Key r f = Edge' r f () type Nodes r f = Nodes (Node r f) type LabelledEdge r f = Edge' r f Label src :: Edge n e -> n dest :: Edge n e -> n lookupEdge :: Ord n => Graph n e -> n -> n -> Maybe e graphToList :: Graph n e -> [Edge n e] graphFromList :: Ord n => [Edge n e] -> Graph n e insertEdge :: (Ord n, MeetSemiLattice e, Top e) => Edge n e -> Graph n e -> Graph n e -- | Compute list of edges that start in a given node. outgoing :: (Ord r, Ord f) => Graph r f a -> Node r f -> [Edge' r f a] -- | Compute list of edges that target a given node. -- -- Note: expensive for unidirectional graph representations. incoming :: (Ord r, Ord f) => Graph r f a -> Node r f -> [Edge' r f a] -- | Set.foldl does not exist in legacy versions of the -- containers package. setFoldl :: (b -> a -> b) -> b -> Set a -> b -- | Floyd-Warshall algorithm. transClos :: forall n a. (Ord n, Dioid a) => Graph n a -> Graph n a data Weight Offset :: Offset -> Weight Infinity :: Weight -- | Test for negativity, used to detect negative cycles. class Negative a negative :: Negative a => a -> Bool -- | Going from Lt to Le is pred, going from -- Le to Lt is succ. -- -- X --(R,n)--> Y means X (R) Y + n. [ ... if -- n positive and X + (-n) (R) Y if n -- negative. ] data Label Label :: Cmp -> Offset -> Label [lcmp] :: Label -> Cmp [loffset] :: Label -> Offset -- | Nodes not connected. LInf :: Label -- | Convert a label to a weight, decrementing in case of Lt. toWeight :: Label -> Weight data Node rigid flex NodeZero :: Node rigid flex NodeInfty :: Node rigid flex NodeRigid :: rigid -> Node rigid flex NodeFlex :: flex -> Node rigid flex isFlexNode :: Node rigid flex -> Maybe flex isZeroNode :: Node rigid flex -> Bool isInftyNode :: Node rigid flex -> Bool nodeToSizeExpr :: Node rigid flex -> SizeExpr' rigid flex -- | A graph forest. type Graphs r f a = [Graph r f a] emptyGraphs :: Graphs r f a -- | Split a list of graphs gs into those that mention node -- n and those that do not. If n is zero or infinity, -- we regard it as "not mentioned". mentions :: (Ord r, Ord f) => Node r f -> Graphs r f a -> (Graphs r f a, Graphs r f a) -- | Add an edge to a graph forest. Graphs that share a node with the edge -- are joined. addEdge :: (Ord r, Ord f, MeetSemiLattice a, Top a) => Edge' r f a -> Graphs r f a -> Graphs r f a -- | Reflexive closure. Add edges 0 -> n -> n -> oo for -- all nodes n. reflClos :: (Ord r, Ord f, Dioid a) => Set (Node r f) -> Graph r f a -> Graph r f a -- | h implies g if any edge in g between rigids -- and constants is implied by a corresponding edge in h, which -- means that the edge in g carries at most the information of -- the one in h. -- -- Application: Constraint implication: Constraints are compatible with -- hypotheses. implies :: (Ord r, Ord f, Pretty r, Pretty f, Pretty a, Top a, Ord a, Negative a) => Graph r f a -> Graph r f a -> Bool nodeFromSizeExpr :: SizeExpr' rigid flex -> (Node rigid flex, Offset) edgeFromConstraint :: Constraint' rigid flex -> LabelledEdge rigid flex -- | Build a graph from list of simplified constraints. graphFromConstraints :: (Ord rigid, Ord flex) => [Constraint' rigid flex] -> Graph rigid flex Label -- | Build a graph from list of simplified constraints. graphsFromConstraints :: (Ord rigid, Ord flex) => [Constraint' rigid flex] -> Graphs rigid flex Label type Hyp = Constraint type Hyp' = Constraint' type HypGraph r f = Graph r f Label hypGraph :: (Ord rigid, Ord flex, Pretty rigid, Pretty flex) => Set rigid -> [Hyp' rigid flex] -> Either Error (HypGraph rigid flex) hypConn :: (Ord r, Ord f) => HypGraph r f -> Node r f -> Node r f -> Label simplifyWithHypotheses :: (Ord rigid, Ord flex, Pretty rigid, Pretty flex) => HypGraph rigid flex -> [Constraint' rigid flex] -> Either Error [Constraint' rigid flex] type ConGraph r f = Graph r f Label constraintGraph :: (Ord r, Ord f, Pretty r, Pretty f) => [Constraint' r f] -> HypGraph r f -> Either Error (ConGraph r f) type ConGraphs r f = Graphs r f Label constraintGraphs :: (Ord r, Ord f, Pretty r, Pretty f) => [Constraint' r f] -> HypGraph r f -> Either Error ([f], ConGraphs r f) -- | If we have an edge X + n <= X (with n >= 0), we must -- set X = oo. infinityFlexs :: (Ord r, Ord f) => ConGraph r f -> ([f], ConGraph r f) class SetToInfty f a setToInfty :: SetToInfty f a => [f] -> a -> a -- | Lower or upper bound for a flexible variable type Bound r f = Map f (Set (SizeExpr' r f)) emptyBound :: Bound r f data Bounds r f Bounds :: Bound r f -> Bound r f -> Set f -> Bounds r f [lowerBounds] :: Bounds r f -> Bound r f [upperBounds] :: Bounds r f -> Bound r f -- | These metas are < ∞. [mustBeFinite] :: Bounds r f -> Set f -- | Compute a lower bound for a flexible from an edge. edgeToLowerBound :: LabelledEdge r f -> Maybe (f, SizeExpr' r f) -- | Compute an upper bound for a flexible from an edge. edgeToUpperBound :: LabelledEdge r f -> Maybe (f, Cmp, SizeExpr' r f) -- | Compute the lower bounds for all flexibles in a graph. graphToLowerBounds :: (Ord r, Ord f) => [LabelledEdge r f] -> Bound r f -- | Compute the upper bounds for all flexibles in a graph. graphToUpperBounds :: (Ord r, Ord f) => [LabelledEdge r f] -> (Bound r f, Set f) -- | Compute the bounds for all flexibles in a graph. bounds :: (Ord r, Ord f) => ConGraph r f -> Bounds r f -- | Compute the relative minima in a set of nodes (those that do not have -- a predecessor in the set). smallest :: (Ord r, Ord f) => HypGraph r f -> [Node r f] -> [Node r f] -- | Compute the relative maxima in a set of nodes (those that do not have -- a successor in the set). largest :: (Ord r, Ord f) => HypGraph r f -> [Node r f] -> [Node r f] -- | Given source nodes n1,n2,... find all target nodes m1,m2, such that -- for all j, there are edges n_i --l_ij--> m_j for all i. Return -- these edges as a map from target notes to a list of edges. We assume -- the graph is reflexive-transitive. commonSuccs :: (Ord r, Ord f) => Graph r f a -> [Node r f] -> Map (Node r f) [Edge' r f a] -- | Given target nodes m1,m2,... find all source nodes n1,n2, such that -- for all j, there are edges n_i --l_ij--> m_j for all i. Return -- these edges as a map from target notes to a list of edges. We assume -- the graph is reflexive-transitive. commonPreds :: (Ord r, Ord f) => Graph r f a -> [Node r f] -> Map (Node r f) [Edge' r f a] -- | Compute the sup of two different rigids or a rigid and a constant. lub' :: forall r f. (Ord r, Ord f, Pretty r, Pretty f, Show r, Show f) => HypGraph r f -> (Node r f, Offset) -> (Node r f, Offset) -> Maybe (SizeExpr' r f) -- | Compute the inf of two different rigids or a rigid and a constant. glb' :: forall r f. (Ord r, Ord f, Pretty r, Pretty f, Show r, Show f) => HypGraph r f -> (Node r f, Offset) -> (Node r f, Offset) -> Maybe (SizeExpr' r f) -- | Compute the least upper bound (sup). lub :: (Ord r, Ord f, Pretty r, Pretty f, Show r, Show f) => HypGraph r f -> SizeExpr' r f -> SizeExpr' r f -> Maybe (SizeExpr' r f) -- | Compute the greatest lower bound (inf) of size expressions relative to -- a hypotheses graph. glb :: (Ord r, Ord f, Pretty r, Pretty f, Show r, Show f) => HypGraph r f -> SizeExpr' r f -> SizeExpr' r f -> Maybe (SizeExpr' r f) findRigidBelow :: (Ord r, Ord f) => HypGraph r f -> SizeExpr' r f -> Maybe (SizeExpr' r f) solveGraph :: (Ord r, Ord f, Pretty r, Pretty f, PrettyTCM f, Show r, Show f) => Polarities f -> HypGraph r f -> ConGraph r f -> Either Error (Solution r f) -- | Solve a forest of constraint graphs relative to a hypotheses graph. -- Concatenate individual solutions. solveGraphs :: (Ord r, Ord f, Pretty r, Pretty f, PrettyTCM f, Show r, Show f) => Polarities f -> HypGraph r f -> ConGraphs r f -> Either Error (Solution r f) -- | Check that after substitution of the solution, constraints are implied -- by hypotheses. verifySolution :: (Ord r, Ord f, Pretty r, Pretty f, Show r, Show f) => HypGraph r f -> [Constraint' r f] -> Solution r f -> Either Error () -- | Iterate solver until no more metas can be solved. -- -- This might trigger a (wanted) error on the second iteration (see Issue -- 2096) which would otherwise go unnoticed. iterateSolver :: (Ord r, Ord f, Pretty r, Pretty f, PrettyTCM f, Show r, Show f) => Polarities f -> HypGraph r f -> [Constraint' r f] -> Solution r f -> Either Error (Solution r f) testSuccs :: Ord f => Map (Node [Char] f) [Edge' [Char] f Label] testLub :: (Pretty f, Ord f, Show f) => Maybe (SizeExpr' [Char] f) instance GHC.Show.Show Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance GHC.Show.Show Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance (GHC.Classes.Ord rigid, GHC.Classes.Ord flex) => GHC.Classes.Ord (Agda.TypeChecking.SizedTypes.WarshallSolver.Node rigid flex) instance (GHC.Classes.Eq rigid, GHC.Classes.Eq flex) => GHC.Classes.Eq (Agda.TypeChecking.SizedTypes.WarshallSolver.Node rigid flex) instance (GHC.Show.Show rigid, GHC.Show.Show flex) => GHC.Show.Show (Agda.TypeChecking.SizedTypes.WarshallSolver.Node rigid flex) instance GHC.Classes.Eq f => Agda.TypeChecking.SizedTypes.WarshallSolver.SetToInfty f (Agda.TypeChecking.SizedTypes.WarshallSolver.Node r f) instance GHC.Classes.Eq f => Agda.TypeChecking.SizedTypes.WarshallSolver.SetToInfty f (Agda.TypeChecking.SizedTypes.WarshallSolver.Edge' r f a) instance (GHC.Classes.Ord r, GHC.Classes.Ord f) => Agda.TypeChecking.SizedTypes.WarshallSolver.SetToInfty f (Agda.TypeChecking.SizedTypes.WarshallSolver.ConGraph r f) instance (GHC.Classes.Ord r, GHC.Classes.Ord f, Agda.TypeChecking.SizedTypes.WarshallSolver.Negative a) => Agda.TypeChecking.SizedTypes.WarshallSolver.Negative (Agda.TypeChecking.SizedTypes.WarshallSolver.Graphs r f a) instance (GHC.Classes.Ord r, GHC.Classes.Ord f, Agda.TypeChecking.SizedTypes.WarshallSolver.Negative a) => Agda.TypeChecking.SizedTypes.WarshallSolver.Negative (Agda.TypeChecking.SizedTypes.WarshallSolver.Graph r f a) instance Agda.TypeChecking.SizedTypes.WarshallSolver.Negative a => Agda.TypeChecking.SizedTypes.WarshallSolver.Negative (Agda.TypeChecking.SizedTypes.WarshallSolver.Edge' r f a) instance (GHC.Classes.Ord r, GHC.Classes.Ord f, Agda.TypeChecking.SizedTypes.Utils.MeetSemiLattice a) => Agda.TypeChecking.SizedTypes.Utils.MeetSemiLattice (Agda.TypeChecking.SizedTypes.WarshallSolver.Edge' r f a) instance (GHC.Classes.Ord r, GHC.Classes.Ord f, Agda.TypeChecking.SizedTypes.Utils.Top a) => Agda.TypeChecking.SizedTypes.Utils.Top (Agda.TypeChecking.SizedTypes.WarshallSolver.Edge' r f a) instance (GHC.Classes.Ord r, GHC.Classes.Ord f, Agda.TypeChecking.SizedTypes.Utils.Dioid a) => Agda.TypeChecking.SizedTypes.Utils.Dioid (Agda.TypeChecking.SizedTypes.WarshallSolver.Edge' r f a) instance (Agda.Utils.Pretty.Pretty rigid, Agda.Utils.Pretty.Pretty flex) => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.SizedTypes.WarshallSolver.Node rigid flex) instance Agda.TypeChecking.SizedTypes.WarshallSolver.Negative Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance Agda.TypeChecking.SizedTypes.Utils.MeetSemiLattice Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance Agda.TypeChecking.SizedTypes.Utils.Top Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance Agda.TypeChecking.SizedTypes.Utils.Dioid Agda.TypeChecking.SizedTypes.WarshallSolver.Label instance Agda.TypeChecking.SizedTypes.Utils.Plus (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) Agda.TypeChecking.SizedTypes.WarshallSolver.Label (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance Agda.TypeChecking.SizedTypes.WarshallSolver.Negative GHC.Types.Int instance Agda.TypeChecking.SizedTypes.WarshallSolver.Negative Agda.TypeChecking.SizedTypes.Syntax.Offset instance Agda.TypeChecking.SizedTypes.WarshallSolver.Negative Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.TypeChecking.SizedTypes.Utils.MeetSemiLattice Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.TypeChecking.SizedTypes.Utils.Top Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance GHC.Enum.Enum Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance GHC.Num.Num Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.TypeChecking.SizedTypes.Utils.Plus Agda.TypeChecking.SizedTypes.WarshallSolver.Weight Agda.TypeChecking.SizedTypes.Syntax.Offset Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.TypeChecking.SizedTypes.Utils.Dioid Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.TypeChecking.SizedTypes.Utils.Plus Agda.TypeChecking.SizedTypes.Syntax.Offset Agda.TypeChecking.SizedTypes.WarshallSolver.Weight Agda.TypeChecking.SizedTypes.WarshallSolver.Weight instance Agda.TypeChecking.SizedTypes.Utils.Plus (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) Agda.TypeChecking.SizedTypes.WarshallSolver.Weight (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) -- | Syntax of size expressions and constraints. module Agda.TypeChecking.SizedTypes.Syntax -- | Constant finite sizes n >= 0. newtype Offset O :: Int -> Offset -- | Fixed size variables i. newtype Rigid RigidId :: String -> Rigid [rigidId] :: Rigid -> String -- | Size meta variables X to solve for. newtype Flex FlexId :: String -> Flex [flexId] :: Flex -> String -- | Size expressions appearing in constraints. data SizeExpr' rigid flex -- | Constant number n. Const :: Offset -> SizeExpr' rigid flex [offset] :: SizeExpr' rigid flex -> Offset -- | Variable plus offset i + n. Rigid :: rigid -> Offset -> SizeExpr' rigid flex [rigid] :: SizeExpr' rigid flex -> rigid [offset] :: SizeExpr' rigid flex -> Offset -- | Infinity . Infty :: SizeExpr' rigid flex -- | Meta variable X + n. Flex :: flex -> Offset -> SizeExpr' rigid flex [flex] :: SizeExpr' rigid flex -> flex [offset] :: SizeExpr' rigid flex -> Offset type SizeExpr = SizeExpr' Rigid Flex -- | Comparison operator, e.g. for size expression. data Cmp -- | <. Lt :: Cmp -- | . Le :: Cmp -- | Constraint: an inequation between size expressions, e.g. X < -- ∞ or i + 3 ≤ j. data Constraint' rigid flex Constraint :: SizeExpr' rigid flex -> Cmp -> SizeExpr' rigid flex -> Constraint' rigid flex [leftExpr] :: Constraint' rigid flex -> SizeExpr' rigid flex [cmp] :: Constraint' rigid flex -> Cmp [rightExpr] :: Constraint' rigid flex -> SizeExpr' rigid flex type Constraint = Constraint' Rigid Flex -- | What type of solution are we looking for? data Polarity Least :: Polarity Greatest :: Polarity -- | Assigning a polarity to a flexible variable. data PolarityAssignment flex PolarityAssignment :: Polarity -> flex -> PolarityAssignment flex -- | Type of solution wanted for each flexible. type Polarities flex = Map flex Polarity emptyPolarities :: Polarities flex polaritiesFromAssignments :: Ord flex => [PolarityAssignment flex] -> Polarities flex -- | Default polarity is Least. getPolarity :: Ord flex => Polarities flex -> flex -> Polarity -- | Partial substitution from flexible variables to size expression. newtype Solution rigid flex Solution :: Map flex (SizeExpr' rigid flex) -> Solution rigid flex [theSolution] :: Solution rigid flex -> Map flex (SizeExpr' rigid flex) emptySolution :: Solution r f -- | Executing a substitution. class Substitute r f a subst :: Substitute r f a => Solution r f -> a -> a -- | Error messages produced by the constraint simplification monad. type Error = TCM Doc type CTrans r f = Constraint' r f -> Either Error [Constraint' r f] -- | Returns an error message if we have a contradictory constraint. simplify1 :: (Pretty f, Pretty r, Eq r) => CTrans r f -> CTrans r f -- | Le acts as True, Lt as False. ifLe :: Cmp -> a -> a -> a -- | Interpret Cmp as relation on Offset. compareOffset :: Offset -> Cmp -> Offset -> Bool -- | Offsets + n must be non-negative class ValidOffset a validOffset :: ValidOffset a => a -> Bool -- | Make offsets non-negative by rounding up. class TruncateOffset a truncateOffset :: TruncateOffset a => a -> a -- | The rigid variables contained in a pice of syntax. class Ord (RigidOf a) => Rigids a where { type RigidOf a; } rigids :: Rigids a => a -> Set (RigidOf a) -- | The flexibe variables contained in a pice of syntax. class Ord (FlexOf a) => Flexs a where { type FlexOf a; } flexs :: Flexs a => a -> Set (FlexOf a) instance GHC.Enum.Enum Agda.TypeChecking.SizedTypes.Syntax.Offset instance GHC.Num.Num Agda.TypeChecking.SizedTypes.Syntax.Offset instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Offset instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Offset instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Rigid instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Rigid instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Flex instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Flex instance Data.Traversable.Traversable (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid) instance Data.Foldable.Foldable (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid) instance GHC.Base.Functor (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid) instance (GHC.Classes.Ord rigid, GHC.Classes.Ord flex) => GHC.Classes.Ord (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid flex) instance (GHC.Classes.Eq rigid, GHC.Classes.Eq flex) => GHC.Classes.Eq (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid flex) instance (GHC.Show.Show rigid, GHC.Show.Show flex) => GHC.Show.Show (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid flex) instance GHC.Enum.Enum Agda.TypeChecking.SizedTypes.Syntax.Cmp instance GHC.Enum.Bounded Agda.TypeChecking.SizedTypes.Syntax.Cmp instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Cmp instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Syntax.Cmp instance Data.Traversable.Traversable (Agda.TypeChecking.SizedTypes.Syntax.Constraint' rigid) instance Data.Foldable.Foldable (Agda.TypeChecking.SizedTypes.Syntax.Constraint' rigid) instance GHC.Base.Functor (Agda.TypeChecking.SizedTypes.Syntax.Constraint' rigid) instance (GHC.Show.Show rigid, GHC.Show.Show flex) => GHC.Show.Show (Agda.TypeChecking.SizedTypes.Syntax.Constraint' rigid flex) instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Polarity instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Polarity instance Agda.Utils.Null.Null (Agda.TypeChecking.SizedTypes.Syntax.Solution rigid flex) instance (GHC.Show.Show flex, GHC.Show.Show rigid) => GHC.Show.Show (Agda.TypeChecking.SizedTypes.Syntax.Solution rigid flex) instance Agda.TypeChecking.SizedTypes.Syntax.Flexs a => Agda.TypeChecking.SizedTypes.Syntax.Flexs [a] instance GHC.Classes.Ord flex => Agda.TypeChecking.SizedTypes.Syntax.Flexs (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid flex) instance GHC.Classes.Ord flex => Agda.TypeChecking.SizedTypes.Syntax.Flexs (Agda.TypeChecking.SizedTypes.Syntax.Constraint' rigid flex) instance Agda.TypeChecking.SizedTypes.Syntax.Rigids a => Agda.TypeChecking.SizedTypes.Syntax.Rigids [a] instance GHC.Classes.Ord r => Agda.TypeChecking.SizedTypes.Syntax.Rigids (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance GHC.Classes.Ord r => Agda.TypeChecking.SizedTypes.Syntax.Rigids (Agda.TypeChecking.SizedTypes.Syntax.Constraint' r f) instance Agda.TypeChecking.SizedTypes.Syntax.TruncateOffset Agda.TypeChecking.SizedTypes.Syntax.Offset instance Agda.TypeChecking.SizedTypes.Syntax.TruncateOffset (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance Agda.TypeChecking.SizedTypes.Syntax.ValidOffset Agda.TypeChecking.SizedTypes.Syntax.Offset instance Agda.TypeChecking.SizedTypes.Syntax.ValidOffset (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance GHC.Classes.Ord f => Agda.TypeChecking.SizedTypes.Syntax.Substitute r f (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance GHC.Classes.Ord f => Agda.TypeChecking.SizedTypes.Syntax.Substitute r f (Agda.TypeChecking.SizedTypes.Syntax.Constraint' r f) instance Agda.TypeChecking.SizedTypes.Syntax.Substitute r f a => Agda.TypeChecking.SizedTypes.Syntax.Substitute r f [a] instance Agda.TypeChecking.SizedTypes.Syntax.Substitute r f a => Agda.TypeChecking.SizedTypes.Syntax.Substitute r f (Data.Map.Internal.Map k a) instance GHC.Classes.Ord f => Agda.TypeChecking.SizedTypes.Syntax.Substitute r f (Agda.TypeChecking.SizedTypes.Syntax.Solution r f) instance (Agda.Utils.Pretty.Pretty r, Agda.Utils.Pretty.Pretty f) => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.SizedTypes.Syntax.Solution r f) instance Agda.Utils.Pretty.Pretty flex => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.SizedTypes.Syntax.PolarityAssignment flex) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Syntax.Polarity instance (Agda.Utils.Pretty.Pretty r, Agda.Utils.Pretty.Pretty f) => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.SizedTypes.Syntax.Constraint' r f) instance Agda.TypeChecking.SizedTypes.Utils.Dioid Agda.TypeChecking.SizedTypes.Syntax.Cmp instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Cmp instance Agda.TypeChecking.SizedTypes.Utils.MeetSemiLattice Agda.TypeChecking.SizedTypes.Syntax.Cmp instance Agda.TypeChecking.SizedTypes.Utils.Top Agda.TypeChecking.SizedTypes.Syntax.Cmp instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Syntax.Cmp instance Agda.TypeChecking.SizedTypes.Utils.Plus (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) Agda.TypeChecking.SizedTypes.Syntax.Offset (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance (Agda.Utils.Pretty.Pretty r, Agda.Utils.Pretty.Pretty f) => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f) instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Syntax.Flex instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Syntax.Flex instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.SizedTypes.Syntax.Flex instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Syntax.Rigid instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Syntax.Rigid instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Syntax.Offset instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.Syntax.Offset instance Agda.TypeChecking.SizedTypes.Utils.MeetSemiLattice Agda.TypeChecking.SizedTypes.Syntax.Offset instance Agda.TypeChecking.SizedTypes.Utils.Plus Agda.TypeChecking.SizedTypes.Syntax.Offset Agda.TypeChecking.SizedTypes.Syntax.Offset Agda.TypeChecking.SizedTypes.Syntax.Offset module Agda.TypeChecking.Rules.LHS -- | Check a LHS. Main function. -- -- checkLeftHandSide a ps a ret checks that user patterns -- ps eliminate the type a of the defined function, and -- calls continuation ret if successful. checkLeftHandSide :: forall a. Call -> Maybe QName -> [NamedArg Pattern] -> Type -> Maybe Substitution -> [ProblemEq] -> (LHSResult -> TCM a) -> TCM a -- | Result of checking the LHS of a clause. data LHSResult LHSResult :: Nat -> Telescope -> [NamedArg DeBruijnPattern] -> Bool -> Arg Type -> Substitution -> [AsBinding] -> IntSet -> Bool -> LHSResult -- | The number of original module parameters. These are present in the the -- patterns. [lhsParameters] :: LHSResult -> Nat -- | Δ : The types of the pattern variables, in internal dependency order. -- Corresponds to clauseTel. [lhsVarTele] :: LHSResult -> Telescope -- | The patterns in internal syntax. [lhsPatterns] :: LHSResult -> [NamedArg DeBruijnPattern] -- | Whether the LHS has at least one absurd pattern. [lhsHasAbsurd] :: LHSResult -> Bool -- | The type of the body. Is if Γ is defined. -- Irrelevant to indicate the rhs must be checked in irrelevant -- mode. [lhsBodyType] :: LHSResult -> Arg Type -- | Substitution version of lhsPatterns, only up to the first -- projection pattern. Δ |- lhsPatSubst : Γ. Where Γ is -- the argument telescope of the function. This is used to update -- inherited dot patterns in with-function clauses. [lhsPatSubst] :: LHSResult -> Substitution -- | As-bindings from the left-hand side. Return instead of bound since we -- want them in where's and right-hand sides, but not in with-clauses -- (Issue 2303). [lhsAsBindings] :: LHSResult -> [AsBinding] -- | have we done a partial split? [lhsPartialSplit] :: LHSResult -> IntSet -- | have we split on an indexed type? [lhsIndexedSplit] :: LHSResult -> Bool -- | Bind as patterns bindAsPatterns :: [AsBinding] -> TCM a -> TCM a -- | A pattern is flexible if it is dotted or implicit, or a record pattern -- with only flexible subpatterns. class IsFlexiblePattern a maybeFlexiblePattern :: (IsFlexiblePattern a, HasConstInfo m, MonadDebug m) => a -> MaybeT m FlexibleVarKind isFlexiblePattern :: (IsFlexiblePattern a, HasConstInfo m, MonadDebug m) => a -> m Bool data DataOrRecord IsData :: DataOrRecord IsRecord :: Maybe Induction -> EtaEquality -> DataOrRecord [recordInduction] :: DataOrRecord -> Maybe Induction [recordEtaEquality] :: DataOrRecord -> EtaEquality checkSortOfSplitVar :: (MonadTCM m, PureTCM m, MonadError TCErr m, LensSort a, PrettyTCM a, LensSort ty, PrettyTCM ty) => DataOrRecord -> a -> Telescope -> Maybe ty -> m () instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.DataOrRecord instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Rules.LHS.LHSResult instance Agda.TypeChecking.Rules.LHS.IsFlexiblePattern Agda.Syntax.Abstract.Pattern instance Agda.TypeChecking.Rules.LHS.IsFlexiblePattern (Agda.Syntax.Internal.Pattern' a) instance Agda.TypeChecking.Rules.LHS.IsFlexiblePattern a => Agda.TypeChecking.Rules.LHS.IsFlexiblePattern [a] instance Agda.TypeChecking.Rules.LHS.IsFlexiblePattern a => Agda.TypeChecking.Rules.LHS.IsFlexiblePattern (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Rules.LHS.IsFlexiblePattern a => Agda.TypeChecking.Rules.LHS.IsFlexiblePattern (Agda.Syntax.Common.Named name a) -- | Unification algorithm for specializing datatype indices, as described -- in "Unifiers as Equivalences: Proof-Relevant Unification of -- Dependently Typed Data" by Jesper Cockx, Dominique Devriese, and Frank -- Piessens (ICFP 2016). -- -- This is the unification algorithm used for checking the left-hand side -- of clauses (see Agda.TypeChecking.Rules.LHS), coverage -- checking (see Agda.TypeChecking.Coverage) and indirectly also -- for interactive case splitting (see -- Agda.Interaction.MakeCase). -- -- A unification problem (of type UnifyState) consists of: -- --
    --
  1. A telescope varTel of free variables, some or all of -- which are flexible (as indicated by flexVars).
  2. --
  3. A telescope eqTel containing the types of the -- equations.
  4. --
  5. Left- and right-hand sides for each equation: varTel ⊢ eqLHS : -- eqTel and varTel ⊢ eqRHS : eqTel.
  6. --
-- -- The unification algorithm can end in three different ways: (type -- UnificationResult): -- -- -- -- The unification algorithm itself consists of two parts: -- --
    --
  1. A *unification strategy* takes a unification problem and produces -- a list of suggested unification rules (of type UnifyStep). -- Strategies can be constructed by composing simpler strategies (see for -- example the definition of completeStrategyAt).
  2. --
  3. The *unification engine* unifyStep takes a unification -- rule and tries to apply it to the given state, writing the result to -- the UnifyOutput on a success.
  4. --
-- -- The unification steps (of type UnifyStep) are the following: -- -- -- -- Higher-dimensional unification (new, does not yet appear in any -- paper): If an equation of the form c us =?= c vs : D pars is -- is encountered where c : Δc → D pars js is a constructor of -- an indexed datatype D pars : Φ → Set ℓ, it is in general -- unsound to just simplify this equation to us =?= vs : Δc. For -- this reason, the injectivity rule in the paper restricts the indices -- is to be distinct variables that are bound in the telescope -- eqTel. But we can be more general by introducing new -- variables ks to the telescope eqTel and equating -- these to is: Δ₁(x : D pars is)Δ₂ ≃ Δ₁(ks : Φ)(x : D pars -- ks)(ps : is ≡Φ ks)Δ₂ Since ks are distinct variables, -- it's now possible to apply injectivity to the equation x, -- resulting in the following new equation telescope: Δ₁(ys : Δc)(ps -- : is ≡Φ js[Δc ↦ ys])Δ₂ Now we can solve the equations -- ps by recursively calling the unification algorithm with -- flexible variables Δ₁(ys : Δc). This is called -- *higher-dimensional unification* since we are unifying equality proofs -- rather than terms. If the higher-dimensional unification succeeds, the -- resulting telescope serves as the new equation telescope for the -- original unification problem. module Agda.TypeChecking.Rules.LHS.Unify -- | Result of unifyIndices. type UnificationResult = UnificationResult' (Telescope, PatternSubstitution, [NamedArg DeBruijnPattern]) data UnificationResult' a -- | Unification succeeded. Unifies :: a -> UnificationResult' a -- | Terms are not unifiable. NoUnify :: NegativeUnification -> UnificationResult' a -- | Unification got blocked on a metavariable UnifyBlocked :: Blocker -> UnificationResult' a -- | Some other error happened, unification got stuck. UnifyStuck :: [UnificationFailure] -> UnificationResult' a data NoLeftInv UnsupportedYet :: UnifyStep -> NoLeftInv [badStep] :: NoLeftInv -> UnifyStep Illegal :: UnifyStep -> NoLeftInv [badStep] :: NoLeftInv -> UnifyStep NoCubical :: NoLeftInv WithKEnabled :: NoLeftInv -- | splitting on a Strict Set. SplitOnStrict :: NoLeftInv -- | splitting on a @♭ argument SplitOnFlat :: NoLeftInv UnsupportedCxt :: NoLeftInv unifyIndices' :: (PureTCM m, MonadError TCErr m) => Maybe NoLeftInv -> Telescope -> FlexibleVars -> Type -> Args -> Args -> m FullUnificationResult -- | Unify indices. -- -- In unifyIndices gamma flex a us vs, -- -- -- -- The result is the most general unifier of us and vs. unifyIndices :: (PureTCM m, MonadBench m, BenchPhase m ~ Phase, MonadError TCErr m) => Maybe NoLeftInv -> Telescope -> FlexibleVars -> Type -> Args -> Args -> m UnificationResult instance Data.Traversable.Traversable Agda.TypeChecking.Rules.LHS.Unify.UnificationResult' instance Data.Foldable.Foldable Agda.TypeChecking.Rules.LHS.Unify.UnificationResult' instance GHC.Base.Functor Agda.TypeChecking.Rules.LHS.Unify.UnificationResult' instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Rules.LHS.Unify.UnificationResult' a) instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Unify.RetryNormalised instance GHC.Classes.Eq Agda.TypeChecking.Rules.LHS.Unify.RetryNormalised module Agda.TypeChecking.Rules.LHS.Unify.Types data Equality Equal :: Dom Type -> Term -> Term -> Equality [_eqType] :: Equality -> Dom Type [_eqLeft] :: Equality -> Term [_eqRight] :: Equality -> Term eqConstructorForm :: HasBuiltins m => Equality -> m Equality eqUnLevel :: HasBuiltins m => Equality -> m Equality data UnifyState UState :: Telescope -> FlexibleVars -> Telescope -> [Arg Term] -> [Arg Term] -> UnifyState -- | Don't reduce! [varTel] :: UnifyState -> Telescope [flexVars] :: UnifyState -> FlexibleVars -- | Can be reduced eagerly. [eqTel] :: UnifyState -> Telescope -- | Ends up in dot patterns (should not be reduced eagerly). [eqLHS] :: UnifyState -> [Arg Term] -- | Ends up in dot patterns (should not be reduced eagerly). [eqRHS] :: UnifyState -> [Arg Term] lensVarTel :: Lens' Telescope UnifyState lensEqTel :: Lens' Telescope UnifyState initUnifyState :: PureTCM m => Telescope -> FlexibleVars -> Type -> Args -> Args -> m UnifyState isUnifyStateSolved :: UnifyState -> Bool varCount :: UnifyState -> Int -- | Get the type of the i'th variable in the given state getVarType :: Int -> UnifyState -> Dom Type getVarTypeUnraised :: Int -> UnifyState -> Dom Type eqCount :: UnifyState -> Int -- | Get the k'th equality in the given state. The left- and right-hand -- sides of the equality live in the varTel telescope, and the type of -- the equality lives in the varTel++eqTel telescope getEquality :: Int -> UnifyState -> Equality getReducedEquality :: (MonadReduce m, MonadAddContext m) => Int -> UnifyState -> m Equality -- | As getEquality, but with the unraised type getEqualityUnraised :: Int -> UnifyState -> Equality getReducedEqualityUnraised :: (MonadReduce m, MonadAddContext m) => Int -> UnifyState -> m Equality -- | Instantiate the k'th variable with the given value. Returns Nothing if -- there is a cycle. solveVar :: Int -> DeBruijnPattern -> UnifyState -> Maybe (UnifyState, PatternSubstitution) applyUnder :: Int -> Telescope -> Term -> Telescope dropAt :: Int -> [a] -> [a] -- | Solve the k'th equation with the given value, which can depend on -- regular variables but not on other equation variables. solveEq :: Int -> Term -> UnifyState -> (UnifyState, PatternSubstitution) data UnifyStep Deletion :: Int -> Type -> Term -> Term -> UnifyStep [deleteAt] :: UnifyStep -> Int [deleteType] :: UnifyStep -> Type [deleteLeft] :: UnifyStep -> Term [deleteRight] :: UnifyStep -> Term Solution :: Int -> Dom Type -> FlexibleVar Int -> Term -> Either () () -> UnifyStep [solutionAt] :: UnifyStep -> Int [solutionType] :: UnifyStep -> Dom Type [solutionVar] :: UnifyStep -> FlexibleVar Int [solutionTerm] :: UnifyStep -> Term -- | side of the equation where the variable is. [solutionSide] :: UnifyStep -> Either () () Injectivity :: Int -> Type -> QName -> Args -> Args -> ConHead -> UnifyStep [injectAt] :: UnifyStep -> Int [injectType] :: UnifyStep -> Type [injectDatatype] :: UnifyStep -> QName [injectParameters] :: UnifyStep -> Args [injectIndices] :: UnifyStep -> Args [injectConstructor] :: UnifyStep -> ConHead Conflict :: Int -> Type -> QName -> Args -> Term -> Term -> UnifyStep [conflictAt] :: UnifyStep -> Int [conflictType] :: UnifyStep -> Type [conflictDatatype] :: UnifyStep -> QName [conflictParameters] :: UnifyStep -> Args [conflictLeft] :: UnifyStep -> Term [conflictRight] :: UnifyStep -> Term Cycle :: Int -> Type -> QName -> Args -> Int -> Term -> UnifyStep [cycleAt] :: UnifyStep -> Int [cycleType] :: UnifyStep -> Type [cycleDatatype] :: UnifyStep -> QName [cycleParameters] :: UnifyStep -> Args [cycleVar] :: UnifyStep -> Int [cycleOccursIn] :: UnifyStep -> Term EtaExpandVar :: FlexibleVar Int -> QName -> Args -> UnifyStep [expandVar] :: UnifyStep -> FlexibleVar Int [expandVarRecordType] :: UnifyStep -> QName [expandVarParameters] :: UnifyStep -> Args EtaExpandEquation :: Int -> QName -> Args -> UnifyStep [expandAt] :: UnifyStep -> Int [expandRecordType] :: UnifyStep -> QName [expandParameters] :: UnifyStep -> Args LitConflict :: Int -> Type -> Literal -> Literal -> UnifyStep [litConflictAt] :: UnifyStep -> Int [litType] :: UnifyStep -> Type [litConflictLeft] :: UnifyStep -> Literal [litConflictRight] :: UnifyStep -> Literal StripSizeSuc :: Int -> Term -> Term -> UnifyStep [stripAt] :: UnifyStep -> Int [stripArgLeft] :: UnifyStep -> Term [stripArgRight] :: UnifyStep -> Term SkipIrrelevantEquation :: Int -> UnifyStep [skipIrrelevantAt] :: UnifyStep -> Int TypeConInjectivity :: Int -> QName -> Args -> Args -> UnifyStep [typeConInjectAt] :: UnifyStep -> Int [typeConstructor] :: UnifyStep -> QName [typeConArgsLeft] :: UnifyStep -> Args [typeConArgsRight] :: UnifyStep -> Args data UnifyLogEntry UnificationStep :: UnifyState -> UnifyStep -> UnifyOutput -> UnifyLogEntry type UnifyLog = [(UnifyLogEntry, UnifyState)] -- | This variant of UnifyLog is used to ensure that tell is -- not expensive. type UnifyLog' = DList (UnifyLogEntry, UnifyState) data UnifyOutput UnifyOutput :: PatternSubstitution -> PatternSubstitution -> UnifyOutput [unifySubst] :: UnifyOutput -> PatternSubstitution [unifyProof] :: UnifyOutput -> PatternSubstitution type UnifyLogT m a = WriterT UnifyLog' m a type UnifyStepT m a = WriterT UnifyOutput m a tellUnifySubst :: MonadWriter UnifyOutput m => PatternSubstitution -> m () tellUnifyProof :: MonadWriter UnifyOutput m => PatternSubstitution -> m () writeUnifyLog :: MonadWriter UnifyLog' m => (UnifyLogEntry, UnifyState) -> m () runUnifyLogT :: Functor m => UnifyLogT m a -> m (a, UnifyLog) instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyState instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyStep instance GHC.Base.Semigroup Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyOutput instance GHC.Base.Monoid Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyOutput instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyStep instance Agda.TypeChecking.Reduce.Reduce Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyState instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Unify.Types.UnifyState -- | Pattern matcher used in the reducer for clauses that have not been -- compiled to case trees yet. module Agda.TypeChecking.Patterns.Match -- | If matching is inconclusive (DontKnow) we want to know -- whether it is due to a particular meta variable. data Match a Yes :: Simplification -> IntMap (Arg a) -> Match a No :: Match a DontKnow :: Blocked () -> Match a matchedArgs :: Empty -> Int -> IntMap (Arg a) -> [Arg a] matchedArgs' :: Int -> IntMap (Arg a) -> [Maybe (Arg a)] -- | Builds a proper substitution from an IntMap produced by -- match(Co)patterns buildSubstitution :: DeBruijn a => Impossible -> Int -> IntMap (Arg a) -> Substitution' a -- | Instead of zipWithM, we need to use this lazy version of -- combining pattern matching computations. foldMatch :: forall m p v. (IsProjP p, MonadMatch m) => (p -> v -> m (Match Term, v)) -> [p] -> [v] -> m (Match Term, [v]) mergeElim :: Elim -> Arg Term -> Elim mergeElims :: [Elim] -> [Arg Term] -> [Elim] type MonadMatch m = PureTCM m -- | matchCopatterns ps es matches spine es against -- copattern spine ps. -- -- Returns Yes and a substitution for the pattern variables (in -- form of IntMap Term) if matching was successful. -- -- Returns No if there was a constructor or projection mismatch. -- -- Returns DontKnow if an argument could not be evaluated to -- constructor form because of a blocking meta variable. -- -- In any case, also returns spine es in reduced form (with all -- the weak head reductions performed that were necessary to come to a -- decision). matchCopatterns :: MonadMatch m => [NamedArg DeBruijnPattern] -> [Elim] -> m (Match Term, [Elim]) -- | Match a single copattern. matchCopattern :: MonadMatch m => DeBruijnPattern -> Elim -> m (Match Term, Elim) matchPatterns :: MonadMatch m => [NamedArg DeBruijnPattern] -> [Arg Term] -> m (Match Term, [Arg Term]) -- | Match a single pattern. matchPattern :: MonadMatch m => DeBruijnPattern -> Arg Term -> m (Match Term, Arg Term) yesSimplification :: (Match a, b) -> (Match a, b) -- | Match a single pattern. matchPatternP :: MonadMatch m => DeBruijnPattern -> Arg DeBruijnPattern -> m (Match DeBruijnPattern) matchPatternsP :: MonadMatch m => [NamedArg DeBruijnPattern] -> [Arg DeBruijnPattern] -> m (Match DeBruijnPattern) instance GHC.Base.Functor Agda.TypeChecking.Patterns.Match.Match instance Agda.Utils.Null.Null (Agda.TypeChecking.Patterns.Match.Match a) instance GHC.Base.Semigroup (Agda.TypeChecking.Patterns.Match.Match a) instance GHC.Base.Monoid (Agda.TypeChecking.Patterns.Match.Match a) module Agda.TypeChecking.Conversion.Pure data FreshThings FreshThings :: Int -> ProblemId -> NameId -> FreshThings [freshInt] :: FreshThings -> Int [freshProblemId] :: FreshThings -> ProblemId [freshNameId] :: FreshThings -> NameId newtype PureConversionT m a PureConversionT :: ExceptT TCErr (StateT FreshThings m) a -> PureConversionT m a [unPureConversionT] :: PureConversionT m a -> ExceptT TCErr (StateT FreshThings m) a pureEqualTerm :: (PureTCM m, MonadBlock m) => Type -> Term -> Term -> m Bool pureEqualType :: (PureTCM m, MonadBlock m) => Type -> Type -> m Bool pureCompareAs :: (PureTCM m, MonadBlock m) => Comparison -> CompareAs -> Term -> Term -> m Bool runPureConversion :: (MonadBlock m, PureTCM m, Show a) => PureConversionT m a -> m (Maybe a) instance (Agda.TypeChecking.Monad.Builtin.HasBuiltins m, Agda.TypeChecking.Monad.Signature.HasConstInfo m, Agda.TypeChecking.Monad.Context.MonadAddContext m, Agda.TypeChecking.Monad.Base.MonadReduce m) => Agda.TypeChecking.Monad.Pure.PureTCM (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState Agda.TypeChecking.Conversion.Pure.FreshThings (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => GHC.Base.Monad (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => GHC.Base.Applicative (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Functor m => GHC.Base.Functor (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Signature.HasConstInfo m => Agda.TypeChecking.Monad.Signature.HasConstInfo (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.Interaction.Options.HasOptions.HasOptions m => Agda.Interaction.Options.HasOptions.HasOptions (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Base.MonadTCEnv m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.ReadTCState (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Base.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Context.MonadAddContext m => Agda.TypeChecking.Monad.Context.MonadAddContext (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Debug.MonadDebug m => Agda.TypeChecking.Monad.Debug.MonadDebug (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Control.Monad.Trans.Class.MonadTrans Agda.TypeChecking.Conversion.Pure.PureConversionT instance (GHC.Base.Monad m, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Agda.TypeChecking.Conversion.Pure.PureConversionT m a) instance (Data.String.IsString a, GHC.Base.Monad m) => Data.String.IsString (Agda.TypeChecking.Conversion.Pure.PureConversionT m a) instance GHC.Base.Monad m => Agda.Utils.Null.Null (Agda.TypeChecking.Conversion.Pure.PureConversionT m Agda.TypeChecking.Pretty.Doc) instance GHC.Base.Monad m => Agda.TypeChecking.Monad.Base.MonadBlock (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance (Agda.TypeChecking.Monad.Pure.PureTCM m, Agda.TypeChecking.Monad.Base.MonadBlock m) => Agda.TypeChecking.Monad.Constraints.MonadConstraint (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance (Agda.TypeChecking.Monad.Pure.PureTCM m, Agda.TypeChecking.Monad.Base.MonadBlock m) => Agda.TypeChecking.Monad.MetaVars.MonadMetaSolver (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance (Agda.TypeChecking.Monad.Pure.PureTCM m, Agda.TypeChecking.Monad.Base.MonadBlock m) => Agda.TypeChecking.Monad.MetaVars.MonadInteractionPoints (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Base.MonadStConcreteNames (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance (Agda.TypeChecking.Monad.Pure.PureTCM m, Agda.TypeChecking.Monad.Base.MonadBlock m) => Agda.TypeChecking.Warnings.MonadWarning (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance Agda.TypeChecking.Monad.Base.ReadTCState m => Agda.TypeChecking.Monad.Statistics.MonadStatistics (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => Agda.TypeChecking.Monad.Base.MonadFresh Agda.Syntax.Common.ProblemId (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => Agda.TypeChecking.Monad.Base.MonadFresh Agda.Syntax.Common.NameId (Agda.TypeChecking.Conversion.Pure.PureConversionT m) instance GHC.Base.Monad m => Agda.TypeChecking.Monad.Base.MonadFresh GHC.Types.Int (Agda.TypeChecking.Conversion.Pure.PureConversionT m) module Agda.TypeChecking.Rules.LHS.Unify.LeftInverse data NoLeftInv UnsupportedYet :: UnifyStep -> NoLeftInv [badStep] :: NoLeftInv -> UnifyStep Illegal :: UnifyStep -> NoLeftInv [badStep] :: NoLeftInv -> UnifyStep NoCubical :: NoLeftInv WithKEnabled :: NoLeftInv -- | splitting on a Strict Set. SplitOnStrict :: NoLeftInv -- | splitting on a @♭ argument SplitOnFlat :: NoLeftInv UnsupportedCxt :: NoLeftInv buildLeftInverse :: (PureTCM tcm, MonadError TCErr tcm) => UnifyState -> UnifyLog -> tcm (Either NoLeftInv (Substitution, Substitution)) type Retract = (Telescope, Substitution, Substitution, Substitution) termsS :: DeBruijn a => Impossible -> [a] -> Substitution' a composeRetract :: (PureTCM tcm, MonadError TCErr tcm, MonadDebug tcm, HasBuiltins tcm, MonadAddContext tcm) => Retract -> Term -> Retract -> tcm Retract buildEquiv :: forall tcm. (PureTCM tcm, MonadError TCErr tcm) => UnifyLogEntry -> UnifyState -> tcm (Either NoLeftInv (Retract, Term)) explainStep :: MonadPretty m => UnifyStep -> m Doc instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Unify.LeftInverse.NoLeftInv instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Unify.LeftInverse.NoLeftInv module Agda.TypeChecking.Rules.LHS.ProblemRest -- | Rename the variables in a telescope using the names from a given -- pattern. -- -- If there are not at least as many patterns as entries as in the -- telescope, the names of the remaining entries in the telescope are -- unchanged. If there are too many patterns, there should be a type -- error later. useNamesFromPattern :: [NamedArg Pattern] -> Telescope -> Telescope useNamesFromProblemEqs :: forall m. PureTCM m => [ProblemEq] -> Telescope -> m Telescope useOriginFrom :: (LensOrigin a, LensOrigin b) => [a] -> [b] -> [a] -- | Are there any untyped user patterns left? noProblemRest :: Problem a -> Bool -- | Construct an initial LHSState from user patterns. Example: @ -- -- Case : {A : Set} → Maybe A → Set → Set → Set Case nothing B C = B Case -- (just _) B C = C -- -- sample : {A : Set} (m : Maybe A) → Case m Bool (Maybe A → Bool) sample -- (just a) (just b) = true sample (just a) nothing = false sample -- nothing = true The problem generated for the first clause of -- sample with patterns just a, just b would be: -- lhsTel = [A : Set, m : Maybe A] lhsOutPat = [A, "m"] lhsProblem -- = Problem [A = _, "just a" = "a"] ["_", "just a"] ["just b"] [] -- lhsTarget = "Case m Bool (Maybe A -> Bool)" @ initLHSState :: Telescope -> [ProblemEq] -> [NamedArg Pattern] -> Type -> (LHSState a -> TCM a) -> TCM (LHSState a) -- | Try to move patterns from the problem rest into the problem. Possible -- if type of problem rest has been updated to a function type. updateProblemRest :: forall m a. (PureTCM m, MonadError TCErr m, MonadTrace m, MonadFresh NameId m) => LHSState a -> m (LHSState a) module Agda.TypeChecking.Rules.Data -- | Type check a datatype definition. Assumes that the type has already -- been checked. checkDataDef :: DefInfo -> QName -> UniverseCheck -> DataDefParams -> [Constructor] -> TCM () -- | Make sure that the target universe admits data type definitions. E.g. -- IUniv, SizeUniv etc. do not accept new -- constructions. checkDataSort :: QName -> Sort -> TCM () -- | Ensure that the type is a sort. If it is not directly a sort, compare -- it to a newSortMetaBelowInf. forceSort :: Type -> TCM Sort -- | Type check a constructor declaration. Checks that the constructor -- targets the datatype and that it fits inside the declared sort. -- Returns the non-linear parameters. checkConstructor :: QName -> UniverseCheck -> Telescope -> Nat -> Sort -> Constructor -> TCM IsPathCons defineCompData :: QName -> ConHead -> Telescope -> [QName] -> Telescope -> Type -> Boundary -> TCM CompKit -- | Define projections for non-indexed data types (families don't work -- yet). Of course, these projections are partial functions in general. -- -- Precondition: we are in the context Γ of the data type parameters. defineProjections :: QName -> ConHead -> Telescope -> [QName] -> Telescope -> Type -> TCM () freshAbstractQName'_ :: String -> TCM QName -- | Defines and returns the name of the transpIx function. defineTranspIx :: QName -> TCM (Maybe QName) defineTranspFun :: QName -> Maybe QName -> [QName] -> [QName] -> TCM (Maybe QName) defineConClause :: QName -> Bool -> Maybe QName -> Nat -> Nat -> Telescope -> Telescope -> Substitution -> Type -> [QName] -> TCM [Clause] defineKanOperationForFields :: Command -> Maybe Term -> (Term -> QName -> Term) -> QName -> Telescope -> Telescope -> [Arg QName] -> Type -> TCM (Maybe ((QName, Telescope, Type, [Dom Type], [Term]), Substitution)) defineTranspForFields :: Maybe Term -> (Term -> QName -> Term) -> QName -> Telescope -> Tele (Dom CType) -> [Arg QName] -> Type -> TCM ((QName, Telescope, Type, [Dom Type], [Term]), Substitution) defineHCompForFields :: (Term -> QName -> Term) -> QName -> Telescope -> Tele (Dom LType) -> [Arg QName] -> LType -> TCM ((QName, Telescope, Type, [Dom Type], [Term]), Substitution) getGeneralizedParameters :: Set Name -> QName -> TCM [Maybe Name] -- | Bind the named generalized parameters. bindGeneralizedParameters :: [Maybe Name] -> Type -> (Telescope -> Type -> TCM a) -> TCM a -- | Bind the parameters of a datatype. -- -- We allow omission of hidden parameters at the definition site. -- Example: data D {a} (A : Set a) : Set a data D A where c : A -- -> D A bindParameters :: Int -> [LamBinding] -> Type -> (Telescope -> Type -> TCM a) -> TCM a bindParameter :: Int -> [LamBinding] -> Name -> Dom Type -> Abs Type -> (Telescope -> Type -> TCM a) -> TCM a -- | Check that the arguments to a constructor fits inside the sort of the -- datatype. The third argument is the type of the constructor. -- -- When --without-K is active and the type is fibrant the -- procedure also checks that the type is usable at the current modality. -- See #4784 and #5434. -- -- As a side effect, return the arity of the constructor. fitsIn :: UniverseCheck -> [IsForced] -> Type -> Sort -> TCM Int -- | When --without-K is enabled, we should check that the sorts of the -- index types fit into the sort of the datatype. checkIndexSorts :: Sort -> Telescope -> TCM () -- | Return the parameters that share variables with the indices -- nonLinearParameters :: Int -> Type -> TCM [Int] -- nonLinearParameters nPars t = data IsPathCons PathCons :: IsPathCons PointCons :: IsPathCons -- | Check that a type constructs something of the given datatype. The -- first argument is the number of parameters to the datatype and the -- second the number of additional non-parameters in the context (1 when -- generalizing, 0 otherwise). constructs :: Int -> Int -> Type -> QName -> TCM IsPathCons -- | Is the type coinductive? Returns Nothing if the answer cannot -- be determined. isCoinductive :: Type -> TCM (Maybe Bool) instance GHC.Show.Show Agda.TypeChecking.Rules.Data.IsPathCons instance GHC.Classes.Eq Agda.TypeChecking.Rules.Data.IsPathCons module Agda.TypeChecking.Generalize -- | Generalize a type over a set of (used) generalizable variables. generalizeType :: Set QName -> TCM Type -> TCM ([Maybe QName], Type) -- | Allow returning additional information from the type checking action. generalizeType' :: Set QName -> TCM (Type, a) -> TCM ([Maybe QName], Type, a) -- | Generalize a telescope over a set of generalizable variables. generalizeTelescope :: Map QName Name -> (forall a. (Telescope -> TCM a) -> TCM a) -> ([Maybe Name] -> Telescope -> TCM a) -> TCM a module Agda.TypeChecking.InstanceArguments -- | findInstance m (v,a)s tries to instantiate on of the types -- as of the candidate terms vs to the type t -- of the metavariable m. If successful, meta m is -- solved with the instantiation of v. If unsuccessful, the -- constraint is regenerated, with possibly reduced candidate set. The -- list of candidates is equal to Nothing when the type of the -- meta wasn't known when the constraint was generated. In that case, try -- to find its type again. findInstance :: MetaId -> Maybe [Candidate] -> TCM () isInstanceConstraint :: Constraint -> Bool shouldPostponeInstanceSearch :: (ReadTCState m, HasOptions m) => m Bool postponeInstanceConstraints :: TCM a -> TCM a -- | Entry point for tcGetInstances primitive getInstanceCandidates :: MetaId -> TCM (Either Blocker [Candidate]) instance GHC.Show.Show Agda.TypeChecking.InstanceArguments.YesNoMaybe -- | A constructor argument is forced if it appears as pattern variable in -- an index of the target. -- -- For instance x is forced in sing and n is -- forced in zero and suc: -- --
--   data Sing {a}{A : Set a} : A -> Set where
--     sing : (x : A) -> Sing x
--   
--   data Fin : Nat -> Set where
--     zero : (n : Nat) -> Fin (suc n)
--     suc  : (n : Nat) (i : Fin n) -> Fin (suc n)
--   
-- -- At runtime, forced constructor arguments may be erased as they can be -- recovered from dot patterns. For instance, unsing : {A : Set} (x -- : A) -> Sing x -> A unsing .x (sing x) = x can become -- unsing x sing = x and proj : (n : Nat) (i : Fin n) -> -- Nat proj .(suc n) (zero n) = n proj .(suc n) (suc n i) = n -- becomes proj (suc n) zero = n proj (suc n) (suc i) = n -- -- This module implements the analysis of which constructor arguments are -- forced. The process of moving the binding site of forced arguments is -- implemented in the unifier (see the Solution step of -- Agda.TypeChecking.Rules.LHS.Unify.unifyStep). -- -- Forcing is a concept from pattern matching and thus builds on the -- concept of equality (I) used there (closed terms, extensional) which -- is different from the equality (II) used in conversion checking and -- the constraint solver (open terms, intensional). -- -- Up to issue 1441 (Feb 2015), the forcing analysis here relied on the -- wrong equality (II), considering type constructors as injective. This -- is unsound for program extraction, but ok if forcing is only used to -- decide which arguments to skip during conversion checking. -- -- From now on, forcing uses equality (I) and does not search for forced -- variables under type constructors. This may lose some savings during -- conversion checking. If this turns out to be a problem, the old -- forcing could be brought back, using a new modality Skip to -- indicate that this is a relevant argument but still can be skipped -- during conversion checking as it is forced by equality (II). module Agda.TypeChecking.Forcing -- | Given the type of a constructor (excluding the parameters), decide -- which arguments are forced. Precondition: the type is of the form -- Γ → D vs and the vs are in normal form. computeForcingAnnotations :: QName -> Type -> TCM [IsForced] isForced :: IsForced -> Bool nextIsForced :: [IsForced] -> (IsForced, [IsForced]) instance Agda.TypeChecking.Forcing.ForcedVariables a => Agda.TypeChecking.Forcing.ForcedVariables [a] instance Agda.TypeChecking.Forcing.ForcedVariables a => Agda.TypeChecking.Forcing.ForcedVariables (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Forcing.ForcedVariables a => Agda.TypeChecking.Forcing.ForcedVariables (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Forcing.ForcedVariables Agda.Syntax.Internal.Term module Agda.TypeChecking.CompiledClause.Compile data RunRecordPatternTranslation RunRecordPatternTranslation :: RunRecordPatternTranslation DontRunRecordPatternTranslation :: RunRecordPatternTranslation compileClauses' :: RunRecordPatternTranslation -> [Clause] -> Maybe SplitTree -> TCM CompiledClauses -- | Process function clauses into case tree. This involves: 1. Coverage -- checking, generating a split tree. 2. Translation of lhs record -- patterns into rhs uses of projection. Update the split tree. 3. -- Generating a case tree from the split tree. Phases 1. and 2. are -- skipped if Nothing. compileClauses :: Maybe (QName, Type) -> [Clause] -> TCM (Maybe SplitTree, Bool, CompiledClauses) -- | Stripped-down version of Clause used in clause compiler. data Cl Cl :: [Arg Pattern] -> Maybe Term -> Cl -- | Pattern variables are considered in left-to-right order. [clPats] :: Cl -> [Arg Pattern] [clBody] :: Cl -> Maybe Term type Cls = [Cl] -- | Strip down a clause. Don't forget to apply the substitution to the dot -- patterns! unBruijn :: Clause -> Cl compileWithSplitTree :: SplitTree -> Cls -> CompiledClauses compile :: Cls -> CompiledClauses -- | Get the index of the next argument we need to split on. This the -- number of the first pattern that does a (non-lazy) match in the first -- clause. Or the first lazy match where all clauses agree on the -- constructor, if there are no non-lazy matches. nextSplit :: Cls -> Maybe (Bool, Arg Int) -- | Is is not a variable pattern? And if yes, is it a record pattern -- and/or a fallThrough one? properSplit :: Pattern' a -> Maybe Bool -- | Is this a variable pattern? -- -- Maintain invariant: isVar = isNothing . properSplit! isVar :: Pattern' a -> Bool -- | splitOn single n cs will force expansion of catch-alls if -- single. splitOn :: Bool -> Int -> Cls -> Case Cls splitC :: Int -> Cl -> Case Cl -- | Expand catch-alls that appear before actual matches. -- -- Example: -- --
--   true  y
--   x     false
--   false y
--   
-- -- will expand the catch-all x to false. -- -- Catch-alls need also to be expanded if they come before/after a record -- pattern, otherwise we get into trouble when we want to eliminate -- splits on records later. -- -- Another example (see Issue 1650): f (x, (y, z)) true = a f _ -- false = b Split tree: 0 (first argument of f) - 1 (second -- component of the pair) - 3 (last argument of f) -- true -> a - -- false -> b We would like to get the following case tree: -- case 0 of _,_ -> case 1 of _,_ -> case 3 of true -> a; false -- -> b _ -> case 3 of true -> a; false -> b _ -> case 3 -- of true -> a; false -> b -- -- Example from issue #2168: f x false = a f false = _ -> b f x -- true = c case tree: f x y = case y of true -> case x of -- true -> c false -> b false -> a -- -- Example from issue #3628: f i j k (i = i0)(k = i1) = base f i j k -- (j = i1) = base case tree: f i j k o = case i of i0 -> -- case k of i1 -> base _ -> case j of i1 -> base _ -> case j -- of i1 -> base expandCatchAlls :: Bool -> Int -> Cls -> Cls -- | Make sure (by eta-expansion) that clause has arity at least n -- where n is also the length of the provided list. ensureNPatterns :: Int -> [ArgInfo] -> Cl -> Cl substBody :: Subst a => Int -> Int -> SubstArg a -> a -> a instance GHC.Classes.Eq Agda.TypeChecking.CompiledClause.Compile.RunRecordPatternTranslation instance GHC.Show.Show Agda.TypeChecking.CompiledClause.Compile.Cl instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.CompiledClause.Compile.Cl instance Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars a => Agda.TypeChecking.Free.Precompute.PrecomputeFreeVars (Agda.TypeChecking.CompiledClause.CompiledClauses' a) -- | Code which replaces pattern matching on record constructors with uses -- of projection functions. module Agda.TypeChecking.RecordPatterns -- | Replaces pattern matching on record constructors with uses of -- projection functions. Does not remove record constructor patterns -- which have sub-patterns containing non-record constructor or literal -- patterns. translateRecordPatterns :: Clause -> TCM Clause translateCompiledClauses :: forall m. (HasConstInfo m, MonadChange m) => CompiledClauses -> m CompiledClauses -- | Split tree annotated for record pattern translation. type -- RecordSplitTree = SplitTree' RecordSplitNode type RecordSplitTrees = -- SplitTrees' RecordSplitNode -- -- Bottom-up procedure to record-pattern-translate split tree. translateSplitTree :: SplitTree -> TCM SplitTree -- | Take a record pattern p and yield a list of projections -- corresponding to the pattern variables, from left to right. -- -- E.g. for (x , (y , z)) we return [ fst, fst . snd, snd . -- snd ]. -- -- If it is not a record pattern, error ShouldBeRecordPattern is -- raised. recordPatternToProjections :: DeBruijnPattern -> TCM [Term -> Term] instance Agda.TypeChecking.Monad.Base.MonadTCState Agda.TypeChecking.RecordPatterns.RecPatM instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.TypeChecking.RecordPatterns.RecPatM instance Agda.Interaction.Options.HasOptions.HasOptions Agda.TypeChecking.RecordPatterns.RecPatM instance Agda.TypeChecking.Monad.Base.MonadTCM Agda.TypeChecking.RecordPatterns.RecPatM instance Control.Monad.IO.Class.MonadIO Agda.TypeChecking.RecordPatterns.RecPatM instance GHC.Base.Monad Agda.TypeChecking.RecordPatterns.RecPatM instance GHC.Base.Applicative Agda.TypeChecking.RecordPatterns.RecPatM instance GHC.Base.Functor Agda.TypeChecking.RecordPatterns.RecPatM instance GHC.Classes.Eq Agda.TypeChecking.RecordPatterns.Kind instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.RecordPatterns.Change instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.RecordPatterns.Kind -> Agda.Syntax.Common.Nat) instance Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.RecordPatterns.Kind -> Agda.Syntax.Common.Nat) instance Agda.TypeChecking.RecordPatterns.DropFrom (Agda.TypeChecking.Coverage.SplitTree.SplitTree' c) instance Agda.TypeChecking.RecordPatterns.DropFrom (c, Agda.TypeChecking.Coverage.SplitTree.SplitTree' c) instance Agda.TypeChecking.RecordPatterns.DropFrom a => Agda.TypeChecking.RecordPatterns.DropFrom [a] -- | Coverage checking, case splitting, and splitting for refine tactics. module Agda.TypeChecking.Coverage data SplitClause SClause :: Telescope -> [NamedArg SplitPattern] -> Substitution' SplitPattern -> Map CheckpointId Substitution -> Maybe (Dom Type) -> SplitClause -- | Type of variables in scPats. [scTel] :: SplitClause -> Telescope -- | The patterns leading to the currently considered branch of the split -- tree. [scPats] :: SplitClause -> [NamedArg SplitPattern] -- | Substitution from scTel to old context. Only needed directly -- after split on variable: * To update scTarget * To rename other -- split variables when splitting on multiple variables. scSubst -- is not `transitive', i.e., does not record the substitution -- from the original context to scTel over a series of splits. It -- is freshly computed after each split by computeNeighborhood; -- also splitResult, which does not split on a variable, should -- reset it to the identity idS, lest it be applied to -- scTarget again, leading to Issue 1294. [scSubst] :: SplitClause -> Substitution' SplitPattern -- | We need to keep track of the module parameter checkpoints for the -- clause for the purpose of inferring missing instance clauses. [scCheckpoints] :: SplitClause -> Map CheckpointId Substitution -- | The type of the rhs, living in context scTel. -- fixTargetType computes the new scTarget by applying -- substitution scSubst. [scTarget] :: SplitClause -> Maybe (Dom Type) -- | Create a split clause from a clause in internal syntax. Used by -- make-case. clauseToSplitClause :: Clause -> SplitClause -- | Add more patterns to split clause if the target type is a function -- type. Returns the domains of the function type (if any). insertTrailingArgs :: Bool -> SplitClause -> TCM (Telescope, SplitClause) -- | A Covering is the result of splitting a SplitClause. data Covering Covering :: Arg Nat -> [(SplitTag, (SplitClause, IInfo))] -> Covering -- | De Bruijn level (counting dot patterns) of argument we split on. [covSplitArg] :: Covering -> Arg Nat -- | Covering clauses, indexed by constructor/literal these clauses share. [covSplitClauses] :: Covering -> [(SplitTag, (SplitClause, IInfo))] -- | Project the split clauses out of a covering. splitClauses :: Covering -> [SplitClause] -- | Top-level function for checking pattern coverage. -- -- Effects: -- -- coverageCheck :: QName -> Type -> [Clause] -> TCM SplitTree -- | Top-level function for eliminating redundant clauses in the -- interactive case splitter isCovered :: QName -> [Clause] -> SplitClause -> TCM Bool -- | Entry point from Interaction.MakeCase. splitClauseWithAbsurd :: SplitClause -> Nat -> TCM (Either SplitError (Either SplitClause Covering)) -- | Entry point from TypeChecking.Empty and -- Interaction.BasicOps. splitLast CoInductive is used -- in the refine tactics. splitLast :: Induction -> Telescope -> [NamedArg DeBruijnPattern] -> TCM (Either SplitError Covering) -- | splitResult for MakeCase, tries to introduce IApply or ProjP -- copatterns splitResult :: QName -> SplitClause -> TCM (Either SplitError [SplitClause]) normaliseProjP :: (NormaliseProjP a, HasConstInfo m) => a -> m a instance GHC.Show.Show Agda.TypeChecking.Coverage.InsertTrailing instance GHC.Classes.Eq Agda.TypeChecking.Coverage.InsertTrailing instance GHC.Show.Show Agda.TypeChecking.Coverage.AllowPartialCover instance GHC.Classes.Eq Agda.TypeChecking.Coverage.AllowPartialCover instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Coverage.SplitClause.SplitClause module Agda.TypeChecking.Empty -- | Check whether a type is empty. isEmptyType :: Type -> TCM Bool -- | Check whether some type in a telescope is empty. isEmptyTel :: Telescope -> TCM Bool -- | Ensure that a type is empty. This check may be postponed as emptiness -- constraint. ensureEmptyType :: Range -> Type -> TCM () -- | Check whether one of the types in the given telescope is -- constructor-less and if yes, return its index in the telescope (0 = -- leftmost). checkEmptyTel :: Range -> Telescope -> TCM (Either ErrorNonEmpty Int) instance GHC.Base.Semigroup Agda.TypeChecking.Empty.ErrorNonEmpty instance GHC.Base.Monoid Agda.TypeChecking.Empty.ErrorNonEmpty -- | Given -- --
    --
  1. the function clauses cs
  2. --
  3. the patterns ps of the split clause
  4. --
-- -- we want to compute a variable index (in the split clause) to split on -- next. -- -- The matcher here checks whether the split clause is covered by one of -- the given clauses cs or whether further splitting is needed -- (and when yes, where). module Agda.TypeChecking.Coverage.Match -- | If matching is inconclusive (Block) we want to know which -- variables or projections are blocking the match. data Match a -- | Matches unconditionally. Yes :: a -> Match a -- | Definitely does not match. No :: Match a Block :: BlockedOnResult -> BlockingVars -> Match a -- | BlockedOnProj o if the clause has a result split. [blockedOnResult] :: Match a -> BlockedOnResult -- | BlockingVar i cs ls o means variable i is blocked on -- constructors cs and literals ls. [blockedOnVars] :: Match a -> BlockingVars -- | Match the given patterns against a list of clauses. -- -- If successful, return the index of the covering clause. match :: PureTCM m => [Clause] -> [NamedArg SplitPattern] -> m (Match (Nat, SplitInstantiation)) -- | matchClause qs i c checks whether clause c covers a -- split clause with patterns qs. matchClause :: PureTCM m => [NamedArg SplitPattern] -> Clause -> m MatchResult type SplitPattern = Pattern' SplitPatVar -- | For each variable in the patterns of a split clause, we remember the -- de Bruijn-index and the literals excluded by previous matches. data SplitPatVar SplitPatVar :: PatVarName -> Int -> [Literal] -> SplitPatVar [splitPatVarName] :: SplitPatVar -> PatVarName [splitPatVarIndex] :: SplitPatVar -> Int [splitExcludedLits] :: SplitPatVar -> [Literal] fromSplitPattern :: NamedArg SplitPattern -> NamedArg DeBruijnPattern fromSplitPatterns :: [NamedArg SplitPattern] -> [NamedArg DeBruijnPattern] toSplitPatterns :: [NamedArg DeBruijnPattern] -> [NamedArg SplitPattern] toSplitPSubst :: PatternSubstitution -> SplitPSubstitution applySplitPSubst :: TermSubst a => SplitPSubstitution -> a -> a -- | A pattern that matches anything (modulo eta). isTrivialPattern :: HasConstInfo m => Pattern' a -> m Bool -- | Variable blocking a match. data BlockingVar BlockingVar :: Nat -> [ConHead] -> [Literal] -> Bool -> Bool -> BlockingVar -- | De Bruijn index of variable blocking the match. [blockingVarNo] :: BlockingVar -> Nat -- | Constructors in this position. [blockingVarCons] :: BlockingVar -> [ConHead] -- | Literals in this position. [blockingVarLits] :: BlockingVar -> [Literal] -- | True if at least one clause has a variable pattern in this position. [blockingVarOverlap] :: BlockingVar -> Bool -- | True if at least one clause has a lazy pattern in this position. [blockingVarLazy] :: BlockingVar -> Bool type BlockingVars = [BlockingVar] -- | Missing elimination blocking a match. data BlockedOnResult -- | Blocked on unsplit projection. BlockedOnProj :: Bool -> BlockedOnResult -- | True if there are also matching clauses without an unsplit copattern. [blockedOnResultOverlap] :: BlockedOnResult -> Bool -- | Blocked on unintroduced argument. BlockedOnApply :: ApplyOrIApply -> BlockedOnResult -- | Is the unintroduced argument an IApply pattern? [blockedOnResultIApply] :: BlockedOnResult -> ApplyOrIApply NotBlockedOnResult :: BlockedOnResult setBlockingVarOverlap :: BlockingVar -> BlockingVar data ApplyOrIApply IsApply :: ApplyOrIApply IsIApply :: ApplyOrIApply instance GHC.Show.Show Agda.TypeChecking.Coverage.Match.BlockingVar instance GHC.Base.Functor Agda.TypeChecking.Coverage.Match.Match instance GHC.Show.Show Agda.TypeChecking.Coverage.Match.SplitPatVar instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Coverage.Match.SplitPattern instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Coverage.Match.SplitPatVar instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Coverage.Match.SplitPatVar instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.TypeChecking.Coverage.Match.SplitPatVar instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Coverage.Match.BlockingVar -- | SplitClause and CoverResult types. module Agda.TypeChecking.Coverage.SplitClause data SplitClause SClause :: Telescope -> [NamedArg SplitPattern] -> Substitution' SplitPattern -> Map CheckpointId Substitution -> Maybe (Dom Type) -> SplitClause -- | Type of variables in scPats. [scTel] :: SplitClause -> Telescope -- | The patterns leading to the currently considered branch of the split -- tree. [scPats] :: SplitClause -> [NamedArg SplitPattern] -- | Substitution from scTel to old context. Only needed directly -- after split on variable: * To update scTarget * To rename other -- split variables when splitting on multiple variables. scSubst -- is not `transitive', i.e., does not record the substitution -- from the original context to scTel over a series of splits. It -- is freshly computed after each split by computeNeighborhood; -- also splitResult, which does not split on a variable, should -- reset it to the identity idS, lest it be applied to -- scTarget again, leading to Issue 1294. [scSubst] :: SplitClause -> Substitution' SplitPattern -- | We need to keep track of the module parameter checkpoints for the -- clause for the purpose of inferring missing instance clauses. [scCheckpoints] :: SplitClause -> Map CheckpointId Substitution -- | The type of the rhs, living in context scTel. -- fixTargetType computes the new scTarget by applying -- substitution scSubst. [scTarget] :: SplitClause -> Maybe (Dom Type) data UnifyEquiv UE :: Telescope -> Telescope -> Telescope -> [Term] -> [Term] -> PatternSubstitution -> Substitution -> Substitution -> UnifyEquiv [infoTel0] :: UnifyEquiv -> Telescope [infoTel] :: UnifyEquiv -> Telescope [infoEqTel] :: UnifyEquiv -> Telescope [infoEqLHS] :: UnifyEquiv -> [Term] [infoEqRHS] :: UnifyEquiv -> [Term] [infoRho] :: UnifyEquiv -> PatternSubstitution [infoTau] :: UnifyEquiv -> Substitution [infoLeftInv] :: UnifyEquiv -> Substitution data IInfo TheInfo :: UnifyEquiv -> IInfo NoInfo :: IInfo -- | A Covering is the result of splitting a SplitClause. data Covering Covering :: Arg Nat -> [(SplitTag, (SplitClause, IInfo))] -> Covering -- | De Bruijn level (counting dot patterns) of argument we split on. [covSplitArg] :: Covering -> Arg Nat -- | Covering clauses, indexed by constructor/literal these clauses share. [covSplitClauses] :: Covering -> [(SplitTag, (SplitClause, IInfo))] -- | Project the split clauses out of a covering. splitClauses :: Covering -> [SplitClause] -- | Create a split clause from a clause in internal syntax. Used by -- make-case. clauseToSplitClause :: Clause -> SplitClause data CoverResult CoverResult :: SplitTree -> IntSet -> [(Telescope, [NamedArg DeBruijnPattern])] -> [Clause] -> IntSet -> CoverResult [coverSplitTree] :: CoverResult -> SplitTree [coverUsedClauses] :: CoverResult -> IntSet [coverMissingClauses] :: CoverResult -> [(Telescope, [NamedArg DeBruijnPattern])] -- | The set of patterns used as cover. [coverPatterns] :: CoverResult -> [Clause] [coverNoExactClauses] :: CoverResult -> IntSet instance GHC.Show.Show Agda.TypeChecking.Coverage.SplitClause.UnifyEquiv instance GHC.Show.Show Agda.TypeChecking.Coverage.SplitClause.IInfo module Agda.TypeChecking.Coverage.Cubical createMissingIndexedClauses :: QName -> Arg Nat -> BlockingVar -> SplitClause -> [(SplitTag, (SplitClause, IInfo))] -> [Clause] -> TCM ([(SplitTag, CoverResult)], [Clause]) covFillTele :: QName -> Abs Telescope -> Term -> Args -> Term -> TCM [Term] createMissingTrXTrXClause :: QName -> QName -> Arg Nat -> BlockingVar -> SplitClause -> TCM Clause createMissingTrXHCompClause :: QName -> QName -> Arg Nat -> BlockingVar -> SplitClause -> TCM Clause createMissingTrXConClause :: QName -> QName -> Arg Nat -> BlockingVar -> SplitClause -> QName -> UnifyEquiv -> TCM Clause -- | If given TheInfo{} then assumes "x : Id u v" and returns both -- a SplittingDone for conId, and the Clause that -- covers it. createMissingConIdClause :: QName -> Arg Nat -> BlockingVar -> SplitClause -> IInfo -> TCM (Maybe ((SplitTag, SplitTree), Clause)) -- | Append an hcomp clause to the clauses of a function. createMissingHCompClause :: QName -> Arg Nat -> BlockingVar -> SplitClause -> SplitClause -> [Clause] -> TCM ([(SplitTag, CoverResult)], [Clause]) -- | Generates data used for precise syntax highlighting. module Agda.Interaction.Highlighting.Generate -- | Highlighting levels. data Level -- | Full highlighting. Should only be used after typechecking has -- completed successfully. Full :: Level -- | Highlighting without disambiguation of overloaded constructors. Partial :: Level -- | Generate syntax highlighting information for the given declaration, -- and (if appropriate) print it. If the boolean is True, then the -- state is additionally updated with the new highlighting info (in case -- of a conflict new info takes precedence over old info). -- -- The procedure makes use of some of the highlighting info corresponding -- to stTokens (that corresponding to the interval covered by the -- declaration). If the boolean is True, then this highlighting -- info is additionally removed from the data structure that -- stTokens refers to. generateAndPrintSyntaxInfo :: Declaration -> Level -> Bool -> TCM () -- | Generate and return the syntax highlighting information for the tokens -- in the given file. generateTokenInfo :: AbsolutePath -> TCM HighlightingInfo -- | Generate and return the syntax highlighting information for the tokens -- in the given file. generateTokenInfoFromSource :: RangeFile -> String -> TCM HighlightingInfo -- | Generate and return the syntax highlighting information for the tokens -- in the given string, which is assumed to correspond to the given -- range. generateTokenInfoFromString :: Range -> String -> TCM HighlightingInfo printSyntaxInfo :: Range -> TCM () -- | Prints syntax highlighting info for an error. printErrorInfo :: TCErr -> TCM () -- | Generate highlighting for error. errorHighlighting :: TCErr -> TCM HighlightingInfoBuilder -- | Generates and prints syntax highlighting information for unsolved -- meta-variables and certain unsolved constraints. printUnsolvedInfo :: TCM () -- | Lispify and print the given highlighting information. printHighlightingInfo :: MonadTrace m => RemoveTokenBasedHighlighting -> HighlightingInfo -> m () -- | highlightAsTypeChecked rPre r m runs m and returns -- its result. Additionally, some code may be highlighted: -- -- highlightAsTypeChecked :: MonadTrace m => Range -> Range -> m a -> m a -- | Highlight a warning. We do not generate highlighting for unsolved -- metas and constraints, as that gets handled in bulk after -- typechecking. highlightWarning :: TCWarning -> TCM () -- | Generate syntax highlighting for warnings. warningHighlighting :: TCWarning -> HighlightingInfoBuilder computeUnsolvedInfo :: TCM HighlightingInfoBuilder storeDisambiguatedConstructor :: Induction -> QName -> TCM () storeDisambiguatedProjection :: QName -> TCM () -- | Store a disambiguation of record field tags for the purpose of -- highlighting. disambiguateRecordFields :: [Name] -> [QName] -> TCM () instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Generate.NameKindBuilder instance GHC.Base.Monoid Agda.Interaction.Highlighting.Generate.NameKindBuilder instance Agda.Utils.Singleton.Singleton Agda.Syntax.Abstract.Views.KName Agda.Interaction.Highlighting.Generate.NameKindBuilder instance Agda.Utils.Singleton.Collection Agda.Syntax.Abstract.Views.KName Agda.Interaction.Highlighting.Generate.NameKindBuilder -- | Extract highlighting syntax from abstract syntax. -- -- Implements one big fold over abstract syntax. module Agda.Interaction.Highlighting.FromAbstract -- | Create highlighting info for some piece of syntax. runHighlighter :: Hilite a => TopLevelModuleName -> NameKinds -> a -> HighlightingInfoBuilder -- | A function mapping names to the kind of name they stand for. type NameKinds = QName -> Maybe NameKind instance (Agda.Interaction.Highlighting.FromAbstract.Hilite m, Agda.Interaction.Highlighting.FromAbstract.Hilite n, Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo m), Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo n)) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.ImportDirective' m n) instance (Agda.Interaction.Highlighting.FromAbstract.Hilite m, Agda.Interaction.Highlighting.FromAbstract.Hilite n, Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo m), Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo n)) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.Renaming' m n) instance Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo Agda.Syntax.Abstract.Name.QName) instance Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo Agda.Syntax.Abstract.Name.ModuleName) instance (Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo m), Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo n)) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Interaction.Highlighting.FromAbstract.RenamingTo (Agda.Syntax.Common.ImportedName' m n)) instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite [a] instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Utils.List1.List1 a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (GHC.Maybe.Maybe a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.WithHiding a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Data.Void.Void instance (Agda.Interaction.Highlighting.FromAbstract.Hilite a, Agda.Interaction.Highlighting.FromAbstract.Hilite b) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Data.Either.Either a b) instance (Agda.Interaction.Highlighting.FromAbstract.Hilite a, Agda.Interaction.Highlighting.FromAbstract.Hilite b) => Agda.Interaction.Highlighting.FromAbstract.Hilite (a, b) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.RecordDirectives instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.Declaration instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.Pragma instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.Expr instance (Agda.Interaction.Highlighting.FromAbstract.Hilite a, Agda.Syntax.Abstract.Name.IsProjP a) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Abstract.Pattern' a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Literal.Literal instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.LHS instance (Agda.Interaction.Highlighting.FromAbstract.Hilite a, Agda.Syntax.Abstract.Name.IsProjP a) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Abstract.LHSCore' a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.RHS instance (Agda.Syntax.Position.HasRange n, Agda.Interaction.Highlighting.FromAbstract.Hilite p, Agda.Interaction.Highlighting.FromAbstract.Hilite e) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.RewriteEqn' x n p e) instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Abstract.Clause' a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.ProblemEq instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.WhereDeclarations instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.GeneralizeTelescope instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.DataDefParams instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.ModuleApplication instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.LetBinding instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.TypedBindingInfo instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.TypedBinding instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.LamBinding instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Abstract.Binder' a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.BindName instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.Interaction.Highlighting.FromAbstract.Hilite a, Agda.Syntax.Position.HasRange n) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.Named n a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite a => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.Arg a) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Common.ArgInfo instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Common.Modality instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Common.Quantity instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Common.Erased instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Info.ModuleInfo instance (Agda.Interaction.Highlighting.FromAbstract.Hilite m, Agda.Interaction.Highlighting.FromAbstract.Hilite n) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.Using' m n) instance (Agda.Interaction.Highlighting.FromAbstract.Hilite m, Agda.Interaction.Highlighting.FromAbstract.Hilite n) => Agda.Interaction.Highlighting.FromAbstract.Hilite (Agda.Syntax.Common.ImportedName' m n) instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.TypeChecking.Monad.Base.DisambiguatedName instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Scope.Base.ResolvedName instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.Name.QName instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.Interaction.Highlighting.FromAbstract.Hilite Agda.Syntax.Abstract.Name.ModuleName instance GHC.Base.Monoid Agda.Interaction.Highlighting.FromAbstract.Hiliter module Agda.TypeChecking.Rules.Decl -- | Cached checkDecl checkDeclCached :: Declaration -> TCM () -- | Type check a sequence of declarations. checkDecls :: [Declaration] -> TCM () -- | Type check a single declaration. checkDecl :: Declaration -> TCM () mutualChecks :: MutualInfo -> Declaration -> [Declaration] -> MutualId -> Set QName -> TCM () -- | Check if there is a inferred eta record type in the mutual block. If -- yes, repeat the record pattern translation for all function -- definitions in the block. This is necessary since the original record -- pattern translation will have skipped record patterns of the new -- record types (as eta was off for them). See issue #2308 (and #2197). revisitRecordPatternTranslation :: [QName] -> TCM () type FinalChecks = Maybe (TCM ()) checkUnquoteDecl :: MutualInfo -> [DefInfo] -> [QName] -> Expr -> TCM FinalChecks checkUnquoteDef :: [DefInfo] -> [QName] -> Expr -> TCM () -- | Run a reflected TCM computatation expected to define a given list of -- names. unquoteTop :: [QName] -> Expr -> TCM [QName] -- | Instantiate all metas in Definition associated to QName. -- Makes sense after freezing metas. Some checks, like free variable -- analysis, are not in TCMT, so they will be more precise (see -- issue 1099) after meta instantiation. Precondition: name has been -- added to signature already. instantiateDefinitionType :: QName -> TCM () data HighlightModuleContents DontHightlightModuleContents :: HighlightModuleContents DoHighlightModuleContents :: HighlightModuleContents -- | Highlight a declaration. Called after checking a mutual block (to -- ensure we have the right definitions for all names). For modules -- inside mutual blocks we haven't highlighted their contents, but for -- modules not in a mutual block we have. Hence the flag. highlight_ :: HighlightModuleContents -> Declaration -> TCM () -- | Termination check a declaration. checkTermination_ :: Declaration -> TCM () -- | Check a set of mutual names for positivity. checkPositivity_ :: MutualInfo -> Set QName -> TCM () -- | Check that all coinductive records are actually recursive. (Otherwise, -- one can implement invalid recursion schemes just like for the old -- coinduction.) checkCoinductiveRecords :: [Declaration] -> TCM () -- | Check a set of mutual names for constructor-headedness. checkInjectivity_ :: Set QName -> TCM () -- | Check a set of mutual names for projection likeness. -- -- Only a single, non-abstract function can be projection-like. Making an -- abstract function projection-like would break the invariant that the -- type of the principle argument of a projection-like function is always -- inferable. checkProjectionLikeness_ :: Set QName -> TCM () -- | Freeze metas created by given computation if in abstract mode. whenAbstractFreezeMetasAfter :: DefInfo -> TCM a -> TCM a checkGeneralize :: Set QName -> DefInfo -> ArgInfo -> QName -> Expr -> TCM () -- | Type check an axiom. checkAxiom :: KindOfName -> DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> Expr -> TCM () -- | Data and record type signatures need to remember the generalized -- parameters for when checking the corresponding definition, so for -- these we pass in the parameter telescope separately. checkAxiom' :: Maybe GeneralizeTelescope -> KindOfName -> DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> Expr -> TCM () -- | Type check a primitive function declaration. checkPrimitive :: DefInfo -> QName -> Arg Expr -> TCM () -- | Check a pragma. checkPragma :: Range -> Pragma -> TCM () -- | Type check a bunch of mutual inductive recursive definitions. -- -- All definitions which have so far been assigned to the given mutual -- block are returned. checkMutual :: MutualInfo -> [Declaration] -> TCM (MutualId, Set QName) checkSig :: KindOfName -> DefInfo -> QName -> GeneralizeTelescope -> Expr -> TCM () -- | Type check the type signature of an inductive or recursive definition. checkTypeSignature :: TypeSignature -> TCM () checkTypeSignature' :: Maybe GeneralizeTelescope -> TypeSignature -> TCM () -- | Type check a module. checkSection :: ModuleName -> GeneralizeTelescope -> [Declaration] -> TCM () -- | Helper for checkSectionApplication. -- -- Matches the arguments of the module application with the module -- parameters. -- -- Returns the remaining module parameters as an open telescope. Warning: -- the returned telescope is not the final result, an actual -- instantiation of the parameters does not occur. checkModuleArity :: ModuleName -> Telescope -> [NamedArg Expr] -> TCM Telescope -- | Check an application of a section. checkSectionApplication :: ModuleInfo -> ModuleName -> ModuleApplication -> ScopeCopyInfo -> TCM () -- | Check an application of a section. (Do not invoke this procedure -- directly, use checkSectionApplication.) checkSectionApplication' :: ModuleInfo -> ModuleName -> ModuleApplication -> ScopeCopyInfo -> TCM () -- | Type check an import declaration. Actually doesn't do anything, since -- all the work is done when scope checking. checkImport :: ModuleInfo -> ModuleName -> TCM () class ShowHead a showHead :: ShowHead a => a -> String debugPrintDecl :: Declaration -> TCM () instance GHC.Classes.Eq Agda.TypeChecking.Rules.Decl.HighlightModuleContents instance Agda.TypeChecking.Rules.Decl.ShowHead Agda.Syntax.Abstract.Declaration module Agda.TypeChecking.Rules.Record -- |
--   checkRecDef i name con ps contel fields
--   
-- -- checkRecDef :: DefInfo -> QName -> UniverseCheck -> RecordDirectives -> DataDefParams -> Expr -> [Field] -> TCM () addCompositionForRecord :: QName -> ConHead -> Telescope -> [Arg QName] -> Telescope -> Type -> TCM () defineCompKitR :: QName -> Telescope -> Telescope -> [Arg QName] -> Type -> TCM CompKit defineKanOperationR :: Command -> QName -> Telescope -> Telescope -> [Arg QName] -> Type -> TCM (Maybe QName) -- | checkRecordProjections m r q tel ftel fs. -- -- checkRecordProjections :: ModuleName -> QName -> Bool -> ConHead -> Telescope -> Telescope -> [Declaration] -> TCM () -- | Checking local or global confluence of rewrite rules. -- -- For checking LOCAL CONFLUENCE of a given rewrite rule f ps ↦ -- v, we construct critical pairs involving this as the main rule by -- searching for: -- --
    --
  1. *Different* rules f ps' ↦ v' where ps and -- ps' can be unified@.
  2. --
  3. Subpatterns g qs of ps and rewrite rules g -- qs' ↦ w where qs and qs' can be unified.
  4. --
-- -- Each of these leads to a *critical pair* v₁ u -- v₂, -- which should satisfy v₁ = v₂. -- -- For checking GLOBAL CONFLUENCE, we check the following two properties: -- --
    --
  1. For any two left-hand sides of the rewrite rules that overlap -- (either at the root position or at a subterm), the most general -- unifier of the two left-hand sides is again a left-hand side of a -- rewrite rule. For example, if there are two rules suc m + n = suc -- (m + n) and m + suc n = suc (m + n), then there should -- also be a rule suc m + suc n = suc (suc (m + n)).
  2. --
  3. Each rewrite rule should satisfy the *triangle property*: For any -- rewrite rule u = w and any single-step parallel unfolding -- u => v, we should have another single-step parallel -- unfolding v => w.
  4. --
module Agda.TypeChecking.Rewriting.Confluence checkConfluenceOfRules :: ConfluenceCheck -> [RewriteRule] -> TCM () -- | Check confluence of the given rewrite rules wrt all other rewrite -- rules (also amongst themselves). -- -- Check confluence of the clauses of the given function wrt rewrite -- rules of the constructors they match against checkConfluenceOfClauses :: ConfluenceCheck -> QName -> TCM () sortRulesOfSymbol :: QName -> TCM () instance GHC.Base.Functor Agda.TypeChecking.Rewriting.Confluence.OneHole instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars a => Agda.TypeChecking.Rewriting.Confluence.MetasToVars [a] instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars a => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars a => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars a => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars a => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars Agda.Syntax.Internal.Term instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars Agda.Syntax.Internal.Type instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars Agda.Syntax.Internal.Level instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Rewriting.Confluence.MetasToVars a => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (Agda.Syntax.Internal.Tele a) instance (Agda.TypeChecking.Rewriting.Confluence.MetasToVars a, Agda.TypeChecking.Rewriting.Confluence.MetasToVars b) => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (a, b) instance (Agda.TypeChecking.Rewriting.Confluence.MetasToVars a, Agda.TypeChecking.Rewriting.Confluence.MetasToVars b, Agda.TypeChecking.Rewriting.Confluence.MetasToVars c) => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (a, b, c) instance (Agda.TypeChecking.Rewriting.Confluence.MetasToVars a, Agda.TypeChecking.Rewriting.Confluence.MetasToVars b, Agda.TypeChecking.Rewriting.Confluence.MetasToVars c, Agda.TypeChecking.Rewriting.Confluence.MetasToVars d) => Agda.TypeChecking.Rewriting.Confluence.MetasToVars (a, b, c, d) instance Agda.TypeChecking.Rewriting.Confluence.AllHoles p => Agda.TypeChecking.Rewriting.Confluence.AllHoles (Agda.Syntax.Common.Arg p) instance Agda.TypeChecking.Rewriting.Confluence.AllHoles p => Agda.TypeChecking.Rewriting.Confluence.AllHoles (Agda.Syntax.Internal.Dom p) instance Agda.TypeChecking.Rewriting.Confluence.AllHoles (Agda.Syntax.Internal.Abs Agda.Syntax.Internal.Term) instance Agda.TypeChecking.Rewriting.Confluence.AllHoles (Agda.Syntax.Internal.Abs Agda.Syntax.Internal.Type) instance Agda.TypeChecking.Rewriting.Confluence.AllHoles Agda.Syntax.Internal.Elims instance Agda.TypeChecking.Rewriting.Confluence.AllHoles Agda.Syntax.Internal.Type instance Agda.TypeChecking.Rewriting.Confluence.AllHoles Agda.Syntax.Internal.Term instance Agda.TypeChecking.Rewriting.Confluence.AllHoles Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Rewriting.Confluence.AllHoles Agda.Syntax.Internal.Level instance Agda.TypeChecking.Rewriting.Confluence.AllHoles [Agda.Syntax.Internal.PlusLevel] instance Agda.TypeChecking.Rewriting.Confluence.AllHoles Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce Agda.Syntax.Internal.Term instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce a => Agda.TypeChecking.Rewriting.Confluence.ParallelReduce (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce a => Agda.TypeChecking.Rewriting.Confluence.ParallelReduce (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce a => Agda.TypeChecking.Rewriting.Confluence.ParallelReduce (Agda.Syntax.Internal.Type' a) instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce a => Agda.TypeChecking.Rewriting.Confluence.ParallelReduce [a] instance Agda.TypeChecking.Rewriting.Confluence.ParallelReduce a => Agda.TypeChecking.Rewriting.Confluence.ParallelReduce (Agda.Syntax.Internal.Elim.Elim' a) instance (Agda.TypeChecking.Free.Lazy.Free a, Agda.TypeChecking.Substitute.Class.Subst a, Agda.TypeChecking.Rewriting.Confluence.ParallelReduce a) => Agda.TypeChecking.Rewriting.Confluence.ParallelReduce (Agda.Syntax.Internal.Abs a) -- | Non-linear matching of the lhs of a rewrite rule against a neutral -- term. -- -- Given a lhs -- -- Δ ⊢ lhs : B -- -- and a candidate term -- -- Γ ⊢ t : A -- -- we seek a substitution Γ ⊢ σ : Δ such that -- -- Γ ⊢ B[σ] = A and Γ ⊢ lhs[σ] = t : A module Agda.TypeChecking.Rewriting.NonLinMatch -- | Monad for non-linear matching. newtype NLM a NLM :: ExceptT Blocked_ (StateT NLMState ReduceM) a -> NLM a [unNLM] :: NLM a -> ExceptT Blocked_ (StateT NLMState ReduceM) a data NLMState NLMState :: Sub -> PostponedEquations -> NLMState [_nlmSub] :: NLMState -> Sub [_nlmEqs] :: NLMState -> PostponedEquations nlmSub :: Lens' Sub NLMState nlmEqs :: Lens' PostponedEquations NLMState runNLM :: MonadReduce m => NLM () -> m (Either Blocked_ NLMState) matchingBlocked :: Blocked_ -> NLM () -- | Add substitution i |-> v : a to result of matching. tellSub :: Relevance -> Int -> Type -> Term -> NLM () tellEq :: Telescope -> Telescope -> Type -> Term -> Term -> NLM () type Sub = IntMap (Relevance, Term) -- | Matching against a term produces a constraint which we have to verify -- after applying the substitution computed by matching. data PostponedEquation PostponedEquation :: Telescope -> Type -> Term -> Term -> PostponedEquation -- | Telescope of free variables in the equation [eqFreeVars] :: PostponedEquation -> Telescope -- | Type of the equation, living in same context as the rhs. [eqType] :: PostponedEquation -> Type -- | Term from pattern, living in pattern context. [eqLhs] :: PostponedEquation -> Term -- | Term from scrutinee, living in context where matching was invoked. [eqRhs] :: PostponedEquation -> Term type PostponedEquations = [PostponedEquation] -- | Match a non-linear pattern against a neutral term, returning a -- substitution. class Match t a b match :: Match t a b => Relevance -> Telescope -> Telescope -> t -> a -> b -> NLM () makeSubstitution :: Telescope -> Sub -> Maybe Substitution checkPostponedEquations :: PureTCM m => Substitution -> PostponedEquations -> m (Maybe Blocked_) nonLinMatch :: (PureTCM m, Match t a b) => Telescope -> t -> a -> b -> m (Either Blocked_ Substitution) -- | Typed βη-equality, also handles empty record types. Returns -- Nothing if the terms are equal, or `Just b` if the terms are -- not (where b contains information about possible metas blocking the -- comparison) equal :: PureTCM m => Type -> Term -> Term -> m (Maybe Blocked_) -- | Utility function for getting the name and type of a head term (i.e. a -- Def or Con with no arguments) getTypedHead :: PureTCM m => Term -> m (Maybe (QName, Type)) instance Agda.TypeChecking.Monad.Pure.PureTCM Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Debug.MonadDebug Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Context.MonadAddContext Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Base.MonadReduce Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.Interaction.Options.HasOptions.HasOptions Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Signature.HasConstInfo Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Monad.Builtin.HasBuiltins Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Control.Monad.State.Class.MonadState Agda.TypeChecking.Rewriting.NonLinMatch.NLMState Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Control.Monad.Error.Class.MonadError Agda.Syntax.Internal.Blocked_ Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance GHC.Base.MonadPlus Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance GHC.Base.Alternative Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Control.Monad.Fail.MonadFail Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance GHC.Base.Monad Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance GHC.Base.Applicative Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance GHC.Base.Functor Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.TypeChecking.Rewriting.NonLinMatch.Match t a b => Agda.TypeChecking.Rewriting.NonLinMatch.Match (Agda.Syntax.Internal.Dom t) (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b) instance Agda.TypeChecking.Rewriting.NonLinMatch.Match (Agda.Syntax.Internal.Type, Agda.Syntax.Internal.Elims -> Agda.Syntax.Internal.Term) [Agda.Syntax.Internal.Elim.Elim' Agda.TypeChecking.Monad.Base.NLPat] Agda.Syntax.Internal.Elims instance Agda.TypeChecking.Rewriting.NonLinMatch.Match t a b => Agda.TypeChecking.Rewriting.NonLinMatch.Match t (Agda.Syntax.Internal.Dom a) (Agda.Syntax.Internal.Dom b) instance Agda.TypeChecking.Rewriting.NonLinMatch.Match () Agda.TypeChecking.Monad.Base.NLPType Agda.Syntax.Internal.Type instance Agda.TypeChecking.Rewriting.NonLinMatch.Match () Agda.TypeChecking.Monad.Base.NLPSort Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Rewriting.NonLinMatch.Match () Agda.TypeChecking.Monad.Base.NLPat Agda.Syntax.Internal.Level instance Agda.TypeChecking.Rewriting.NonLinMatch.Match Agda.Syntax.Internal.Type Agda.TypeChecking.Monad.Base.NLPat Agda.Syntax.Internal.Term instance Agda.TypeChecking.Monad.Base.MonadBlock Agda.TypeChecking.Rewriting.NonLinMatch.NLM instance Agda.Utils.Null.Null Agda.TypeChecking.Rewriting.NonLinMatch.NLMState module Agda.TypeChecking.Rewriting.Clause -- | Get all the clauses of a definition and convert them to rewrite rules. getClausesAsRewriteRules :: (HasConstInfo m, MonadFresh NameId m) => QName -> m [RewriteRule] -- | Generate a sensible name for the given clause clauseQName :: (HasConstInfo m, MonadFresh NameId m) => QName -> Int -> m QName -- | clauseToRewriteRule f q cl converts the clause cl of -- the function f to a rewrite rule with name q. -- Returns Nothing if clauseBody cl is -- Nothing. Precondition: clauseType cl is not -- Nothing. clauseToRewriteRule :: QName -> QName -> Clause -> Maybe RewriteRule class ToNLPat a b toNLPat :: ToNLPat a b => a -> b toNLPat :: (ToNLPat a b, ToNLPat a' b', Functor f, a ~ f a', b ~ f b') => a -> b instance Agda.TypeChecking.Rewriting.Clause.ToNLPat a b => Agda.TypeChecking.Rewriting.Clause.ToNLPat [a] [b] instance Agda.TypeChecking.Rewriting.Clause.ToNLPat a b => Agda.TypeChecking.Rewriting.Clause.ToNLPat (Agda.Syntax.Internal.Dom a) (Agda.Syntax.Internal.Dom b) instance Agda.TypeChecking.Rewriting.Clause.ToNLPat a b => Agda.TypeChecking.Rewriting.Clause.ToNLPat (Agda.Syntax.Internal.Elim.Elim' a) (Agda.Syntax.Internal.Elim.Elim' b) instance Agda.TypeChecking.Rewriting.Clause.ToNLPat a b => Agda.TypeChecking.Rewriting.Clause.ToNLPat (Agda.Syntax.Internal.Abs a) (Agda.Syntax.Internal.Abs b) instance Agda.TypeChecking.Rewriting.Clause.ToNLPat (Agda.Syntax.Common.Arg Agda.Syntax.Internal.DeBruijnPattern) (Agda.Syntax.Internal.Elim.Elim' Agda.TypeChecking.Monad.Base.NLPat) instance Agda.TypeChecking.Rewriting.Clause.ToNLPat (Agda.Syntax.Common.NamedArg Agda.Syntax.Internal.DeBruijnPattern) (Agda.Syntax.Internal.Elim.Elim' Agda.TypeChecking.Monad.Base.NLPat) module Agda.TypeChecking.Rules.Display checkDisplayPragma :: QName -> [NamedArg Pattern] -> Expr -> TCM () module Agda.TypeChecking.Rules.Builtin -- | Bind a builtin thing to an expression. bindBuiltin :: String -> ResolvedName -> TCM () -- | Bind a builtin thing to a new name. -- -- Since their type is closed, it does not matter whether we are in a -- parameterized module when we declare them. We simply ignore the -- parameters. bindBuiltinNoDef :: String -> QName -> TCM () builtinKindOfName :: String -> Maybe KindOfName -- | bindPostulatedName builtin q m checks that q is a -- postulated name, and binds the builtin builtin to the term -- m q def, where def is the current Definition -- of q. bindPostulatedName :: String -> ResolvedName -> (QName -> Definition -> TCM Term) -> TCM () isUntypedBuiltin :: String -> Bool bindUntypedBuiltin :: String -> ResolvedName -> TCM () -- | Handling of the INFINITY, SHARP and FLAT builtins. module Agda.TypeChecking.Rules.Builtin.Coinduction -- | The type of . typeOfInf :: TCM Type -- | The type of ♯_. typeOfSharp :: TCM Type -- | The type of . typeOfFlat :: TCM Type -- | Binds the INFINITY builtin, but does not change the type's definition. bindBuiltinInf :: ResolvedName -> TCM () -- | Binds the SHARP builtin, and changes the definitions of INFINITY and -- SHARP. bindBuiltinSharp :: ResolvedName -> TCM () -- | Binds the FLAT builtin, and changes its definition. bindBuiltinFlat :: ResolvedName -> TCM () module Agda.TypeChecking.Rules.Application -- | checkArguments cmp exph r args t0 t k tries -- checkArgumentsE exph args t0 t. If it succeeds, it continues -- k with the returned results. If it fails, it registers a -- postponed typechecking problem and returns the resulting new meta -- variable. -- -- Checks e := ((_ : t0) args) : t. checkArguments :: Comparison -> ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term -- | Check that a list of arguments fits a telescope. Inserts hidden -- arguments as necessary. Returns the type-checked arguments and the -- remaining telescope. checkArguments_ :: Comparison -> ExpandHidden -> Range -> [NamedArg Expr] -> Telescope -> TCM (Elims, Telescope) -- | checkApplication hd args e t checks an application. -- Precondition: Application hs args = appView e -- -- checkApplication disambiguates constructors (and continues to -- checkConstructorApplication) and resolves pattern synonyms. checkApplication :: Comparison -> Expr -> Args -> Expr -> Type -> TCM Term -- | Precondition: Application hd args = appView e. inferApplication :: ExpandHidden -> Expr -> Args -> Expr -> TCM (Term, Type) -- | Checking the type of an overloaded projection application. See -- inferOrCheckProjAppToKnownPrincipalArg. checkProjAppToKnownPrincipalArg :: Comparison -> Expr -> ProjOrigin -> List1 QName -> Args -> Type -> Int -> Term -> Type -> PrincipalArgTypeMetas -> TCM Term -- | Injectivity, or more precisely, "constructor headedness", is a -- property of functions defined by pattern matching that helps us solve -- constraints involving blocked applications of such functions. -- Blocked shall mean here that pattern matching is blocked on a -- meta variable, and constructor headedness lets us learn more about -- that meta variable. -- -- Consider the simple example: isZero : Nat -> Bool isZero zero -- = true isZero (suc n) = false This function is -- constructor-headed, meaning that all rhss are headed by a distinct -- constructor. Thus, on a constraint like isZero ?X = false : Bool -- involving an application of isZero that is blocked on -- meta variable ?X, we can exploit injectivity and learn that -- ?X = suc ?Y for a new meta-variable ?Y. -- -- Which functions qualify for injectivity? -- --
    --
  1. The function needs to have at least one non-absurd clause that has -- a proper match, meaning that the function can actually be blocked on a -- meta. Proper matches are these patterns:
  2. --
-- -- -- -- Projection patterns (ProjP) are excluded because metas cannot -- occupy their place! -- --
    --
  1. All the clauses that satisfy (1.) need to be headed by a distinct -- constructor.
  2. --
module Agda.TypeChecking.Injectivity headSymbol :: Term -> TCM (Maybe TermHead) -- | Is this a matchable definition, or constructor, which reduces based on -- interval substitutions? isUnstableDef :: PureTCM m => QName -> m Bool -- | Do a full whnf and treat neutral terms as rigid. Used on the arguments -- to an injective functions and to the right-hand side. Only returns -- heads which are stable under interval substitution, i.e. NOT path -- constructors or generated hcomp/transp! headSymbol' :: (PureTCM m, MonadError TCErr m) => Term -> m (Maybe TermHead) -- | Does deBruijn variable i correspond to a top-level argument, and if so -- which one (index from the left). topLevelArg :: Clause -> Int -> Maybe TermHead -- | Join a list of inversion maps. joinHeadMaps :: [InversionMap c] -> InversionMap c -- | Update the heads of an inversion map. updateHeads :: Monad m => (TermHead -> [c] -> m TermHead) -> InversionMap c -> m (InversionMap c) checkInjectivity :: QName -> [Clause] -> TCM FunctionInverse -- | Precondition: all the given clauses are non-absurd and contain a -- proper match. checkInjectivity' :: QName -> [Clause] -> TCM FunctionInverse -- | If a clause is over-applied we can't trust the head (Issue 2944). For -- instance, the clause might be `f ps = u , v` and the actual call `f vs -- .fst`. In this case the head will be the head of u rather -- than `_,_`. checkOverapplication :: forall m. HasConstInfo m => Elims -> InversionMap Clause -> m (InversionMap Clause) -- | Turn variable heads, referring to top-level argument positions, into -- proper heads. These might still be VarHead, but in that case -- they refer to deBruijn variables. Checks that the instantiated heads -- are still rigid and distinct. instantiateVarHeads :: forall m c. (PureTCM m, MonadError TCErr m) => QName -> Elims -> InversionMap c -> m (Maybe (InversionMap c)) -- | Argument should be in weak head normal form. functionInverse :: (PureTCM m, MonadError TCErr m) => Term -> m InvView data InvView Inv :: QName -> [Elim] -> InversionMap Clause -> InvView NoInv :: InvView -- | Precondition: The first term must be blocked on the given meta and the -- second must be neutral. useInjectivity :: MonadConversion m => CompareDirection -> Blocker -> CompareAs -> Term -> Term -> m () -- | The second argument should be a blocked application and the third -- argument the inverse of the applied function. invertFunction :: MonadConversion m => Comparison -> Term -> InvView -> TermHead -> m () -> m () -> (Term -> m ()) -> m () forcePiUsingInjectivity :: Type -> TCM Type module Agda.TypeChecking.Level.Solve -- | Run the given action. At the end take all new metavariables of type -- level for which the only constraints are upper bounds on the level, -- and instantiate them to the lowest level. defaultOpenLevelsToZero :: (PureTCM m, MonadMetaSolver m) => m a -> m a defaultLevelsToZero :: forall m. (PureTCM m, MonadMetaSolver m) => LocalMetaStore -> m () module Agda.TypeChecking.MetaVars.Mention class MentionsMeta t mentionsMetas :: MentionsMeta t => HashSet MetaId -> t -> Bool mentionsMeta :: MentionsMeta t => MetaId -> t -> Bool instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.Term instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.Level instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.Blockers.Blocker instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.Type instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.Sort instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta t => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (Agda.Syntax.Internal.Abs t) instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta t => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (Agda.Syntax.Common.Arg t) instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta t => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (Agda.Syntax.Internal.Dom t) instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta t => Agda.TypeChecking.MetaVars.Mention.MentionsMeta [t] instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta t => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (GHC.Maybe.Maybe t) instance (Agda.TypeChecking.MetaVars.Mention.MentionsMeta a, Agda.TypeChecking.MetaVars.Mention.MentionsMeta b) => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (a, b) instance (Agda.TypeChecking.MetaVars.Mention.MentionsMeta a, Agda.TypeChecking.MetaVars.Mention.MentionsMeta b, Agda.TypeChecking.MetaVars.Mention.MentionsMeta c) => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (a, b, c) instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta a => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (Agda.TypeChecking.Monad.Base.Closure a) instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.Syntax.Internal.Elim instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta a => Agda.TypeChecking.MetaVars.Mention.MentionsMeta (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.TypeChecking.Monad.Base.Constraint instance Agda.TypeChecking.MetaVars.Mention.MentionsMeta Agda.TypeChecking.Monad.Base.CompareAs module Agda.TypeChecking.IApplyConfluence checkIApplyConfluence_ :: QName -> TCM () -- | addClause f (Clause {namedClausePats = ps}) checks that f -- ps reduces in a way that agrees with IApply reductions. checkIApplyConfluence :: QName -> Clause -> TCM () -- | current context is of the form Γ.Δ unifyElims :: Args -> Args -> (Substitution -> [(Term, Term)] -> TCM a) -> TCM a -- | Like unifyElims but Γ is from the the meta's -- MetaInfo and the context extension Δ is taken from -- the Closure. unifyElimsMeta :: MetaId -> Args -> Closure Constraint -> ([(Term, Term)] -> Constraint -> TCM a) -> TCM a module Agda.Termination.TermCheck -- | Entry point: Termination check a single declaration. -- -- Precondition: envMutualBlock must be set correctly. termDecl :: Declaration -> TCM Result -- | Entry point: Termination check the current mutual block. termMutual :: [QName] -> TCM Result -- | The result of termination checking a module. Must be a Monoid -- and have Singleton. type Result = [TerminationError] instance Agda.Termination.TermCheck.StripAllProjections a => Agda.Termination.TermCheck.StripAllProjections (Agda.Syntax.Common.Arg a) instance Agda.Termination.TermCheck.StripAllProjections Agda.Syntax.Internal.Elims instance Agda.Termination.TermCheck.StripAllProjections Agda.Syntax.Internal.Args instance Agda.Termination.TermCheck.StripAllProjections Agda.Syntax.Internal.Term instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls (Agda.Syntax.Internal.Abs a) instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls (Agda.Syntax.Common.Arg a) instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls (Agda.Syntax.Internal.Dom a) instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls [a] instance (Agda.Termination.TermCheck.ExtractCalls a, Agda.Termination.TermCheck.ExtractCalls b) => Agda.Termination.TermCheck.ExtractCalls (a, b) instance (Agda.Termination.TermCheck.ExtractCalls a, Agda.Termination.TermCheck.ExtractCalls b, Agda.Termination.TermCheck.ExtractCalls c) => Agda.Termination.TermCheck.ExtractCalls (a, b, c) instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.Sort instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.Type instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls (Agda.Syntax.Internal.Tele a) instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.Term instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.Level instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.PlusLevel instance Agda.Termination.TermCheck.TermToPattern a b => Agda.Termination.TermCheck.TermToPattern [a] [b] instance Agda.Termination.TermCheck.TermToPattern a b => Agda.Termination.TermCheck.TermToPattern (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b) instance Agda.Termination.TermCheck.TermToPattern a b => Agda.Termination.TermCheck.TermToPattern (Agda.Syntax.Common.Named c a) (Agda.Syntax.Common.Named c b) instance Agda.Termination.TermCheck.TermToPattern Agda.Syntax.Internal.Term Agda.Syntax.Internal.DeBruijnPattern -- | Checking for recursion: -- -- -- -- Original contribution by Andrea Vezzosi (sanzhiyan). This -- implementation by Andreas. module Agda.Termination.RecCheck -- | The mutual block we are checking. -- -- The functions are numbered according to their order of appearance in -- this set. type MutualNames = Set QName -- | Given a list of formally mutually recursive functions, check for -- actual recursive calls in the bodies of these functions. Returns the -- actually recursive functions as strongly connected components. -- -- As a side effect, update the clauseRecursive field in the -- clauses belonging to the given functions. recursive :: Set QName -> TCM [MutualNames] -- | anysDef names a returns all definitions from names -- that are used in a. anyDefs :: GetDefs a => (QName -> Bool) -> a -> TCM (Set QName) -- | The monad for the termination checker. -- -- The termination monad TerM is an extension of the type -- checking monad TCMT by an environment with information needed -- by the termination checker. module Agda.Termination.Monad -- | The target of the function we are checking. data Target -- | The target of recursion is a record, data, or -- unreducible Def. TargetDef :: QName -> Target -- | We are termination-checking a record. TargetRecord :: Target -- | None of the above two or unknown. TargetOther :: Target -- | The current guardedness level. type Guarded = Order -- | The termination environment. data TerEnv TerEnv :: Bool -> Maybe QName -> Maybe QName -> CutOff -> QName -> MutualNames -> Set QName -> Bool -> Target -> Delayed -> [Bool] -> Bool -> Int -> MaskedDeBruijnPatterns -> !Int -> !Guarded -> Bool -> VarSet -> TerEnv -- | Are we mining dot patterns to find evindence of structal descent? [terUseDotPatterns] :: TerEnv -> Bool -- | The name of size successor, if any. [terSizeSuc] :: TerEnv -> Maybe QName -- | The name of the delay constructor (sharp), if any. [terSharp] :: TerEnv -> Maybe QName -- | Depth at which to cut off the structural order. [terCutOff] :: TerEnv -> CutOff -- | The name of the function we are currently checking. [terCurrent] :: TerEnv -> QName -- | The names of the functions in the mutual block we are checking. This -- includes the internally generated functions (with, extendedlambda, -- coinduction). [terMutual] :: TerEnv -> MutualNames -- | The list of name actually appearing in the file (abstract syntax). -- Excludes the internally generated functions. [terUserNames] :: TerEnv -> Set QName -- | Does the actual clause result from with-inlining? (If yes, it may be -- ill-typed.) [terHaveInlinedWith] :: TerEnv -> Bool -- | Target type of the function we are currently termination checking. -- Only the constructors of Target are considered guarding. [terTarget] :: TerEnv -> Target -- | Are we checking a delayed definition? [terDelayed] :: TerEnv -> Delayed -- | Only consider the notMasked False arguments for -- establishing termination. See issue #1023. [terMaskArgs] :: TerEnv -> [Bool] -- | Only consider guardedness if False (not masked). [terMaskResult] :: TerEnv -> Bool -- | How many SIZELT relations do we have in the context (= clause -- telescope). Used to approximate termination for metas in call args. [_terSizeDepth] :: TerEnv -> Int -- | The patterns of the clause we are checking. [terPatterns] :: TerEnv -> MaskedDeBruijnPatterns -- | Number of additional binders we have gone under (and consequently need -- to raise the patterns to compare to terms). Updated during call graph -- extraction, hence strict. [terPatternsRaise] :: TerEnv -> !Int -- | The current guardedness status. Changes as we go deeper into the term. -- Updated during call graph extraction, hence strict. [terGuarded] :: TerEnv -> !Guarded -- | When extracting usable size variables during construction of the call -- matrix, can we take the variable for use with SIZELT constraints from -- the context? Yes, if we are under an inductive constructor. No, if we -- are under a record constructor. (See issue #1015). [terUseSizeLt] :: TerEnv -> Bool -- | Pattern variables that can be compared to argument variables using -- SIZELT. [terUsableVars] :: TerEnv -> VarSet -- | An empty termination environment. -- -- Values are set to a safe default meaning that with these initial -- values the termination checker will not miss termination errors it -- would have seen with better settings of these values. -- -- Values that do not have a safe default are set to -- IMPOSSIBLE. defaultTerEnv :: TerEnv -- | Termination monad service class. class (Functor m, Monad m) => MonadTer m terAsk :: MonadTer m => m TerEnv terLocal :: MonadTer m => (TerEnv -> TerEnv) -> m a -> m a terAsks :: MonadTer m => (TerEnv -> a) -> m a -- | Termination monad. newtype TerM a TerM :: ReaderT TerEnv TCM a -> TerM a [terM] :: TerM a -> ReaderT TerEnv TCM a -- | Generic run method for termination monad. runTer :: TerEnv -> TerM a -> TCM a -- | Run TerM computation in default environment (created from options). runTerDefault :: TerM a -> TCM a terGetUseDotPatterns :: TerM Bool terSetUseDotPatterns :: Bool -> TerM a -> TerM a terGetSizeSuc :: TerM (Maybe QName) terGetCurrent :: TerM QName terSetCurrent :: QName -> TerM a -> TerM a terGetSharp :: TerM (Maybe QName) terGetCutOff :: TerM CutOff terGetMutual :: TerM MutualNames terGetUserNames :: TerM (Set QName) terGetTarget :: TerM Target terSetTarget :: Target -> TerM a -> TerM a terGetHaveInlinedWith :: TerM Bool terSetHaveInlinedWith :: TerM a -> TerM a terGetDelayed :: TerM Delayed terSetDelayed :: Delayed -> TerM a -> TerM a terGetMaskArgs :: TerM [Bool] terSetMaskArgs :: [Bool] -> TerM a -> TerM a terGetMaskResult :: TerM Bool terSetMaskResult :: Bool -> TerM a -> TerM a terGetPatterns :: TerM MaskedDeBruijnPatterns terSetPatterns :: MaskedDeBruijnPatterns -> TerM a -> TerM a terRaise :: TerM a -> TerM a terGetGuarded :: TerM Guarded terModifyGuarded :: (Order -> Order) -> TerM a -> TerM a terSetGuarded :: Order -> TerM a -> TerM a terUnguarded :: TerM a -> TerM a -- | Lens for _terSizeDepth. terSizeDepth :: Lens' Int TerEnv -- | Lens for terUsableVars. terGetUsableVars :: TerM VarSet terModifyUsableVars :: (VarSet -> VarSet) -> TerM a -> TerM a terSetUsableVars :: VarSet -> TerM a -> TerM a -- | Lens for terUseSizeLt. terGetUseSizeLt :: TerM Bool terModifyUseSizeLt :: (Bool -> Bool) -> TerM a -> TerM a terSetUseSizeLt :: Bool -> TerM a -> TerM a -- | Compute usable vars from patterns and run subcomputation. withUsableVars :: UsableSizeVars a => a -> TerM b -> TerM b -- | Set terUseSizeLt when going under constructor c. conUseSizeLt :: QName -> TerM a -> TerM a -- | Set terUseSizeLt for arguments following projection q. -- We disregard j<i after a non-coinductive projection. However, the -- projection need not be recursive (Issue 1470). projUseSizeLt :: QName -> TerM a -> TerM a -- | For termination checking purposes flat should not be considered a -- projection. That is, it flat doesn't preserve either structural order -- or guardedness like other projections do. Andreas, 2012-06-09: the -- same applies to projections of recursive records. isProjectionButNotCoinductive :: MonadTCM tcm => QName -> tcm Bool -- | Check whether a projection belongs to a coinductive record and is -- actually recursive. E.g. @ isCoinductiveProjection (Stream.head) = -- return False -- -- isCoinductiveProjection (Stream.tail) = return True @ isCoinductiveProjection :: MonadTCM tcm => Bool -> QName -> tcm Bool -- | How long is the path to the deepest atomic pattern? patternDepth :: forall a. Pattern' a -> Int -- | A dummy pattern used to mask a pattern that cannot be used for -- structural descent. unusedVar :: DeBruijnPattern -- | Extract variables from DeBruijnPatterns that could witness a -- decrease via a SIZELT constraint. -- -- These variables must be under an inductive constructor (with no record -- constructor in the way), or after a coinductive projection (with no -- inductive one in the way). class UsableSizeVars a usableSizeVars :: UsableSizeVars a => a -> TerM VarSet type MaskedDeBruijnPatterns = [Masked DeBruijnPattern] data Masked a Masked :: Bool -> a -> Masked a -- | True if thing not eligible for structural descent. [getMask] :: Masked a -> Bool -- | Thing. [getMasked] :: Masked a -> a masked :: a -> Masked a notMasked :: a -> Masked a -- | Call paths. newtype CallPath CallPath :: DList CallInfo -> CallPath -- | The calls making up the call path. callInfos :: CallPath -> [CallInfo] -- | A very crude way of estimating the SIZELT chains i > j -- > k in context. Returns 3 in this case. Overapproximates. class TerSetSizeDepth b terSetSizeDepth :: TerSetSizeDepth b => b -> TerM a -> TerM a instance GHC.Show.Show Agda.Termination.Monad.Target instance GHC.Classes.Eq Agda.Termination.Monad.Target instance Data.Traversable.Traversable Agda.Termination.Monad.Masked instance Data.Foldable.Foldable Agda.Termination.Monad.Masked instance GHC.Base.Functor Agda.Termination.Monad.Masked instance GHC.Show.Show a => GHC.Show.Show (Agda.Termination.Monad.Masked a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Termination.Monad.Masked a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Termination.Monad.Masked a) instance Agda.TypeChecking.Monad.Pure.PureTCM Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Context.MonadAddContext Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Base.MonadReduce Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Base.MonadTCM Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Base.MonadTCState Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.Termination.Monad.TerM instance Control.Monad.IO.Class.MonadIO Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Signature.HasConstInfo Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Debug.MonadDebug Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Builtin.HasBuiltins Agda.Termination.Monad.TerM instance Agda.Interaction.Options.HasOptions.HasOptions Agda.Termination.Monad.TerM instance Agda.TypeChecking.Monad.Statistics.MonadStatistics Agda.Termination.Monad.TerM instance Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr Agda.Termination.Monad.TerM instance Control.Monad.Fail.MonadFail Agda.Termination.Monad.TerM instance GHC.Base.Monad Agda.Termination.Monad.TerM instance GHC.Base.Applicative Agda.Termination.Monad.TerM instance GHC.Base.Functor Agda.Termination.Monad.TerM instance GHC.Base.Monoid Agda.Termination.Monad.CallPath instance GHC.Base.Semigroup Agda.Termination.Monad.CallPath instance GHC.Show.Show Agda.Termination.Monad.CallPath instance Agda.Termination.Monad.TerSetSizeDepth Agda.Syntax.Internal.Telescope instance Agda.Termination.Monad.TerSetSizeDepth Agda.Syntax.Internal.ListTel instance Agda.Utils.Pretty.Pretty Agda.Termination.Monad.CallPath instance Agda.Termination.Monad.MonadTer Agda.Termination.Monad.TerM instance Agda.Termination.Monad.UsableSizeVars Agda.Syntax.Internal.DeBruijnPattern instance Agda.Termination.Monad.UsableSizeVars [Agda.Syntax.Internal.DeBruijnPattern] instance Agda.Termination.Monad.UsableSizeVars (Agda.Termination.Monad.Masked Agda.Syntax.Internal.DeBruijnPattern) instance Agda.Termination.Monad.UsableSizeVars Agda.Termination.Monad.MaskedDeBruijnPatterns instance Agda.Utils.Benchmark.MonadBench Agda.Termination.Monad.TerM instance GHC.Base.Semigroup m => GHC.Base.Semigroup (Agda.Termination.Monad.TerM m) instance (GHC.Base.Semigroup m, GHC.Base.Monoid m) => GHC.Base.Monoid (Agda.Termination.Monad.TerM m) instance Agda.Utils.Functor.Decoration Agda.Termination.Monad.Masked instance Agda.TypeChecking.Pretty.PrettyTCM a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Termination.Monad.Masked a) -- | Logic for deciding which functions should be automatically inlined. module Agda.TypeChecking.Inlining -- | Mark a definition to be inlined if it satisfies the inlining -- criterion. autoInline :: Defn -> TCM Defn -- | Reconstruct dropped parameters from constructors. Used by -- with-abstraction to avoid ill-typed abstractions (#745). Note that the -- term is invalid after parameter reconstruction. Parameters need to be -- dropped again before using it. module Agda.TypeChecking.ReconstructParameters reconstructParametersInType :: Type -> TCM Type reconstructParametersInType' :: Action TCM -> Type -> TCM Type reconstructParametersInTel :: Telescope -> TCM Telescope reconstructParametersInEqView :: EqualityView -> TCM EqualityView reconstructParameters :: Type -> Term -> TCM Term reconstructParameters' :: Action TCM -> Type -> Term -> TCM Term reconstructAction :: Action TCM reconstructAction' :: Action TCM -> Action TCM reconstruct :: Type -> Term -> TCM Term extractParameters :: QName -> Type -> TCM Args dropParameters :: TermLike a => a -> TCM a module Agda.TypeChecking.Lock isTimeless :: Type -> TCM Bool checkLockedVars :: Term -> Type -> Arg Term -> Type -> TCM () checkEarlierThan :: Term -> VarSet -> TCM () requireGuarded :: String -> TCM () module Agda.TypeChecking.LevelConstraints -- | simplifyLevelConstraint c cs turns an c into an -- equality constraint if it is an inequality constraint and the reverse -- inequality is contained in cs. -- -- The constraints don't necessarily have to live in the same context, -- but they do need to be universally quanitfied over the context. This -- function takes care of renaming variables when checking for matches. simplifyLevelConstraint :: Constraint -> [Constraint] -> Maybe [Constraint] instance GHC.Classes.Eq Agda.TypeChecking.LevelConstraints.Leq instance GHC.Show.Show Agda.TypeChecking.LevelConstraints.Leq module Agda.TypeChecking.Monad.Mutual noMutualBlock :: TCM a -> TCM a -- | Pass the current mutual block id or create a new mutual block if we -- are not already inside on. inMutualBlock :: (MutualId -> TCM a) -> TCM a -- | Set the mutual block info for a block, possibly overwriting the -- existing one. setMutualBlockInfo :: MutualId -> MutualInfo -> TCM () -- | Set the mutual block info for a block if non-existing. insertMutualBlockInfo :: MutualId -> MutualInfo -> TCM () -- | Set the mutual block for a definition. setMutualBlock :: MutualId -> QName -> TCM () -- | Get the current mutual block, if any, otherwise a fresh mutual block -- is returned. currentOrFreshMutualBlock :: TCM MutualId lookupMutualBlock :: ReadTCState tcm => MutualId -> tcm MutualBlock -- | Reverse lookup of a mutual block id for a name. mutualBlockOf :: QName -> TCM MutualId module Agda.Compiler.Treeless.Erase eraseTerms :: QName -> EvaluationStrategy -> TTerm -> TCM TTerm -- | Takes the name of the data/record type. computeErasedConstructorArgs :: QName -> TCM () isErasable :: QName -> TCM Bool instance GHC.Show.Show Agda.Compiler.Treeless.Erase.TypeInfo instance GHC.Classes.Eq Agda.Compiler.Treeless.Erase.TypeInfo module Agda.Compiler.Treeless.Unused usedArguments :: QName -> TTerm -> TCM [ArgUsage] stripUnusedArguments :: [ArgUsage] -> TTerm -> TTerm module Agda.Compiler.Treeless.Pretty instance Agda.Utils.Pretty.Pretty Agda.Syntax.Treeless.TTerm module Agda.Compiler.Treeless.Subst newtype UnderLambda UnderLambda :: Any -> UnderLambda newtype SeqArg SeqArg :: All -> SeqArg data Occurs Occurs :: Int -> UnderLambda -> SeqArg -> Occurs once :: Occurs inSeq :: Occurs -> Occurs underLambda :: Occurs -> Occurs class HasFree a freeVars :: HasFree a => a -> Map Int Occurs freeIn :: HasFree a => Int -> a -> Bool occursIn :: HasFree a => Int -> a -> Occurs data Binder a Binder :: Int -> a -> Binder a newtype InSeq a InSeq :: a -> InSeq a -- | Strenghtening. tryStrengthen :: (HasFree a, Subst a) => Int -> a -> Maybe a instance GHC.Base.Monoid Agda.Compiler.Treeless.Subst.UnderLambda instance GHC.Base.Semigroup Agda.Compiler.Treeless.Subst.UnderLambda instance GHC.Show.Show Agda.Compiler.Treeless.Subst.UnderLambda instance GHC.Classes.Ord Agda.Compiler.Treeless.Subst.UnderLambda instance GHC.Classes.Eq Agda.Compiler.Treeless.Subst.UnderLambda instance GHC.Base.Monoid Agda.Compiler.Treeless.Subst.SeqArg instance GHC.Base.Semigroup Agda.Compiler.Treeless.Subst.SeqArg instance GHC.Show.Show Agda.Compiler.Treeless.Subst.SeqArg instance GHC.Classes.Ord Agda.Compiler.Treeless.Subst.SeqArg instance GHC.Classes.Eq Agda.Compiler.Treeless.Subst.SeqArg instance GHC.Show.Show Agda.Compiler.Treeless.Subst.Occurs instance GHC.Classes.Ord Agda.Compiler.Treeless.Subst.Occurs instance GHC.Classes.Eq Agda.Compiler.Treeless.Subst.Occurs instance Agda.Compiler.Treeless.Subst.HasFree a => Agda.Compiler.Treeless.Subst.HasFree (Agda.Compiler.Treeless.Subst.InSeq a) instance Agda.Compiler.Treeless.Subst.HasFree Agda.Syntax.Treeless.TTerm instance Agda.Compiler.Treeless.Subst.HasFree a => Agda.Compiler.Treeless.Subst.HasFree (Agda.Compiler.Treeless.Subst.Binder a) instance Agda.Compiler.Treeless.Subst.HasFree Agda.Syntax.Treeless.TAlt instance Agda.Compiler.Treeless.Subst.HasFree GHC.Types.Int instance Agda.Compiler.Treeless.Subst.HasFree a => Agda.Compiler.Treeless.Subst.HasFree [a] instance (Agda.Compiler.Treeless.Subst.HasFree a, Agda.Compiler.Treeless.Subst.HasFree b) => Agda.Compiler.Treeless.Subst.HasFree (a, b) instance GHC.Base.Semigroup Agda.Compiler.Treeless.Subst.Occurs instance GHC.Base.Monoid Agda.Compiler.Treeless.Subst.Occurs instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Treeless.TTerm instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Treeless.TTerm instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Treeless.TAlt -- | Built-in backends. module Agda.Compiler.Builtin builtinBackends :: [Backend] -- | Generating highlighted and aligned LaTeX from literate Agda source. module Agda.Interaction.Highlighting.LaTeX latexBackend :: Backend module Agda.Compiler.Common data IsMain IsMain :: IsMain NotMain :: IsMain doCompile :: Monoid r => (IsMain -> Interface -> TCM r) -> IsMain -> Interface -> TCM r doCompile' :: Monoid r => (IsMain -> Interface -> TCM r) -> IsMain -> Interface -> StateT (Set ModuleName) TCM r setInterface :: Interface -> TCM () curIF :: ReadTCState m => m Interface curMName :: ReadTCState m => m TopLevelModuleName curDefs :: ReadTCState m => m Definitions sortDefs :: Definitions -> [(QName, Definition)] compileDir :: HasOptions m => m FilePath repl :: [String] -> String -> String -- | Sets up the compilation environment. inCompilerEnv :: CheckResult -> TCM a -> TCM a topLevelModuleName :: ReadTCState m => ModuleName -> m TopLevelModuleName instance GHC.Show.Show Agda.Compiler.Common.IsMain instance GHC.Classes.Eq Agda.Compiler.Common.IsMain instance GHC.Base.Semigroup Agda.Compiler.Common.IsMain instance GHC.Base.Monoid Agda.Compiler.Common.IsMain -- | This module deals with finding imported modules and loading their -- interface files. module Agda.Interaction.Imports -- | Is the aim to type-check the top-level module, or only to scope-check -- it? data Mode pattern ScopeCheck :: () => Mode pattern TypeCheck :: () => Mode -- | The result and associated parameters of a type-checked file, when -- invoked directly via interaction or a backend. Note that the -- constructor is not exported. data CheckResult -- | Flattened unidirectional pattern for CheckResult for -- destructuring inside the ModuleInfo field. pattern CheckResult :: Interface -> [TCWarning] -> ModuleCheckMode -> Source -> CheckResult crModuleInfo :: CheckResult -> ModuleInfo crInterface :: CheckResult -> Interface crWarnings :: CheckResult -> [TCWarning] crMode :: CheckResult -> ModuleCheckMode crSource :: CheckResult -> Source -- | The decorated source code. data Source Source :: Text -> FileType -> SourceFile -> Module -> TopLevelModuleName -> [AgdaLibFile] -> !CohesionAttributes -> Source -- | Source code. [srcText] :: Source -> Text -- | Source file type [srcFileType] :: Source -> FileType -- | Source location at the time of its parsing [srcOrigin] :: Source -> SourceFile -- | The parsed module. [srcModule] :: Source -> Module -- | The top-level module name. [srcModuleName] :: Source -> TopLevelModuleName -- | The .agda-lib file(s) of the project this file belongs to. [srcProjectLibs] :: Source -> [AgdaLibFile] -- | Every encountered occurrence of a cohesion attribute. [srcCohesion] :: Source -> !CohesionAttributes -- | Scope checks the given module. A proper version of the module name -- (with correct definition sites) is returned. scopeCheckImport :: TopLevelModuleName -> ModuleName -> TCM (ModuleName, Map ModuleName Scope) -- | Parses a source file and prepares the Source record. parseSource :: SourceFile -> TCM Source -- | Type checks the main file of the interaction. This could be the file -- loaded in the interacting editor (emacs), or the file passed on the -- command line. -- -- First, the primitive modules are imported. Then, getInterface -- is called to do the main work. -- -- If the Mode is ScopeCheck, then type-checking is not -- performed, only scope-checking. (This may include type-checking of -- imported modules.) In this case the generated, partial interface is -- not stored in the state (stDecodedModules). Note, however, that -- if the file has already been type-checked, then a complete interface -- is returned. typeCheckMain :: Mode -> Source -> TCM CheckResult -- | Read interface file corresponding to a module. readInterface :: InterfaceFile -> TCM (Maybe Interface) instance GHC.Show.Show Agda.Interaction.Imports.Mode instance GHC.Classes.Eq Agda.Interaction.Imports.Mode instance GHC.Show.Show Agda.Interaction.Imports.MainInterface instance GHC.Classes.Eq Agda.Interaction.Imports.MainInterface -- | Structure-sharing serialisation of Agda interface files. module Agda.TypeChecking.Serialise -- | Encodes something. To ensure relocatability file paths in positions -- are replaced with module names. encode :: EmbPrj a => a -> TCM Encoded -- | Encodes an interface. To ensure relocatability file paths in positions -- are replaced with module names. -- -- An uncompressed bytestring corresponding to the encoded interface is -- returned. encodeFile :: FilePath -> Interface -> TCM ByteString encodeInterface :: Interface -> TCM Encoded -- | Decodes an uncompressed bytestring (without extra hashes or magic -- numbers). The result depends on the include path. -- -- Returns Nothing if a decoding error is encountered. decode :: EmbPrj a => ByteString -> TCM (Maybe a) decodeFile :: FilePath -> TCM (Maybe Interface) -- | Decodes an interface. The result depends on the include path. -- -- Returns Nothing if the file does not start with the right magic -- number or some other decoding error is encountered. decodeInterface :: ByteString -> TCM (Maybe Interface) decodeHashes :: ByteString -> Maybe (Hash, Hash) class Typeable a => EmbPrj a instance Data.Binary.Class.Binary a => Data.Binary.Class.Binary (Agda.TypeChecking.Serialise.ListLike a) module Agda.TypeChecking.Serialise.Instances instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Interface module Agda.TypeChecking.Serialise.Instances.Highlighting instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Range.Range instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.NameKind instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.Aspect instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.OtherAspect instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.Aspects instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.DefinitionSite instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.RangeMap.RangeMap a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.TokenBased module Agda.TypeChecking.Serialise.Instances.Common -- | Ranges that should be serialised properly. newtype SerialisedRange SerialisedRange :: Range -> SerialisedRange [underlyingRange] :: SerialisedRange -> Range instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Serialise.Instances.Common.SerialisedRange instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Abstract.Name.Name instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Base.String instance Agda.TypeChecking.Serialise.Base.EmbPrj Data.Text.Internal.Lazy.Text instance Agda.TypeChecking.Serialise.Base.EmbPrj Data.Text.Internal.Text instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Num.Integer.Integer instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Word.Word64 instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Int.Int32 instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Types.Int instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Types.Char instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Types.Double instance Agda.TypeChecking.Serialise.Base.EmbPrj Data.Void.Void instance Agda.TypeChecking.Serialise.Base.EmbPrj () instance (Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (a, b) instance (Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.Strict.Tuple.Pair a b) instance (Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b, Agda.TypeChecking.Serialise.Base.EmbPrj c) => Agda.TypeChecking.Serialise.Base.EmbPrj (a, b, c) instance (Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.Either.Either a b) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (GHC.Maybe.Maybe a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.Strict.Maybe.Maybe a) instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Types.Bool instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.FileType instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Cubical instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Language instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Position.Position' a) instance Data.Typeable.Internal.Typeable b => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.WithDefault.WithDefault b) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.TopLevelModuleName.TopLevelModuleName instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj [a] instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.List1.List1 a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.List2.List2 a) instance (Agda.TypeChecking.Serialise.Base.EmbPrj k, Agda.TypeChecking.Serialise.Base.EmbPrj v, Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.BiMap.Tag v)) => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.BiMap.BiMap k v) instance (GHC.Classes.Ord a, Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.Map.Internal.Map a b) instance (GHC.Classes.Ord a, Agda.TypeChecking.Serialise.Base.EmbPrj a) => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.Set.Internal.Set a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Data.IntSet.Internal.IntSet instance (GHC.Classes.Ord a, Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.Trie.Trie a b) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.Sequence.Internal.Seq a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Position.Interval' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Position.RangeFile instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Position.Range instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Name.Name instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Name.NamePart instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Name.NameInScope instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Name.QName instance (Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.ImportedName' a b) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Associativity instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.FixityLevel instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Fixity instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Fixity' instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.BoundVariablePosition instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.NotationPart instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.MetaId instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Abstract.Name.QName instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Abstract.Name.AmbiguousQName instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Abstract.Name.ModuleName instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Concrete.FieldAssignment' a) instance (Agda.TypeChecking.Serialise.Base.EmbPrj s, Agda.TypeChecking.Serialise.Base.EmbPrj t) => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.Named s t) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.Ranged a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.ArgInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.ModuleNameHash instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.NameId instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k, Agda.TypeChecking.Serialise.Base.EmbPrj k, Agda.TypeChecking.Serialise.Base.EmbPrj v) => Agda.TypeChecking.Serialise.Base.EmbPrj (Data.HashMap.Internal.HashMap k v) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.WithHiding a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.Arg a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.HasEta' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.PatternOrCopattern instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Induction instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Hiding instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Q0Origin instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Q1Origin instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.QωOrigin instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Quantity instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Cohesion instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Modality instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Relevance instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Annotation instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Lock instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Origin instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Common.WithOrigin a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.FreeVariables instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.ConOrigin instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.ProjOrigin instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Literal.Literal instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.IsAbstract instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Delayed instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Stack.Types.SrcLoc instance Agda.TypeChecking.Serialise.Base.EmbPrj GHC.Stack.Types.CallStack instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Utils.Impossible.Impossible instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.ExpandedEllipsis module Agda.TypeChecking.Serialise.Base -- | Constructor tag (maybe omitted) and argument indices. type Node = [Int32] -- | Structure providing fresh identifiers for hash map and counting hash -- map hits (i.e. when no fresh identifier required). newtype FreshAndReuse FreshAndReuse :: Int32 -> FreshAndReuse -- | Number of hash map misses. [farFresh] :: FreshAndReuse -> Int32 farEmpty :: FreshAndReuse lensFresh :: Lens' Int32 FreshAndReuse -- | Two QNames are equal if their QNameId is equal. type QNameId = [NameId] -- | Computing a qualified names composed ID. qnameId :: QName -> QNameId -- | State of the the encoder. data Dict Dict :: !HashTable Node Int32 -> !HashTable String Int32 -> !HashTable Text Int32 -> !HashTable Text Int32 -> !HashTable Integer Int32 -> !HashTable Double Int32 -> !HashTable (Ptr Term) Int32 -> !HashTable NameId Int32 -> !HashTable QNameId Int32 -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !IORef FreshAndReuse -> !HashTable String Int -> Bool -> Dict -- | Written to interface file. [nodeD] :: Dict -> !HashTable Node Int32 -- | Written to interface file. [stringD] :: Dict -> !HashTable String Int32 -- | Written to interface file. [lTextD] :: Dict -> !HashTable Text Int32 -- | Written to interface file. [sTextD] :: Dict -> !HashTable Text Int32 -- | Written to interface file. [integerD] :: Dict -> !HashTable Integer Int32 -- | Written to interface file. Dicitionaries which are not serialized, but -- provide short cuts to speed up serialization: [doubleD] :: Dict -> !HashTable Double Int32 -- | Not written to interface file. Andreas, Makoto, AIM XXI Memoizing -- A.Name does not buy us much if we already memoize A.QName. [termD] :: Dict -> !HashTable (Ptr Term) Int32 -- | Not written to interface file. [nameD] :: Dict -> !HashTable NameId Int32 -- | Not written to interface file. Fresh UIDs and reuse statistics: [qnameD] :: Dict -> !HashTable QNameId Int32 [nodeC] :: Dict -> !IORef FreshAndReuse [stringC] :: Dict -> !IORef FreshAndReuse [lTextC] :: Dict -> !IORef FreshAndReuse [sTextC] :: Dict -> !IORef FreshAndReuse [integerC] :: Dict -> !IORef FreshAndReuse [doubleC] :: Dict -> !IORef FreshAndReuse [termC] :: Dict -> !IORef FreshAndReuse [nameC] :: Dict -> !IORef FreshAndReuse [qnameC] :: Dict -> !IORef FreshAndReuse [stats] :: Dict -> !HashTable String Int -- | If True collect in stats the quantities of calls to -- icode for each Typeable a. [collectStats] :: Dict -> Bool -- | Creates an empty dictionary. emptyDict :: Bool -> IO Dict -- | Universal type, wraps everything. data U U :: !a -> U -- | Univeral memo structure, to introduce sharing during decoding type Memo = IOArray Int32 (HashMap TypeRep U) -- | State of the decoder. data St St :: !Array Int32 Node -> !Array Int32 String -> !Array Int32 Text -> !Array Int32 Text -> !Array Int32 Integer -> !Array Int32 Double -> !Memo -> !ModuleToSource -> [AbsolutePath] -> St -- | Obtained from interface file. [nodeE] :: St -> !Array Int32 Node -- | Obtained from interface file. [stringE] :: St -> !Array Int32 String -- | Obtained from interface file. [lTextE] :: St -> !Array Int32 Text -- | Obtained from interface file. [sTextE] :: St -> !Array Int32 Text -- | Obtained from interface file. [integerE] :: St -> !Array Int32 Integer -- | Obtained from interface file. [doubleE] :: St -> !Array Int32 Double -- | Created and modified by decoder. Used to introduce sharing while -- deserializing objects. [nodeMemo] :: St -> !Memo -- | Maps module names to file names. Constructed by the decoder. [modFile] :: St -> !ModuleToSource -- | The include directories. [includes] :: St -> [AbsolutePath] -- | Monad used by the encoder. type S a = ReaderT Dict IO a -- | Monad used by the decoder. -- -- TCM is not used because the associated overheads would make -- decoding slower. type R a = ExceptT TypeError (StateT St IO) a -- | Throws an error which is suitable when the data stream is malformed. malformed :: R a class Typeable a => EmbPrj a icode :: EmbPrj a => a -> S Int32 icod_ :: EmbPrj a => a -> S Int32 value :: EmbPrj a => Int32 -> R a value :: (EmbPrj a, Enum a) => Int32 -> R a icod_ :: (EmbPrj a, Enum a) => a -> S Int32 -- | Increase entry for a in stats. tickICode :: forall a. Typeable a => a -> S () -- | Data.Binary.runGetState is deprecated in favour of runGetIncremental. -- Reimplementing it in terms of the new function. The new Decoder type -- contains strict byte strings so we need to be careful not to feed the -- entire lazy byte string to the decoder at once. runGetState :: Get a -> ByteString -> ByteOffset -> (a, ByteString, ByteOffset) icodeX :: (Eq k, Hashable k) => (Dict -> HashTable k Int32) -> (Dict -> IORef FreshAndReuse) -> k -> S Int32 icodeInteger :: Integer -> S Int32 icodeDouble :: Double -> S Int32 icodeString :: String -> S Int32 icodeNode :: Node -> S Int32 -- | icode only if thing has not seen before. icodeMemo :: (Ord a, Hashable a) => (Dict -> HashTable a Int32) -> (Dict -> IORef FreshAndReuse) -> a -> S Int32 -> S Int32 -- | vcase value ix decodes thing represented by ix :: -- Int32 via the valu function and stores it in -- nodeMemo. If ix is present in nodeMemo, -- valu is not used, but the thing is read from nodeMemo -- instead. vcase :: forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a -- | icodeArgs proxy (a1, ..., an) maps icode over -- a1, ..., an and returns the corresponding list of -- Int32. class ICODE t b icodeArgs :: (ICODE t b, IsBase t ~ b) => All EmbPrj (Domains t) => Proxy t -> Products (Domains t) -> S [Int32] -- | icodeN tag t a1 ... an serialises the arguments a1, -- ..., an of the constructor t together with a tag -- tag picked to disambiguate between different constructors. It -- corresponds to icodeNode . (tag :) =<< mapM icode [a1, ..., -- an] icodeN :: forall t. ICODE t (IsBase t) => Currying (Domains t) (S Int32) => All EmbPrj (Domains t) => Int32 -> t -> Arrows (Domains t) (S Int32) -- | icodeN' is the same as icodeN except that there is -- no tag icodeN' :: forall t. ICODE t (IsBase t) => Currying (Domains t) (S Int32) => All EmbPrj (Domains t) => t -> Arrows (Domains t) (S Int32) class VALU t b valuN' :: (VALU t b, b ~ IsBase t) => All EmbPrj (Domains t) => t -> Products (Constant Int32 (Domains t)) -> R (CoDomain t) valueArgs :: (VALU t b, b ~ IsBase t) => All EmbPrj (CoDomain t : Domains t) => Proxy t -> Node -> Maybe (Products (Constant Int32 (Domains t))) valuN :: forall t. VALU t (IsBase t) => Currying (Constant Int32 (Domains t)) (R (CoDomain t)) => All EmbPrj (Domains t) => t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t)) valueN :: forall t. VALU t (IsBase t) => All EmbPrj (CoDomain t : Domains t) => t -> Int32 -> R (CoDomain t) instance Agda.TypeChecking.Serialise.Base.VALU t 'GHC.Types.True instance Agda.TypeChecking.Serialise.Base.VALU t (Agda.Utils.TypeLevel.IsBase t) => Agda.TypeChecking.Serialise.Base.VALU (a -> t) 'GHC.Types.False instance (Agda.Utils.TypeLevel.IsBase t GHC.Types.~ 'GHC.Types.True) => Agda.TypeChecking.Serialise.Base.ICODE t 'GHC.Types.True instance Agda.TypeChecking.Serialise.Base.ICODE t (Agda.Utils.TypeLevel.IsBase t) => Agda.TypeChecking.Serialise.Base.ICODE (a -> t) 'GHC.Types.False -- | Functions which map between module names and file names. -- -- Note that file name lookups are cached in the TCState. The code -- assumes that no Agda source files are added or removed from the -- include directories while the code is being type checked. module Agda.Interaction.FindFile -- | Type aliases for source files and interface files. We may only produce -- one of these if we know for sure that the file does exist. We can -- always output an AbsolutePath if we are not sure. newtype SourceFile SourceFile :: AbsolutePath -> SourceFile [srcFilePath] :: SourceFile -> AbsolutePath data InterfaceFile -- | Converts an Agda file name to the corresponding interface file name. -- Note that we do not guarantee that the file exists. toIFile :: SourceFile -> TCM AbsolutePath -- | Makes an interface file from an AbsolutePath candidate. If the file -- does not exist, then fail by returning Nothing. mkInterfaceFile :: AbsolutePath -> IO (Maybe InterfaceFile) -- | Errors which can arise when trying to find a source file. -- -- Invariant: All paths are absolute. data FindError -- | The file was not found. It should have had one of the given file -- names. NotFound :: [SourceFile] -> FindError -- | Several matching files were found. -- -- Invariant: The list of matching files has at least two elements. Ambiguous :: [SourceFile] -> FindError -- | Given the module name which the error applies to this function -- converts a FindError to a TypeError. findErrorToTypeError :: TopLevelModuleName -> FindError -> TypeError -- | Finds the source file corresponding to a given top-level module name. -- The returned paths are absolute. -- -- Raises an error if the file cannot be found. findFile :: TopLevelModuleName -> TCM SourceFile -- | Tries to find the source file corresponding to a given top-level -- module name. The returned paths are absolute. -- -- SIDE EFFECT: Updates stModuleToSource. findFile' :: TopLevelModuleName -> TCM (Either FindError SourceFile) -- | A variant of findFile' which does not require TCMT. findFile'' :: [AbsolutePath] -> TopLevelModuleName -> ModuleToSource -> IO (Either FindError SourceFile, ModuleToSource) -- | Finds the interface file corresponding to a given top-level module -- file. The returned paths are absolute. -- -- Raises Nothing if the the interface file cannot be found. findInterfaceFile' :: SourceFile -> TCM (Maybe InterfaceFile) -- | Finds the interface file corresponding to a given top-level module -- file. The returned paths are absolute. -- -- Raises an error if the source file cannot be found, and returns -- Nothing if the source file can be found but not the interface -- file. findInterfaceFile :: TopLevelModuleName -> TCM (Maybe InterfaceFile) -- | Ensures that the module name matches the file name. The file -- corresponding to the module name (according to the include path) has -- to be the same as the given file name. checkModuleName :: TopLevelModuleName -> SourceFile -> Maybe TopLevelModuleName -> TCM () -- | Computes the module name of the top-level module in the given file. -- -- If no top-level module name is given, then an attempt is made to use -- the file name as a module name. moduleName :: AbsolutePath -> Module -> TCM TopLevelModuleName rootNameModule :: AbsolutePath -> String replaceModuleExtension :: String -> AbsolutePath -> AbsolutePath instance GHC.Classes.Ord Agda.Interaction.FindFile.SourceFile instance GHC.Classes.Eq Agda.Interaction.FindFile.SourceFile instance Agda.Utils.Pretty.Pretty Agda.Interaction.FindFile.InterfaceFile instance Agda.Utils.Pretty.Pretty Agda.Interaction.FindFile.SourceFile module Agda.TypeChecking.Serialise.Instances.Errors instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.TCWarning instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Warning instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Parser.Monad.ParseWarning instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.RecordFieldWarning instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Definitions.Errors.DeclarationWarning' instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.Base.LibWarning instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.Base.LibWarning' instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.Base.ExecutablesFile instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.Base.LibPositionInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Text.PrettyPrint.HughesPJ.Doc instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Options.Base.InfectiveCoinfective instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Options.Base.PragmaOptions instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Utils.ProfileOptions.ProfileOptions instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Utils.ProfileOptions.ProfileOption instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Concrete.Glyph.UnicodeOrAscii instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Options.Base.ConfluenceCheck instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Options.Warnings.WarningMode instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Options.Warnings.WarningName instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Termination.CutOff.CutOff module Agda.TypeChecking.Serialise.Instances.Internal instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Dom a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Signature instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Section instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Tele a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Utils.Permutation.Permutation instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.Permutation.Drop a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Elim.Elim' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.DataOrRecord instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.ConHead instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Type' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Abs a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.Term instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.Level instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.PlusLevel instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.IsFibrant instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.Sort instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.DisplayForm instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.Monad.Base.Open a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.CheckpointId instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.DisplayTerm instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.MutualId instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.CompKit instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Definition instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.NotBlocked instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.Blocked_ instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.NLPat instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.NLPType instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.NLPSort instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.RewriteRule instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Projection instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.ProjLams instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.System instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.ExtLamInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Polarity instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.IsForced instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.NumGeneralizableArgs instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.DoGeneralize instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Positivity.Occurrence.Occurrence instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.EtaEquality instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.ProjectionLikenessMissing instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Defn instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Coverage.SplitTree.LazySplit instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Coverage.SplitTree.SplitTag instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.FunctionFlag instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.CompiledClause.WithArity a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.CompiledClause.Case a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.CompiledClause.CompiledClauses instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.Monad.Base.FunctionInverse' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.TermHead instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.Clause instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.ConPatternInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.DBPatVar instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.PatternInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Internal.PatOrigin instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Pattern' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.Monad.Base.Builtin a) instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Internal.Substitution' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Instantiation instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Comparison instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.TypeChecking.Monad.Base.Judgement a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.RemoteMetaVariable module Agda.TypeChecking.Serialise.Instances.Compilers instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.CompilerPragma instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.ForeignCode module Agda.TypeChecking.Serialise.Instances.Abstract data AbsNameWithFixity AbsNameWithFixity :: Fixity -> QName -> KindOfName -> WhyInScope -> NameMetadata -> AbsNameWithFixity toAbsName :: AbsNameWithFixity -> AbstractName fromAbsName :: AbstractName -> AbsNameWithFixity instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Serialise.Instances.Abstract.AbsNameWithFixity instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Abstract.BindName instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.Scope instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.DataOrRecordModule instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.NameSpaceId instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.Access instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.NameSpace instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.WhyInScope instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.AbstractName instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.NameMetadata instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Abstract.Name.Suffix instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.AbstractModule instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.KindOfName instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.BindingSource instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.LocalVar instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Info.ConPatInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Info.ConPatLazy instance Agda.TypeChecking.Serialise.Base.EmbPrj a => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Syntax.Abstract.Pattern' a) instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Fixity.ParenPreference instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Fixity.Precedence instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.ScopeInfo instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.NameOrModule module Agda.TypeChecking.DeadCode -- | Run before serialisation to remove any definitions and meta-variables -- that are not reachable from the module's public interface. -- -- Things that are reachable only from warnings are removed. eliminateDeadCode :: BuiltinThings PrimFun -> DisplayForms -> Signature -> LocalMetaStore -> TCM (DisplayForms, Signature, RemoteMetaStore) module Agda.TheTypeChecker -- | Type check a sequence of declarations. checkDecls :: [Declaration] -> TCM () -- | Type check a single declaration. checkDecl :: Declaration -> TCM () -- | Cached checkDecl checkDeclCached :: Declaration -> TCM () -- | Infer the type of an expression. Implemented by checking against a -- meta variable. Except for neutrals, for them a polymorphic type is -- inferred. inferExpr :: Expr -> TCM (Term, Type) -- | Type check an expression. checkExpr :: Expr -> Type -> TCM Term -- | Translation from Agda.Syntax.Concrete to -- Agda.Syntax.Abstract. Involves scope analysis, figuring out -- infix operator precedences and tidying up definitions. module Agda.Syntax.Translation.ConcreteToAbstract -- | Things that can be translated to abstract syntax are instances of this -- class. class ToAbstract c where { type AbsOfCon c; } toAbstract :: ToAbstract c => c -> ScopeM (AbsOfCon c) -- | This operation does not affect the scope, i.e. the original scope is -- restored upon completion. localToAbstract :: ToAbstract c => c -> (AbsOfCon c -> ScopeM b) -> ScopeM b concreteToAbstract_ :: ToAbstract c => c -> ScopeM (AbsOfCon c) concreteToAbstract :: ToAbstract c => ScopeInfo -> c -> ScopeM (AbsOfCon c) newtype NewModuleQName NewModuleQName :: QName -> NewModuleQName -- | Temporary data type to scope check a file. data TopLevel a TopLevel :: AbsolutePath -> TopLevelModuleName -> a -> TopLevel a -- | The file path from which we loaded this module. [topLevelPath] :: TopLevel a -> AbsolutePath -- | The expected module name (coming from the import statement that -- triggered scope checking this file). [topLevelExpectedName] :: TopLevel a -> TopLevelModuleName -- | The file content. [topLevelTheThing] :: TopLevel a -> a data TopLevelInfo TopLevelInfo :: [Declaration] -> ScopeInfo -> TopLevelInfo [topLevelDecls] :: TopLevelInfo -> [Declaration] -- | as seen from inside the module [topLevelScope] :: TopLevelInfo -> ScopeInfo -- | The top-level module name. topLevelModuleName :: TopLevelInfo -> ModuleName data AbstractRHS data NewModuleName data OldModuleName data NewName a data OldQName data PatName data APatName -- | Declaration open import Agda.Primitive using (Set; Prop) when -- optImportSorts. importPrimitives :: ScopeM [Declaration] -- | Raises an error if the list of cohesion attributes is non-empty and -- cohesion modalities are not supported. checkCohesionAttributes :: CohesionAttributes -> ScopeM () instance GHC.Base.Functor Agda.Syntax.Translation.ConcreteToAbstract.NewName instance GHC.Show.Show Agda.Syntax.Translation.ConcreteToAbstract.TerminationOrPositivity instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Pragma instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Definitions.Types.Clause instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.LeftHandSide instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.AbstractRHS instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.RightHandSide instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.RHS instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Definitions.Types.NiceDeclaration instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.DataConstrDecl instance Agda.Syntax.Translation.ConcreteToAbstract.LivesInCurrentModule Agda.Syntax.Scope.Base.AbstractName instance Agda.Syntax.Translation.ConcreteToAbstract.LivesInCurrentModule Agda.Syntax.Abstract.Name.QName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.GenTelAndType instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.GenTel instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.LetDefs instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.LetDef instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Expr instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.TopLevel [Agda.Syntax.Concrete.Declaration]) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.Declarations instance Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms Agda.Syntax.Concrete.Binder instance Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms Agda.Syntax.Concrete.TypedBinding instance Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms a => Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms (Agda.Syntax.Concrete.LamBinding' a) instance Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms a => Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms (Agda.Syntax.Common.Named_ a) instance Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms a => Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms (Agda.Syntax.Common.NamedArg a) instance Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms a => Agda.Syntax.Translation.ConcreteToAbstract.EnsureNoLetStms [a] instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.OldModuleName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.ModuleAssignment instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.NewModuleQName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.NewModuleName instance Agda.Syntax.Translation.ConcreteToAbstract.ToQName Agda.Syntax.Concrete.Name.Name instance Agda.Syntax.Translation.ConcreteToAbstract.ToQName Agda.Syntax.Concrete.Name.QName instance Agda.Syntax.Translation.ConcreteToAbstract.ToQName a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.OldName a) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.PatName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Pattern instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.ResolveQName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.LHSCore instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.OldQName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.MaybeOldQName instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.NewName Agda.Syntax.Concrete.Name.Name) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.NewName Agda.Syntax.Concrete.BoundName) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Concrete.Binder' (Agda.Syntax.Translation.ConcreteToAbstract.NewName Agda.Syntax.Concrete.BoundName)) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.LamBinding instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.RewriteEqn instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.RecordConstructorType instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract () instance (Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c1, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c2) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (c1, c2) instance (Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c1, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c2, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c3) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (c1, c2, c3) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract [c] instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Utils.List1.List1 c) instance (Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c1, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c2) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Data.Either.Either c1 c2) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (GHC.Maybe.Maybe c) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Concrete.FieldAssignment' c) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.RewriteEqn' () Agda.Syntax.Abstract.BindName Agda.Syntax.Abstract.Pattern Agda.Syntax.Abstract.Expr) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.WithHiding c) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.Arg c) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.Named name c) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Abstract.LHSCore' Agda.Syntax.Concrete.Expr) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Abstract.Pattern' Agda.Syntax.Concrete.Expr) instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.HoleContent module Agda.Syntax.IdiomBrackets parseIdiomBracketsSeq :: Range -> [Expr] -> ScopeM Expr -- | The parser doesn't know about operators and parses everything as -- normal function application. This module contains the functions that -- parses the operators properly. For a stand-alone implementation of -- this see src/prototyping/mixfix/old. -- -- It also contains the function that puts parenthesis back given the -- precedence of the context. module Agda.Syntax.Concrete.Operators -- | Parse a list of expressions (typically from a RawApp) into an -- application. parseApplication :: List2 Expr -> ScopeM Expr -- | Parse an expression into a module application (an identifier plus a -- list of arguments). parseModuleApplication :: Expr -> ScopeM (QName, [NamedArg Expr]) -- | Parses a left-hand side, and makes sure that it defined the expected -- name. parseLHS :: QName -> Pattern -> ScopeM LHSCore -- | Parses a pattern. parsePattern :: Pattern -> ScopeM Pattern parsePatternSyn :: Pattern -> ScopeM Pattern instance GHC.Show.Show Agda.Syntax.Concrete.Operators.ExprKind instance GHC.Classes.Eq Agda.Syntax.Concrete.Operators.ExprKind instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Operators.ParseLHS -- | Flattened scopes. module Agda.Syntax.Scope.Flat -- | Flattened scopes. data FlatScope -- | Compute a flattened scope. Only include unqualified names or names -- qualified by modules in the first argument. flattenScope :: [[Name]] -> ScopeInfo -> FlatScope -- | Compute all defined names in scope and their fixities/notations. Note -- that overloaded names (constructors) can have several -- fixities/notations. Then we mergeNotations. (See issue 1194.) getDefinedNames :: KindsOfNames -> FlatScope -> [[NewNotation]] -- | Compute all names (first component) and operators/notations (second -- component) in scope. localNames :: FlatScope -> ScopeM ([QName], [NewNotation]) instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Flat.FlatScope -- | Desugaring for do-notation. Uses whatever `_>>=_` and -- `_>>_` happen to be in scope. -- -- Example: -- -- ``` foo = do x ← m₁ m₂ just y ← m₃ where nothing → m₄ let z = t m₅ ``` -- desugars to ``` foo = m₁ >>= λ x → m₂ >> m₃ >>= λ -- where just y → let z = t in m₅ nothing → m₄ ``` module Agda.Syntax.DoNotation desugarDoNotation :: Range -> List1 DoStmt -> ScopeM Expr -- | Facility to test throwing internal errors. module Agda.ImpossibleTest -- | If the given list of words is non-empty, print them as debug message -- (using __IMPOSSIBLE_VERBOSE__) before raising the internal -- error. impossibleTest :: (MonadDebug m, HasCallStack) => [String] -> m a impossibleTestReduceM :: HasCallStack => [String] -> TCM a module Agda.Interaction.Highlighting.Vim vimFile :: FilePath -> FilePath escape :: String -> String wordBounded :: String -> String keyword :: String -> [String] -> String match :: String -> [String] -> String matches :: [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String] toVim :: NamesInScope -> String generateVimFile :: FilePath -> TCM () module Agda.Interaction.BasicOps -- | Parses an expression. parseExpr :: Range -> String -> TCM Expr parseExprIn :: InteractionId -> Range -> String -> TCM Expr giveExpr :: UseForce -> Maybe InteractionId -> MetaId -> Expr -> TCM Term -- | After a give, redo termination etc. checks for function which was -- complemented. redoChecks :: Maybe InteractionId -> TCM () -- | Try to fill hole by expression. -- -- Returns the given expression unchanged (for convenient generalization -- to refine). give :: UseForce -> InteractionId -> Maybe Range -> Expr -> TCM Expr -- | Try to fill hole by elaborated expression. elaborate_give :: Rewrite -> UseForce -> InteractionId -> Maybe Range -> Expr -> TCM Expr -- | Try to refine hole by expression e. -- -- This amounts to successively try to give e, e ?, -- e ? ?, ... Returns the successfully given expression. refine :: UseForce -> InteractionId -> Maybe Range -> Expr -> TCM Expr -- | Evaluate the given expression in the current environment evalInCurrent :: ComputeMode -> Expr -> TCM Expr evalInMeta :: InteractionId -> ComputeMode -> Expr -> TCM Expr -- | Modifier for interactive commands, specifying the amount of -- normalization in the output. normalForm :: (Reduce t, Simplify t, Instantiate t, Normalise t) => Rewrite -> t -> TCM t -- | Modifier for the interactive computation command, specifying the mode -- of computation and result display. computeIgnoreAbstract :: ComputeMode -> Bool computeWrapInput :: ComputeMode -> String -> String showComputed :: ComputeMode -> Expr -> TCM Doc -- | Modifier for interactive commands, specifying whether safety checks -- should be ignored. outputFormId :: OutputForm a b -> b reifyElimToExpr :: MonadReify m => Elim -> m Expr prettyConstraints :: [Closure Constraint] -> TCM [OutputForm Expr Expr] getConstraints :: TCM [OutputForm Expr Expr] namedMetaOf :: OutputConstraint Expr a -> a getConstraintsMentioning :: Rewrite -> MetaId -> TCM [OutputForm Expr Expr] stripConstraintPids :: Constraints -> Constraints -- | Converts an InteractionId to a MetaId. interactionIdToMetaId :: ReadTCState m => InteractionId -> m MetaId getConstraints' :: (ProblemConstraint -> TCM ProblemConstraint) -> (ProblemConstraint -> Bool) -> TCM [OutputForm Expr Expr] getIPBoundary :: Rewrite -> InteractionId -> TCM [IPBoundary' Expr] -- | Goals and Warnings getGoals :: TCM Goals getGoals' :: Rewrite -> Rewrite -> TCM Goals -- | Print open metas nicely. showGoals :: Goals -> TCM String getWarningsAndNonFatalErrors :: TCM WarningsAndNonFatalErrors -- | Collecting the context of the given meta-variable. getResponseContext :: Rewrite -> InteractionId -> TCM [ResponseContextEntry] -- | getSolvedInteractionPoints True returns all solutions, even -- if just solved by another, non-interaction meta. -- -- getSolvedInteractionPoints False only returns metas that are -- solved by a non-meta. getSolvedInteractionPoints :: Bool -> Rewrite -> TCM [(InteractionId, MetaId, Expr)] typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputConstraint Expr NamedMeta) typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputConstraint Expr InteractionId) typeOfMeta' :: Rewrite -> (InteractionId, MetaId) -> TCM (OutputConstraint Expr InteractionId) typesOfVisibleMetas :: Rewrite -> TCM [OutputConstraint Expr InteractionId] typesOfHiddenMetas :: Rewrite -> TCM [OutputConstraint Expr NamedMeta] -- | Create type of application of new helper function that would solve the -- goal. metaHelperType :: Rewrite -> InteractionId -> Range -> String -> TCM (OutputConstraint' Expr Expr) -- | Gives a list of names and corresponding types. This list includes not -- only the local variables in scope, but also the let-bindings. contextOfMeta :: InteractionId -> Rewrite -> TCM [ResponseContextEntry] -- | Returns the type of the expression in the current environment We wake -- up irrelevant variables just in case the user want to invoke that -- command in an irrelevant context. typeInCurrent :: Rewrite -> Expr -> TCM Expr typeInMeta :: InteractionId -> Rewrite -> Expr -> TCM Expr -- | The intro tactic. -- -- Returns the terms (as strings) that can be used to refine the goal. -- Uses the coverage checker to find out which constructors are possible. introTactic :: Bool -> InteractionId -> TCM [String] -- | Runs the given computation as if in an anonymous goal at the end of -- the top-level module. -- -- Sets up current module, scope, and context. atTopLevel :: TCM a -> TCM a -- | Parse a name. parseName :: Range -> String -> TCM QName -- | Check whether an expression is a (qualified) identifier. isQName :: Expr -> Maybe QName isName :: Expr -> Maybe Name -- | Returns the contents of the given module or record. moduleContents :: Rewrite -> Range -> String -> TCM ([Name], Telescope, [(Name, Type)]) -- | Returns the contents of the given record identifier. getRecordContents :: Rewrite -> Expr -> TCM ([Name], Telescope, [(Name, Type)]) -- | Returns the contents of the given module. getModuleContents :: Rewrite -> Maybe QName -> TCM ([Name], Telescope, [(Name, Type)]) whyInScope :: FilePath -> String -> TCM WhyInScopeData instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.TypeChecking.Monad.Base.ProblemConstraint instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.TypeChecking.Monad.Base.Constraint instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Interaction.Base.OutputForm a b) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Interaction.Base.OutputForm a b) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Interaction.Base.OutputConstraint a b) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete b) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Interaction.Base.OutputForm a b) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete b) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Interaction.Base.OutputConstraint a b) instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Interaction.Base.OutputConstraint' a b) instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete b) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Interaction.Base.OutputConstraint' a b) instance Agda.Syntax.Translation.InternalToAbstract.Reify a => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.TypeChecking.Monad.Base.IPBoundary' a) instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.TypeChecking.Monad.Base.IPBoundary' a) instance Agda.Utils.Pretty.Pretty c => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Monad.Base.IPBoundary' c) -- | Backend for generating highlighted, hyperlinked HTML from Agda -- sources. module Agda.Interaction.Highlighting.HTML htmlBackend :: Backend module Agda.Interaction.Highlighting.Dot dotBackend :: Backend module Agda.Compiler.MAlonzo.Compiler ghcBackend :: Backend ghcBackend' :: Backend' GHCFlags GHCEnv GHCModuleEnv GHCModule GHCDefinition data GHCFlags GHCFlags :: Bool -> Bool -> Maybe FilePath -> [String] -> Bool -> Bool -> GHCFlags [flagGhcCompile] :: GHCFlags -> Bool [flagGhcCallGhc] :: GHCFlags -> Bool -- | Use the compiler at PATH instead of "ghc" [flagGhcBin] :: GHCFlags -> Maybe FilePath [flagGhcFlags] :: GHCFlags -> [String] -- | Make inductive constructors strict? [flagGhcStrictData] :: GHCFlags -> Bool -- | Make functions strict? [flagGhcStrict] :: GHCFlags -> Bool defaultGHCFlags :: GHCFlags ghcCommandLineFlags :: [OptDescr (Flag GHCFlags)] withCompilerFlag :: FilePath -> Flag GHCFlags -- | Monads that can read GHCOptions class Monad m => ReadGHCOpts m askGhcOpts :: ReadGHCOpts m => m GHCOptions data GHCModule GHCModule :: GHCModuleEnv -> [MainFunctionDef] -> GHCModule [ghcModModuleEnv] :: GHCModule -> GHCModuleEnv -- | The main function definition(s), if both the module is the -- IsMain module (root/focused) and a suitable main -- function was defined. [ghcModMainFuncs] :: GHCModule -> [MainFunctionDef] data GHCDefinition GHCDefinition :: UsesFloat -> [Decl] -> Definition -> Maybe MainFunctionDef -> Set TopLevelModuleName -> GHCDefinition [ghcDefUsesFloat] :: GHCDefinition -> UsesFloat [ghcDefDecls] :: GHCDefinition -> [Decl] [ghcDefDefinition] :: GHCDefinition -> Definition [ghcDefMainDef] :: GHCDefinition -> Maybe MainFunctionDef [ghcDefImports] :: GHCDefinition -> Set TopLevelModuleName ghcPreCompile :: GHCFlags -> TCM GHCEnv ghcPostCompile :: GHCEnv -> IsMain -> Map TopLevelModuleName GHCModule -> TCM () ghcPreModule :: GHCEnv -> IsMain -> TopLevelModuleName -> Maybe FilePath -> TCM (Recompile GHCModuleEnv GHCModule) ghcPostModule :: GHCEnv -> GHCModuleEnv -> IsMain -> TopLevelModuleName -> [GHCDefinition] -> TCM GHCModule ghcCompileDef :: GHCEnv -> GHCModuleEnv -> IsMain -> Definition -> TCM GHCDefinition -- | We do not erase types that have a HsData pragma. This is to -- ensure a stable interface to third-party code. ghcMayEraseType :: QName -> TCM Bool imports :: BuiltinThings PrimFun -> Set TopLevelModuleName -> [Definition] -> [ImportDecl] newtype UsesFloat UsesFloat :: Bool -> UsesFloat pattern YesFloat :: UsesFloat pattern NoFloat :: UsesFloat mazRTEFloatImport :: UsesFloat -> [ImportDecl] definition :: Definition -> HsCompileM (UsesFloat, [Decl], Maybe CheckedMainFunctionDef) constructorCoverageCode :: QName -> Int -> [QName] -> HaskellType -> [HaskellCode] -> HsCompileM [Decl] -- | Environment for naming of local variables. Invariant: reverse -- ccCxt ++ ccNameSupply data CCEnv CCEnv :: NameSupply -> CCContext -> CCEnv -- | Supply of fresh names [_ccNameSupply] :: CCEnv -> NameSupply -- | Names currently in scope [_ccContext] :: CCEnv -> CCContext type NameSupply = [Name] type CCContext = [Name] ccNameSupply :: Lens' NameSupply CCEnv ccContext :: Lens' CCContext CCEnv -- | Initial environment for expression generation. initCCEnv :: CCEnv -- | Term variables are de Bruijn indices. lookupIndex :: Int -> CCContext -> Name -- | Constructor coverage monad transformer type CCT m = ReaderT CCEnv (WriterT UsesFloat (HsCompileT m)) -- | Constructor coverage monad type CC = CCT TCM liftCC :: Monad m => HsCompileT m a -> CCT m a freshNames :: Monad m => Int -> ([Name] -> CCT m a) -> CCT m a -- | Introduce n variables into the context. intros :: Monad m => Int -> ([Name] -> CCT m a) -> CCT m a checkConstructorType :: QName -> HaskellCode -> HsCompileM [Decl] checkCover :: HasConstInfo m => QName -> HaskellType -> Nat -> [QName] -> [HaskellCode] -> m [Decl] closedTerm_ :: TTerm -> HsCompileM Exp closedTerm :: TTerm -> HsCompileM (Exp, UsesFloat) mkIf :: TTerm -> CC TTerm -- | Extract Agda term to Haskell expression. Erased arguments are -- extracted as (). Types are extracted as (). term :: TTerm -> CC Exp -- | Translate a non-application, non-coercion, non-constructor, -- non-definition term. noApplication :: TTerm -> CC Exp hsCoerce :: Exp -> Exp compilePrim :: TPrim -> Exp alt :: Int -> TAlt -> CC Alt literal :: forall m. Monad m => Literal -> CCT m Exp hslit :: Literal -> Literal litString :: Text -> Exp litqname :: QName -> Exp litqnamepat :: QName -> Pat condecl :: QName -> Induction -> HsCompileM ConDecl compiledcondecl :: Maybe Nat -> QName -> HsCompileM Decl compiledTypeSynonym :: QName -> String -> Nat -> Decl tvaldecl :: QName -> Induction -> Nat -> [ConDecl] -> Maybe Clause -> [Decl] infodecl :: QName -> [Decl] -> [Decl] type MonadGHCIO m = (MonadIO m, ReadGHCOpts m) copyRTEModules :: MonadGHCIO m => m () writeModule :: MonadGHCIO m => Module -> m () outFileAndDir :: MonadGHCIO m => ModuleName -> m (FilePath, FilePath) curOutFileAndDir :: (MonadGHCIO m, ReadGHCModuleEnv m) => m (FilePath, FilePath) curOutFile :: (MonadGHCIO m, ReadGHCModuleEnv m) => m FilePath callGHC :: ReaderT GHCModule TCM () instance GHC.Generics.Generic Agda.Compiler.MAlonzo.Compiler.GHCFlags instance GHC.Show.Show Agda.Compiler.MAlonzo.Compiler.UsesFloat instance GHC.Classes.Eq Agda.Compiler.MAlonzo.Compiler.UsesFloat instance GHC.Base.Semigroup Agda.Compiler.MAlonzo.Compiler.UsesFloat instance GHC.Base.Monoid Agda.Compiler.MAlonzo.Compiler.UsesFloat instance GHC.Base.Monad m => Agda.Compiler.MAlonzo.Compiler.ReadGHCOpts (Control.Monad.Trans.Reader.ReaderT Agda.Compiler.MAlonzo.Compiler.GHCModule m) instance GHC.Base.Monad m => Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv (Control.Monad.Trans.Reader.ReaderT Agda.Compiler.MAlonzo.Compiler.GHCModule m) instance GHC.Base.Monad m => Agda.Compiler.MAlonzo.Compiler.ReadGHCOpts (Control.Monad.Trans.Reader.ReaderT Agda.Compiler.MAlonzo.Misc.GHCOptions m) instance GHC.Base.Monad m => Agda.Compiler.MAlonzo.Compiler.ReadGHCOpts (Control.Monad.Trans.Reader.ReaderT Agda.Compiler.MAlonzo.Misc.GHCEnv m) instance GHC.Base.Monad m => Agda.Compiler.MAlonzo.Compiler.ReadGHCOpts (Control.Monad.Trans.Reader.ReaderT Agda.Compiler.MAlonzo.Misc.GHCModuleEnv m) instance Control.DeepSeq.NFData Agda.Compiler.MAlonzo.Compiler.GHCFlags module Agda.Compiler.ToTreeless -- | 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. toTreeless :: EvaluationStrategy -> QName -> TCM (Maybe TTerm) closedTermToTreeless :: EvaluationStrategy -> Term -> TCM TTerm module Agda.Compiler.Treeless.Uncase caseToSeq :: Monad m => TTerm -> m TTerm module Agda.Compiler.Treeless.Compare equalTerms :: TTerm -> TTerm -> Bool module Agda.Compiler.Treeless.Simplify simplifyTTerm :: TTerm -> TCM TTerm instance GHC.Classes.Ord Agda.Compiler.Treeless.Simplify.Atom instance GHC.Classes.Eq Agda.Compiler.Treeless.Simplify.Atom instance GHC.Show.Show Agda.Compiler.Treeless.Simplify.Atom module Agda.Compiler.Treeless.Identity detectIdentityFunctions :: QName -> TTerm -> TCM TTerm instance GHC.Base.Semigroup Agda.Compiler.Treeless.Identity.IdentityIn -- | Translates the Agda builtin nat datatype to arbitrary-precision -- integers. -- -- Philipp, 20150921: At the moment, this optimization is the reason that -- there is a TAPlus alternative. For Haskell, this can easily be -- translated to guards. However, in the long term it would be easier for -- the backends if these things were translated directly to a less-than -- primitive and if-then-else expressions or similar. This would require -- us to add some internal Bool-datatype as compiler-internal type and a -- primitive less-than function, which will be much easier once Treeless -- is used for whole modules. -- -- Ulf, 2015-09-21: No, actually we need the n+k patterns, or at least -- guards. Representing them with if-then-else would make it a lot harder -- to do optimisations that analyse case tree, like impossible case -- elimination. -- -- Ulf, 2015-10-30: Guards are actually a better primitive. Fixed that. module Agda.Compiler.Treeless.Builtin translateBuiltins :: TTerm -> TCM TTerm module Agda.Compiler.MAlonzo.Primitives newtype MainFunctionDef MainFunctionDef :: Definition -> MainFunctionDef data CheckedMainFunctionDef CheckedMainFunctionDef :: MainFunctionDef -> Decl -> CheckedMainFunctionDef [checkedMainDef] :: CheckedMainFunctionDef -> MainFunctionDef [checkedMainDecl] :: CheckedMainFunctionDef -> Decl asMainFunctionDef :: Definition -> Maybe MainFunctionDef mainFunctionDefs :: Interface -> [MainFunctionDef] -- | Check that the main function has type IO a, for some a. checkTypeOfMain :: Definition -> HsCompileM (Maybe CheckedMainFunctionDef) checkTypeOfMain' :: MainFunctionDef -> TCM CheckedMainFunctionDef treelessPrimName :: TPrim -> String -- | Haskell modules to be imported for BUILT-INs importsForPrim :: BuiltinThings PrimFun -> [Definition] -> [ModuleName] xForPrim :: Map String a -> BuiltinThings PrimFun -> [Definition] -> [a] -- | Definition bodies for primitive functions primBody :: MonadTCError m => String -> m Exp noCheckCover :: (HasBuiltins m, MonadReduce m) => QName -> m Bool bltQual' :: String -> String -> HsCompileM String module Agda.Compiler.MAlonzo.Pretty prettyPrint :: Pretty a => a -> String prettyWhere :: Maybe Binds -> Doc -> Doc prettyRhs :: String -> Rhs -> Doc prettyGuardedRhs :: String -> GuardedRhs -> Doc isOperator :: QName -> Bool prettyQName :: QName -> Doc instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Module instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.ModulePragma instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.ImportDecl instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.ImportSpec instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Decl instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.ConDecl instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Strictness instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Match instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Pat instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Binds instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.DataOrNew instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.TyVarBind instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Type instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Stmt instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Literal instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Exp instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Alt instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.ModuleName instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.QName instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.Name instance Agda.Utils.Pretty.Pretty Agda.Utils.Haskell.Syntax.QOp module Agda.Compiler.MAlonzo.Encode -- | Haskell module names have to satisfy the Haskell (including the -- hierarchical module namespace extension) lexical syntax: -- --
--   modid -> [modid.] large {small | large | digit | ' }
--   
-- -- encodeModuleName is an injective function into the set of -- module names defined by modid. The function preserves -- .s, and it also preserves module names whose first name part -- is not mazstr. -- -- Precondition: The input must not start or end with ., and no -- two .s may be adjacent. encodeModuleName :: ModuleName -> ModuleName module Agda.Compiler.MAlonzo.Misc data HsModuleEnv HsModuleEnv :: TopLevelModuleName -> Bool -> HsModuleEnv -- | The name of the Agda module [mazModuleName] :: HsModuleEnv -> TopLevelModuleName -- | Whether this is the compilation root and therefore should have the -- main function. This corresponds to the IsMain flag -- provided to the backend, not necessarily whether the GHC module has a -- main function defined. [mazIsMainModule] :: HsModuleEnv -> Bool -- | The options derived from GHCFlags and other shared options. data GHCOptions GHCOptions :: Bool -> FilePath -> [String] -> FilePath -> Bool -> Bool -> GHCOptions [optGhcCallGhc] :: GHCOptions -> Bool -- | Use the compiler at PATH instead of "ghc" [optGhcBin] :: GHCOptions -> FilePath [optGhcFlags] :: GHCOptions -> [String] [optGhcCompileDir] :: GHCOptions -> FilePath -- | Make inductive constructors strict? [optGhcStrictData] :: GHCOptions -> Bool -- | Make functions strict? [optGhcStrict] :: GHCOptions -> Bool -- | A static part of the GHC backend's environment that does not change -- from module to module. data GHCEnv GHCEnv :: GHCOptions -> Maybe QName -> (QName -> Bool) -> GHCEnv [ghcEnvOpts] :: GHCEnv -> GHCOptions [ghcEnvBool, ghcEnvTrue, ghcEnvFalse, ghcEnvMaybe, ghcEnvNothing, ghcEnvJust, ghcEnvList, ghcEnvNil, ghcEnvCons, ghcEnvNat, ghcEnvInteger, ghcEnvWord64, ghcEnvInf, ghcEnvSharp, ghcEnvFlat, ghcEnvInterval, ghcEnvIZero, ghcEnvIOne, ghcEnvIsOne, ghcEnvItIsOne, ghcEnvIsOne1, ghcEnvIsOne2, ghcEnvIsOneEmpty, ghcEnvPathP, ghcEnvSub, ghcEnvSubIn, ghcEnvId, ghcEnvConId] :: GHCEnv -> Maybe QName -- | Is the given name a TC builtin (except for TC -- itself)? [ghcEnvIsTCBuiltin] :: GHCEnv -> QName -> Bool -- | Module compilation environment, bundling the overall backend session -- options along with the module's basic readable properties. data GHCModuleEnv GHCModuleEnv :: GHCEnv -> HsModuleEnv -> GHCModuleEnv [ghcModEnv] :: GHCModuleEnv -> GHCEnv [ghcModHsModuleEnv] :: GHCModuleEnv -> HsModuleEnv -- | Monads that can produce a GHCModuleEnv. class Monad m => ReadGHCModuleEnv m askGHCModuleEnv :: ReadGHCModuleEnv m => m GHCModuleEnv askGHCModuleEnv :: (ReadGHCModuleEnv m, MonadTrans t, Monad n, m ~ t n, ReadGHCModuleEnv n) => m GHCModuleEnv askHsModuleEnv :: ReadGHCModuleEnv m => m HsModuleEnv askGHCEnv :: ReadGHCModuleEnv m => m GHCEnv newtype HsCompileState HsCompileState :: Set TopLevelModuleName -> HsCompileState [mazAccumlatedImports] :: HsCompileState -> Set TopLevelModuleName -- | Transformer adding read-only module info and a writable set of -- imported modules type HsCompileT m = ReaderT GHCModuleEnv (StateT HsCompileState m) -- | The default compilation monad is the entire TCM (☹️) enriched with our -- state and module info type HsCompileM = HsCompileT TCM runHsCompileT' :: HsCompileT m a -> GHCModuleEnv -> HsCompileState -> m (a, HsCompileState) runHsCompileT :: HsCompileT m a -> GHCModuleEnv -> m (a, HsCompileState) -- | Whether the current module is expected to have the main -- function. This corresponds to the IsMain flag provided to the -- backend, not necessarily whether the GHC module actually has a -- main function defined. curIsMainModule :: ReadGHCModuleEnv m => m Bool -- | This is the same value as curMName, but does not rely on the -- TCM's state. (curMName and co. should be removed, but the -- current Backend interface is not sufficient yet to allow -- that) curAgdaMod :: ReadGHCModuleEnv m => m TopLevelModuleName -- | Get the Haskell module name of the currently-focused Agda module curHsMod :: ReadGHCModuleEnv m => m ModuleName -- | There are two kinds of functions: those definitely without unused -- arguments, and those that might have unused arguments. data FunctionKind NoUnused :: FunctionKind PossiblyUnused :: FunctionKind -- | Different kinds of variables: those starting with a, those -- starting with v, and those starting with x. data VariableKind A :: VariableKind V :: VariableKind X :: VariableKind -- | Different kinds of names. data NameKind -- | Types. TypeK :: NameKind -- | Constructors. ConK :: NameKind -- | Variables. VarK :: VariableKind -> NameKind -- | Used for coverage checking. CoverK :: NameKind -- | Used for constructor type checking. CheckK :: NameKind -- | Other functions. FunK :: FunctionKind -> NameKind -- | Turns strings into valid Haskell identifiers. -- -- In order to avoid clashes with names of regular Haskell definitions -- (those not generated from Agda definitions), make sure that the -- Haskell names are always used qualified, with the exception of names -- from the prelude. encodeString :: NameKind -> String -> String ihname :: VariableKind -> Nat -> Name unqhname :: NameKind -> QName -> Name tlmodOf :: ReadTCState m => ModuleName -> m ModuleName xqual :: QName -> Name -> HsCompileM QName xhqn :: NameKind -> QName -> HsCompileM QName hsName :: String -> QName conhqn :: QName -> HsCompileM QName bltQual :: String -> String -> HsCompileM QName dname :: QName -> Name -- | Name for definition stripped of unused arguments duname :: QName -> Name hsPrimOp :: String -> QOp hsPrimOpApp :: String -> Exp -> Exp -> Exp hsInt :: Integer -> Exp hsTypedInt :: Integral a => a -> Exp hsTypedDouble :: Real a => a -> Exp hsLet :: Name -> Exp -> Exp -> Exp hsVarUQ :: Name -> Exp hsAppView :: Exp -> [Exp] hsOpToExp :: QOp -> Exp hsLambda :: [Pat] -> Exp -> Exp hsMapAlt :: (Exp -> Exp) -> Alt -> Alt hsMapRHS :: (Exp -> Exp) -> Rhs -> Rhs mazstr :: String mazName :: Name mazMod' :: String -> ModuleName mazMod :: TopLevelModuleName -> ModuleName mazCoerceName :: String mazErasedName :: String mazAnyTypeName :: String mazCoerce :: Exp mazUnreachableError :: Exp rtmUnreachableError :: Exp mazHole :: Exp rtmHole :: String -> Exp mazAnyType :: Type mazRTE :: ModuleName mazRTEFloat :: ModuleName rtmQual :: String -> QName rtmVar :: String -> Exp rtmError :: Text -> Exp unsafeCoerceMod :: ModuleName fakeD :: Name -> String -> Decl fakeDS :: String -> String -> Decl fakeDQ :: QName -> String -> Decl fakeType :: String -> Type fakeExp :: String -> Exp fakeDecl :: String -> Decl emptyBinds :: Maybe Binds -- | Can the character be used in a Haskell module name part -- (conid)? This function is more restrictive than what the -- Haskell report allows. isModChar :: Char -> Bool instance GHC.Base.Monoid Agda.Compiler.MAlonzo.Misc.HsCompileState instance GHC.Base.Semigroup Agda.Compiler.MAlonzo.Misc.HsCompileState instance GHC.Classes.Eq Agda.Compiler.MAlonzo.Misc.HsCompileState instance GHC.Base.Monad m => Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv (Control.Monad.Trans.Reader.ReaderT Agda.Compiler.MAlonzo.Misc.GHCModuleEnv m) instance Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv m => Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv (Control.Monad.Trans.Except.ExceptT e m) instance Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv m => Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv (Control.Monad.Trans.Identity.IdentityT m) instance Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv m => Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv (Control.Monad.Trans.Maybe.MaybeT m) instance Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv m => Agda.Compiler.MAlonzo.Misc.ReadGHCModuleEnv (Control.Monad.Trans.State.Lazy.StateT s m) module Agda.Compiler.MAlonzo.Pragmas type HaskellCode = String type HaskellType = String -- | GHC backend translation pragmas. data HaskellPragma HsDefn :: Range -> HaskellCode -> HaskellPragma HsType :: Range -> HaskellType -> HaskellPragma -- | @COMPILE GHC X = data D (c₁ | ... | cₙ) HsData :: Range -> HaskellType -> [HaskellCode] -> HaskellPragma -- |
--   COMPILE GHC x as f
--   
HsExport :: Range -> HaskellCode -> HaskellPragma parsePragma :: CompilerPragma -> Either String HaskellPragma parseHaskellPragma :: (MonadTCError m, MonadTrace m) => CompilerPragma -> m HaskellPragma getHaskellPragma :: QName -> TCM (Maybe HaskellPragma) sanityCheckPragma :: (HasBuiltins m, MonadTCError m, MonadReduce m) => Definition -> Maybe HaskellPragma -> m () getHaskellConstructor :: QName -> HsCompileM (Maybe HaskellCode) -- | Get content of FOREIGN GHC pragmas, sorted by -- KindOfForeignCode: file header pragmas, import statements, -- rest. foreignHaskell :: Interface -> ([String], [String], [String]) -- | Classify FOREIGN Haskell code. data KindOfForeignCode -- | A pragma that must appear before the module header. ForeignFileHeaderPragma :: KindOfForeignCode -- | An import statement. Must appear right after the module header. ForeignImport :: KindOfForeignCode -- | The rest. To appear after the import statements. ForeignOther :: KindOfForeignCode -- | Classify a FOREIGN GHC declaration. classifyForeign :: String -> KindOfForeignCode -- | Classify a Haskell pragma into whether it is a file header pragma or -- not. classifyPragma :: String -> KindOfForeignCode -- | Partition a list by KindOfForeignCode attribute. partitionByKindOfForeignCode :: (a -> KindOfForeignCode) -> [a] -> ([a], [a], [a]) instance GHC.Classes.Eq Agda.Compiler.MAlonzo.Pragmas.HaskellPragma instance GHC.Show.Show Agda.Compiler.MAlonzo.Pragmas.HaskellPragma instance Agda.Syntax.Position.HasRange Agda.Compiler.MAlonzo.Pragmas.HaskellPragma instance Agda.Utils.Pretty.Pretty Agda.Compiler.MAlonzo.Pragmas.HaskellPragma -- | Translating Agda types to Haskell types. Used to ensure that imported -- Haskell functions have the right type. module Agda.Compiler.MAlonzo.HaskellTypes haskellType :: QName -> HsCompileM Type checkConstructorCount :: QName -> [QName] -> [HaskellCode] -> TCM () hsTelApproximation :: Type -> HsCompileM ([Type], Type) hsTelApproximation' :: PolyApprox -> Type -> HsCompileM ([Type], Type) instance GHC.Classes.Eq Agda.Compiler.MAlonzo.HaskellTypes.PolyApprox module Agda.Compiler.MAlonzo.Coerce -- | Insert unsafeCoerce (in the form of TCoerce) everywhere it's -- needed in the right-hand side of a definition. addCoercions :: HasConstInfo m => TTerm -> m TTerm -- | The number of retained arguments after erasure. erasedArity :: HasConstInfo m => QName -> m Nat -- | A command which calls a compiler module Agda.Compiler.CallCompiler -- | Calls a compiler: -- -- callCompiler :: Bool -> FilePath -> [String] -> Maybe FilePath -> Maybe TextEncoding -> TCM () -- | Generalisation of callCompiler where the raised exception is -- returned. callCompiler' :: FilePath -> [String] -> Maybe FilePath -> Maybe TextEncoding -> TCM (Maybe String) module Agda.TypeChecking.Monad.Imports addImport :: TopLevelModuleName -> TCM () addImportCycleCheck :: TopLevelModuleName -> TCM a -> TCM a -- | Assumes that the first module in the import path is the module we are -- worried about. checkForImportCycle :: TCM () dropDecodedModule :: TopLevelModuleName -> TCM () getDecodedModule :: TopLevelModuleName -> TCM (Maybe ModuleInfo) getDecodedModules :: TCM DecodedModules getImportPath :: TCM [TopLevelModuleName] getPrettyVisitedModules :: ReadTCState m => m Doc getVisitedModule :: ReadTCState m => TopLevelModuleName -> m (Maybe ModuleInfo) getVisitedModules :: ReadTCState m => m VisitedModules setDecodedModules :: DecodedModules -> TCM () setVisitedModules :: VisitedModules -> TCM () storeDecodedModule :: ModuleInfo -> TCM () visitModule :: ModuleInfo -> TCM () withImportPath :: [TopLevelModuleName] -> TCM a -> TCM a module Agda.TypeChecking.Monad.Caching -- | Writes a TypeCheckAction to the current log, using the current -- PostScopeState writeToCurrentLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => TypeCheckAction -> m () -- | Reads the next entry in the cached type check log, if present. readFromCachedLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => m (Maybe (TypeCheckAction, PostScopeState)) -- | Empties the "to read" CachedState. To be used when it gets invalid. cleanCachedLog :: (MonadDebug m, MonadTCState m) => m () -- | Caches the current type check log. Discardes the old cache. Does -- nothing if caching is inactive. cacheCurrentLog :: (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. activateLoadedFileCache :: (HasOptions m, MonadDebug m, MonadTCState m) => m () -- | To be called before any write or restore calls. cachingStarts :: (MonadDebug m, MonadTCState m, ReadTCState m) => m () areWeCaching :: ReadTCState m => m Bool -- | Runs the action and restores the current cache at the end of it. localCache :: (MonadTCState m, ReadTCState m) => m a -> m a -- | Runs the action without cache and restores the current cache at the -- end of it. withoutCache :: (MonadTCState m, ReadTCState m) => m a -> m a restorePostScopeState :: (MonadDebug m, MonadTCState m) => PostScopeState -> m () -- | This module implements the Agda Abstract Machine used for compile-time -- reduction. It's a call-by-need environment machine with an implicit -- heap maintained using STRefs. See the AM type below for -- a description of the machine. -- -- Some other tricks that improves performance: -- -- -- -- A big chunk of the time during reduction is spent looking up -- definitions in the signature. Any long-running reduction will use only -- a handful definitions though, so memoising getConstInfo is a big win. -- -- -- -- Since we memoise getConstInfo we can do some preprocessing of the -- definitions, returning a CompactDef instead of a -- Definition. In particular we streamline the case trees used for -- matching in a few ways: -- -- -- -- None of these changes would make sense to incorporate into the actual -- case trees. The first two loses information that we need in other -- places and the third would complicate a lot of code working with case -- trees. -- -- CompactDef also has a special representation for -- built-in/primitive functions that can be implemented as pure functions -- from Literals. module Agda.TypeChecking.Reduce.Fast -- | The entry point to the reduction machine. fastReduce :: Term -> ReduceM (Blocked Term) fastNormalise :: Term -> ReduceM Term instance GHC.Classes.Eq Agda.TypeChecking.Reduce.Fast.Normalisation instance GHC.Base.Functor Agda.TypeChecking.Reduce.Fast.Thunk instance Data.Traversable.Traversable Agda.TypeChecking.Reduce.Fast.ElimZipper instance Data.Foldable.Foldable Agda.TypeChecking.Reduce.Fast.ElimZipper instance GHC.Base.Functor Agda.TypeChecking.Reduce.Fast.ElimZipper instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Reduce.Fast.ElimZipper a) instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.TypeChecking.Reduce.Fast.ElimZipper a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Reduce.Fast.ElimZipper a) instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.AM s) instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.ControlFrame s) instance Agda.Utils.Zipper.Zipper (Agda.TypeChecking.Reduce.Fast.ElimZipper a) instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.MatchStack s) instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.CatchAllFrame s) instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.Pointer s) instance Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.Closure s) instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.Thunk a) instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Reduce.Fast.FastCompiledClauses instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.TypeChecking.Reduce.Fast.FastCase a) module Agda.TypeChecking.CompiledClause.Match matchCompiled :: CompiledClauses -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Args) Term) -- | matchCompiledE c es takes a function given by case tree -- c and and a spine es and tries to apply the function -- to es. matchCompiledE :: CompiledClauses -> MaybeReducedElims -> ReduceM (Reduced (Blocked Elims) Term) -- | A stack entry is a triple consisting of 1. the part of the case tree -- to continue matching, 2. the current argument vector, and 3. a patch -- function taking the current argument vector back to the original -- argument vector. type Frame = (CompiledClauses, MaybeReducedElims, Elims -> Elims) type Stack = [Frame] -- | match' tries to solve the matching problems on the -- Stack. In each iteration, the top problem is removed and -- handled. -- -- If the top problem was a Done, we succeed. -- -- If the top problem was a Case n and the nth argument -- of the problem is not a constructor or literal, we are stuck, thus, -- fail. -- -- If we have a branch for the constructor/literal, we put it on the -- stack to continue. If we do not have a branch, we fall through to the -- next problem, which should be the corresponding catch-all branch. -- -- An empty stack is an exception that can come only from an incomplete -- function definition. match' :: Stack -> ReduceM (Reduced (Blocked Elims) Term) -- | Converts case matches on literals to if cascades with equality -- comparisons. module Agda.Compiler.Treeless.EliminateLiteralPatterns eliminateLiteralPatterns :: TTerm -> TCM TTerm data BuiltinKit BuiltinKit :: Maybe QName -> Maybe QName -> BuiltinKit [nat] :: BuiltinKit -> Maybe QName [int] :: BuiltinKit -> Maybe QName transform :: BuiltinKit -> TTerm -> TTerm -- | Eliminates case defaults by adding an alternative for all possible -- constructors. Literal cases are preserved as-is. module Agda.Compiler.Treeless.EliminateDefaults eliminateCaseDefaults :: TTerm -> TCM TTerm -- | Tools to manipulate patterns in internal syntax in the TCM (type -- checking monad). module Agda.TypeChecking.Patterns.Internal -- | Convert a term (from a dot pattern) to a DeBruijn pattern. class TermToPattern a b termToPattern :: TermToPattern a b => a -> TCM b termToPattern :: (TermToPattern a b, TermToPattern a' b', Traversable f, a ~ f a', b ~ f b') => a -> TCM b dotPatternsToPatterns :: forall a. DeBruijn (Pattern' a) => Pattern' a -> TCM (Pattern' a) instance Agda.TypeChecking.Patterns.Internal.TermToPattern a b => Agda.TypeChecking.Patterns.Internal.TermToPattern [a] [b] instance Agda.TypeChecking.Patterns.Internal.TermToPattern a b => Agda.TypeChecking.Patterns.Internal.TermToPattern (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b) instance Agda.TypeChecking.Patterns.Internal.TermToPattern a b => Agda.TypeChecking.Patterns.Internal.TermToPattern (Agda.Syntax.Common.Named c a) (Agda.Syntax.Common.Named c b) instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn (Agda.Syntax.Internal.Pattern' a) => Agda.TypeChecking.Patterns.Internal.TermToPattern Agda.Syntax.Internal.Term (Agda.Syntax.Internal.Pattern' a) -- | Sanity checking for internal syntax. Mostly checking variable scoping. module Agda.Syntax.Internal.SanityCheck sanityCheckVars :: (Pretty a, Free a) => Telescope -> a -> TCM () -- | Check that Γ ⊢ ρ : Δ. sanityCheckSubst :: (Pretty a, Free a) => Telescope -> Substitution' a -> Telescope -> TCM () module Agda.Interaction.Monad -- | Interaction monad. data IM a runIM :: IM a -> TCM a -- | Line reader. The line reader history is not stored between sessions. readline :: String -> IM (Maybe String) instance Agda.TypeChecking.Monad.Base.MonadTCM Agda.Interaction.Monad.IM instance Agda.TypeChecking.Monad.Base.MonadTCState Agda.Interaction.Monad.IM instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.Interaction.Monad.IM instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.Interaction.Monad.IM instance Agda.Interaction.Options.HasOptions.HasOptions Agda.Interaction.Monad.IM instance Control.Monad.IO.Class.MonadIO Agda.Interaction.Monad.IM instance GHC.Base.Monad Agda.Interaction.Monad.IM instance GHC.Base.Applicative Agda.Interaction.Monad.IM instance GHC.Base.Functor Agda.Interaction.Monad.IM instance Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr Agda.Interaction.Monad.IM -- | Encoding stuff into JSON values in TCM module Agda.Interaction.JSON -- | Left-to-right composition of Kleisli arrows. -- -- '(bs >=> cs) a' can be understood as the -- do expression -- --
--   do b <- bs a
--      cs b
--   
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 >=> -- | Right-to-left composition of Kleisli arrows. -- (>=>), with the arguments flipped. -- -- Note how this operator resembles function composition -- (.): -- --
--   (.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
--   (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
--   
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 <=< decode :: FromJSON a => ByteString -> Maybe a decode' :: FromJSON a => ByteString -> Maybe a decodeFileStrict :: FromJSON a => FilePath -> IO (Maybe a) decodeFileStrict' :: FromJSON a => FilePath -> IO (Maybe a) decodeStrict :: FromJSON a => ByteString -> Maybe a decodeStrict' :: FromJSON a => ByteString -> Maybe a eitherDecode :: FromJSON a => ByteString -> Either String a eitherDecode' :: FromJSON a => ByteString -> Either String a eitherDecodeFileStrict :: FromJSON a => FilePath -> IO (Either String a) eitherDecodeFileStrict' :: FromJSON a => FilePath -> IO (Either String a) eitherDecodeStrict :: FromJSON a => ByteString -> Either String a eitherDecodeStrict' :: FromJSON a => ByteString -> Either String a encode :: ToJSON a => a -> ByteString encodeFile :: ToJSON a => FilePath -> a -> IO () pairs :: Series -> Encoding json :: Parser Value json' :: Parser Value foldable :: (Foldable t, ToJSON a) => t a -> Encoding (.!=) :: Parser (Maybe a) -> a -> Parser a (.:) :: FromJSON a => Object -> Key -> Parser a (.:!) :: FromJSON a => Object -> Key -> Parser (Maybe a) (.:?) :: FromJSON a => Object -> Key -> Parser (Maybe a) fromJSON :: FromJSON a => Value -> Result a genericFromJSONKey :: (Generic a, GFromJSONKey (Rep a)) => JSONKeyOptions -> FromJSONKeyFunction a genericLiftParseJSON :: (Generic1 f, GFromJSON One (Rep1 f)) => Options -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) genericParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Options -> Value -> Parser a parseIndexedJSON :: (Value -> Parser a) -> Int -> Value -> Parser a parseJSON1 :: (FromJSON1 f, FromJSON a) => Value -> Parser (f a) parseJSON2 :: (FromJSON2 f, FromJSON a, FromJSON b) => Value -> Parser (f a b) withArray :: String -> (Array -> Parser a) -> Value -> Parser a withBool :: String -> (Bool -> Parser a) -> Value -> Parser a withEmbeddedJSON :: String -> (Value -> Parser a) -> Value -> Parser a withObject :: String -> (Object -> Parser a) -> Value -> Parser a withScientific :: String -> (Scientific -> Parser a) -> Value -> Parser a withText :: String -> (Text -> Parser a) -> Value -> Parser a () :: Parser a -> JSONPathElement -> Parser a camelTo2 :: Char -> String -> String defaultJSONKeyOptions :: JSONKeyOptions defaultOptions :: Options defaultTaggedObject :: SumEncoding object :: [Pair] -> Value genericLiftToEncoding :: (Generic1 f, GToJSON' Encoding One (Rep1 f)) => Options -> (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding genericLiftToJSON :: (Generic1 f, GToJSON' Value One (Rep1 f)) => Options -> (a -> Value) -> ([a] -> Value) -> f a -> Value genericToEncoding :: (Generic a, GToJSON' Encoding Zero (Rep a)) => Options -> a -> Encoding genericToJSON :: (Generic a, GToJSON' Value Zero (Rep a)) => Options -> a -> Value genericToJSONKey :: (Generic a, GToJSONKey (Rep a)) => JSONKeyOptions -> ToJSONKeyFunction a toEncoding1 :: (ToJSON1 f, ToJSON a) => f a -> Encoding toEncoding2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Encoding toJSON1 :: (ToJSON1 f, ToJSON a) => f a -> Value toJSON2 :: (ToJSON2 f, ToJSON a, ToJSON b) => f a b -> Value type Encoding = Encoding' Value fromEncoding :: Encoding' tag -> Builder data Series data Key type GToEncoding = GToJSON' Encoding type GToJSON = GToJSON' Value data FromArgs arity a class FromJSON a parseJSON :: FromJSON a => Value -> Parser a parseJSONList :: FromJSON a => Value -> Parser [a] class FromJSON1 (f :: Type -> Type) liftParseJSON :: FromJSON1 f => (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (f a) liftParseJSONList :: FromJSON1 f => (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [f a] class FromJSON2 (f :: Type -> Type -> Type) liftParseJSON2 :: FromJSON2 f => (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (f a b) liftParseJSONList2 :: FromJSON2 f => (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [f a b] class FromJSONKey a fromJSONKey :: FromJSONKey a => FromJSONKeyFunction a fromJSONKeyList :: FromJSONKey a => FromJSONKeyFunction [a] data FromJSONKeyFunction a [FromJSONKeyCoerce] :: forall a. Coercible Text a => FromJSONKeyFunction a [FromJSONKeyText] :: forall a. !Text -> a -> FromJSONKeyFunction a [FromJSONKeyTextParser] :: forall a. !Text -> Parser a -> FromJSONKeyFunction a [FromJSONKeyValue] :: forall a. !Value -> Parser a -> FromJSONKeyFunction a class GFromJSON arity (f :: Type -> Type) class (ConstructorNames f, SumFromString f) => GFromJSONKey (f :: Type -> Type) data One data Zero type Array = Vector Value newtype DotNetTime DotNetTime :: UTCTime -> DotNetTime [fromDotNetTime] :: DotNetTime -> UTCTime data JSONKeyOptions type JSONPath = [JSONPathElement] type Object = KeyMap Value data Options data SumEncoding TaggedObject :: String -> String -> SumEncoding [tagFieldName] :: SumEncoding -> String [contentsFieldName] :: SumEncoding -> String UntaggedValue :: SumEncoding ObjectWithSingleField :: SumEncoding TwoElemArray :: SumEncoding data Value Object :: !Object -> Value Array :: !Array -> Value String :: !Text -> Value Number :: !Scientific -> Value Bool :: !Bool -> Value Null :: Value class GToJSON' enc arity (f :: TYPE LiftedRep -> Type) class GetConName f => GToJSONKey (f :: k -> Type) class KeyValue kv data ToArgs res arity a class ToJSON a toJSON :: ToJSON a => a -> Value toEncoding :: ToJSON a => a -> Encoding toJSONList :: ToJSON a => [a] -> Value toEncodingList :: ToJSON a => [a] -> Encoding class ToJSON1 (f :: TYPE LiftedRep -> TYPE LiftedRep) liftToJSON :: ToJSON1 f => (a -> Value) -> ([a] -> Value) -> f a -> Value liftToJSONList :: ToJSON1 f => (a -> Value) -> ([a] -> Value) -> [f a] -> Value liftToEncoding :: ToJSON1 f => (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding liftToEncodingList :: ToJSON1 f => (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding class ToJSON2 (f :: TYPE LiftedRep -> TYPE LiftedRep -> TYPE LiftedRep) liftToJSON2 :: ToJSON2 f => (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> f a b -> Value liftToJSONList2 :: ToJSON2 f => (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [f a b] -> Value liftToEncoding2 :: ToJSON2 f => (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> f a b -> Encoding liftToEncodingList2 :: ToJSON2 f => (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [f a b] -> Encoding class ToJSONKey a toJSONKey :: ToJSONKey a => ToJSONKeyFunction a toJSONKeyList :: ToJSONKey a => ToJSONKeyFunction [a] data ToJSONKeyFunction a ToJSONKeyText :: !a -> Key -> !a -> Encoding' Key -> ToJSONKeyFunction a ToJSONKeyValue :: !a -> Value -> !a -> Encoding -> ToJSONKeyFunction a -- | The JSON version ofPrettyTCM, for encoding JSON value in TCM class EncodeTCM a encodeTCM :: EncodeTCM a => a -> TCM Value encodeTCM :: (EncodeTCM a, ToJSON a) => a -> TCM Value -- | TCM monadic version of object obj :: [TCM Pair] -> TCM Value -- | A handy alternative of obj with kind specified kind :: Text -> [TCM Pair] -> TCM Value -- | A handy alternative of object with kind specified kind' :: Text -> [Pair] -> Value -- | A key-value pair for encoding a JSON object. (.=) :: ToJSON a => Text -> a -> Pair -- | Abbreviation of `_ #= encodeTCM _` (@=) :: EncodeTCM a => Text -> a -> TCM Pair -- | Pairs a key with a value wrapped in TCM (#=) :: ToJSON a => Text -> TCM a -> TCM Pair instance Agda.Interaction.JSON.EncodeTCM a => Agda.Interaction.JSON.EncodeTCM [a] instance Agda.Interaction.JSON.EncodeTCM GHC.Base.String instance Agda.Interaction.JSON.EncodeTCM GHC.Types.Bool instance Agda.Interaction.JSON.EncodeTCM GHC.Types.Int instance Agda.Interaction.JSON.EncodeTCM GHC.Int.Int32 instance Agda.Interaction.JSON.EncodeTCM Data.Aeson.Types.Internal.Value instance Agda.Interaction.JSON.EncodeTCM Text.PrettyPrint.HughesPJ.Doc instance Agda.Interaction.JSON.EncodeTCM a => Agda.Interaction.JSON.EncodeTCM (GHC.Maybe.Maybe a) instance Data.Aeson.Types.ToJSON.ToJSON Text.PrettyPrint.HughesPJ.Doc instance Data.Aeson.Types.ToJSON.ToJSON Agda.Utils.FileName.AbsolutePath -- | Common syntax highlighting functions for Emacs and JSON module Agda.Interaction.Highlighting.Common -- | Converts the aspect and otherAspects fields to strings -- that are friendly to editors. toAtoms :: Aspects -> [String] -- | Choose which method to use based on HighlightingInfo and -- HighlightingMethod chooseHighlightingMethod :: HighlightingInfo -> HighlightingMethod -> HighlightingMethod -- | Functions which give precise syntax highlighting info in JSON format. module Agda.Interaction.Highlighting.JSON -- | Turns syntax highlighting information into a JSON value jsonifyHighlightingInfo :: HighlightingInfo -> RemoveTokenBasedHighlighting -> HighlightingMethod -> ModuleToSource -> IO Value instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Highlighting.Precise.TokenBased instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Highlighting.Precise.TokenBased -- | Ensures that all occurences of an abstract name share the same -- concrete name. -- -- Apply this transformation if your backend uses concrete names for -- identification purposes! -- -- The identity of an abstract name is only the nameId, the concrete name -- is only a naming suggestion. If renaming imports are used, the -- concrete name may change. This transformation makes sure that all -- occurences of an abstract name share the same concrete name. -- -- This transfomation should be run as the last transformation. module Agda.Compiler.Treeless.NormalizeNames normalizeNames :: TTerm -> TCM TTerm -- | Compute eta long normal forms. module Agda.TypeChecking.EtaExpand -- | Eta-expand a term if its type is a function type or an eta-record -- type. etaExpandOnce :: PureTCM m => Type -> Term -> m Term -- | Eta-expand functions and expressions of eta-record type wherever -- possible. deepEtaExpand :: Term -> Type -> TCM Term etaExpandAction :: PureTCM m => Action m module Agda.Interaction.MakeCase type CaseContext = Maybe ExtLamInfo -- | Parse variables (visible or hidden), returning their de Bruijn -- indices. Used in makeCase. parseVariables :: QName -> Context -> [AsBinding] -> InteractionId -> Range -> [String] -> TCM [(Int, NameInScope)] -- | Lookup the clause for an interaction point in the signature. Returns -- the CaseContext, the previous clauses, the clause itself, and a list -- of the remaining ones. type ClauseZipper = ([Clause], Clause, [Clause]) getClauseZipperForIP :: QName -> Int -> TCM (CaseContext, ClauseZipper) recheckAbstractClause :: Type -> Maybe Substitution -> SpineClause -> TCM (Clause, Context, [AsBinding]) -- | Entry point for case splitting tactic. makeCase :: InteractionId -> Range -> String -> TCM (QName, CaseContext, [Clause]) -- | Make the given pattern variables visible by marking their origin as -- CaseSplit and pattern origin as PatOSplit in the -- SplitClause. makePatternVarsVisible :: [Nat] -> SplitClause -> SplitClause -- | If a copattern split yields no clauses, we must be at an empty record -- type. In this case, replace the rhs by record{} makeRHSEmptyRecord :: RHS -> RHS -- | Make clause with no rhs (because of absurd match). makeAbsurdClause :: QName -> ExpandedEllipsis -> SplitClause -> TCM Clause -- | Make a clause with a question mark as rhs. makeAbstractClause :: QName -> RHS -> ExpandedEllipsis -> SplitClause -> TCM Clause anyEllipsisVar :: QName -> SpineClause -> [Name] -> TCM Bool -- | Functions which give precise syntax highlighting info to Emacs. module Agda.Interaction.Highlighting.Emacs -- | Turns syntax highlighting information into a list of S-expressions. lispifyHighlightingInfo :: HighlightingInfo -> RemoveTokenBasedHighlighting -> HighlightingMethod -> ModuleToSource -> IO (Lisp String) -- | Formats the TokenBased tag for the Emacs backend. No quotes are -- added. lispifyTokenBased :: TokenBased -> Lisp String module Agda.Interaction.CommandLine runInteractionLoop :: Maybe AbsolutePath -> TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM () instance Control.Monad.State.Class.MonadState Agda.Interaction.CommandLine.ReplState Agda.Interaction.CommandLine.ReplM instance Control.Monad.Reader.Class.MonadReader Agda.Interaction.CommandLine.ReplEnv Agda.Interaction.CommandLine.ReplM instance Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr Agda.Interaction.CommandLine.ReplM instance Agda.TypeChecking.Monad.Base.MonadTCM Agda.Interaction.CommandLine.ReplM instance Agda.TypeChecking.Monad.Base.MonadTCState Agda.Interaction.CommandLine.ReplM instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.Interaction.CommandLine.ReplM instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.Interaction.CommandLine.ReplM instance Agda.Interaction.Options.HasOptions.HasOptions Agda.Interaction.CommandLine.ReplM instance Control.Monad.IO.Class.MonadIO Agda.Interaction.CommandLine.ReplM instance GHC.Base.Monad Agda.Interaction.CommandLine.ReplM instance GHC.Base.Applicative Agda.Interaction.CommandLine.ReplM instance GHC.Base.Functor Agda.Interaction.CommandLine.ReplM module Agda.Interaction.SearchAbout findMentions :: Rewrite -> Range -> String -> ScopeM [(Name, Type)] module Agda.Auto.Convert data Hint Hint :: Bool -> QName -> Hint [hintIsConstructor] :: Hint -> Bool [hintQName] :: Hint -> QName type O = (Maybe (Int, [Arg QName]), QName) data TMode TMAll :: TMode type MapS a b = (Map a b, [a]) initMapS :: MapS a b popMapS :: (S -> (a, [b])) -> ((a, [b]) -> S -> S) -> TOM (Maybe b) data S S :: MapS QName (TMode, ConstRef O) -> MapS MetaId (Metavar (Exp O) (RefInfo O), Maybe (MExp O, [MExp O]), [MetaId]) -> MapS Int (Maybe (Bool, MExp O, MExp O)) -> Maybe MetaId -> MetaId -> S [sConsts] :: S -> MapS QName (TMode, ConstRef O) [sMetas] :: S -> MapS MetaId (Metavar (Exp O) (RefInfo O), Maybe (MExp O, [MExp O]), [MetaId]) [sEqs] :: S -> MapS Int (Maybe (Bool, MExp O, MExp O)) [sCurMeta] :: S -> Maybe MetaId [sMainMeta] :: S -> MetaId type TOM = StateT S TCM type MOT = ExceptT String IO tomy :: MetaId -> [Hint] -> [Type] -> TCM ([ConstRef O], [MExp O], Map MetaId (Metavar (Exp O) (RefInfo O), MExp O, [MExp O], [MetaId]), [(Bool, MExp O, MExp O)], Map QName (TMode, ConstRef O)) getConst :: Bool -> QName -> TMode -> TOM (ConstRef O) getdfv :: MetaId -> QName -> TCM Nat -- | A variant of lookupLocalMeta that, if applied to a remote -- meta-variable, raises a special error message noting that remote -- meta-variables are not handled by the auto command. lookupLocalMetaAuto :: MetaId -> TCM MetaVariable getMeta :: MetaId -> TOM (Metavar (Exp O) (RefInfo O)) getEqs :: TCM [(Bool, Term, Term)] literalsNotImplemented :: TCM a hitsNotImplemented :: TCM a class Conversion m a b convert :: Conversion m a b => a -> m b tomyIneq :: Comparison -> Bool fmType :: MetaId -> Type -> Bool fmExp :: MetaId -> Term -> Bool fmExps :: MetaId -> Args -> Bool fmLevel :: MetaId -> PlusLevel -> Bool icnvh :: Hiding -> ArgInfo frommyExps :: Nat -> MArgList O -> Term -> ExceptT String IO Term abslamvarname :: String modifyAbstractExpr :: Expr -> Expr modifyAbstractClause :: Clause -> Clause constructPats :: Map QName (TMode, ConstRef O) -> MetaId -> Clause -> TCM ([(Hiding, MId)], [CSPat O]) frommyClause :: (CSCtx O, [CSPat O], Maybe (MExp O)) -> ExceptT String IO Clause contains_constructor :: [CSPat O] -> Bool freeIn :: Nat -> MExp o -> Bool negtype :: ConstRef o -> MExp o -> MExp o findClauseDeep :: InteractionId -> TCM (Maybe (QName, Clause, Bool)) matchType :: Int -> Int -> Type -> Type -> Maybe (Nat, Nat) instance GHC.Classes.Eq Agda.Auto.Convert.TMode instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM [Agda.Syntax.Internal.Clause] [([Agda.Auto.Syntax.Pat Agda.Auto.Convert.O], Agda.Auto.Syntax.MExp Agda.Auto.Convert.O)] instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM Agda.Syntax.Internal.Clause (GHC.Maybe.Maybe ([Agda.Auto.Syntax.Pat Agda.Auto.Convert.O], Agda.Auto.Syntax.MExp Agda.Auto.Convert.O)) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM (Agda.Syntax.Common.Arg Agda.Syntax.Internal.Pattern) (Agda.Auto.Syntax.Pat Agda.Auto.Convert.O) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM Agda.Syntax.Internal.Type (Agda.Auto.Syntax.MExp Agda.Auto.Convert.O) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM Agda.Syntax.Internal.Term (Agda.Auto.Syntax.MExp Agda.Auto.Convert.O) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM a b => Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Hiding, b) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.TOM Agda.Syntax.Internal.Args (Agda.Auto.NarrowingSearch.MM (Agda.Auto.Syntax.ArgList Agda.Auto.Convert.O) (Agda.Auto.Syntax.RefInfo Agda.Auto.Convert.O)) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.MOT a b => Agda.Auto.Convert.Conversion Agda.Auto.Convert.MOT (Agda.Auto.NarrowingSearch.MM a (Agda.Auto.Syntax.RefInfo Agda.Auto.Convert.O)) b instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.MOT a b => Agda.Auto.Convert.Conversion Agda.Auto.Convert.MOT (Agda.Auto.Syntax.Abs a) (Agda.Syntax.Internal.Abs b) instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.MOT (Agda.Auto.Syntax.Exp Agda.Auto.Convert.O) Agda.Syntax.Internal.Type instance Agda.Auto.Convert.Conversion Agda.Auto.Convert.MOT (Agda.Auto.Syntax.Exp Agda.Auto.Convert.O) Agda.Syntax.Internal.Term module Agda.Auto.Auto -- | Entry point for Auto tactic (Agsy). -- -- If the autoMessage part of the result is set to Just -- msg, the message msg produced by Agsy should be -- displayed to the user. auto :: MonadTCM tcm => InteractionId -> Range -> String -> tcm AutoResult data AutoResult AutoResult :: AutoProgress -> Maybe String -> AutoResult [autoProgress] :: AutoResult -> AutoProgress [autoMessage] :: AutoResult -> Maybe String -- | Result type: Progress & potential Message for the user -- -- The of the Auto tactic can be one of the following three: -- --
    --
  1. Solutions [(ii,s)] A list of solutions s for -- interaction ids ii. In particular, Solutions [] -- means Agsy found no solution.
  2. --
  3. FunClauses cs A list of clauses for the interaction id -- ii in which Auto was invoked with case-splitting turned -- on.
  4. --
  5. Refinement s A refinement for the interaction id -- ii in which Auto was invoked.
  6. --
data AutoProgress Solutions :: [(InteractionId, String)] -> AutoProgress FunClauses :: [String] -> AutoProgress Refinement :: String -> AutoProgress module Agda.Interaction.InteractionTop data GiveRefine Give :: GiveRefine Refine :: GiveRefine Intro :: GiveRefine ElaborateGive :: Rewrite -> GiveRefine -- | Restore both TCState and CommandState. localStateCommandM :: CommandM a -> CommandM a -- | Restore TCState, do not touch CommandState. liftLocalState :: TCM a -> CommandM a -- | Build an opposite action to lift for state monads. revLift :: MonadState st m => (forall c. m c -> st -> k (c, st)) -> (forall b. k b -> m b) -> (forall x. (m a -> k x) -> k x) -> m a revLiftTC :: MonadTCState m => (forall c. m c -> TCState -> k (c, TCState)) -> (forall b. k b -> m b) -> (forall x. (m a -> k x) -> k x) -> m a -- | Opposite of liftIO for CommandM. -- -- This function should only be applied to computations that are -- guaranteed not to raise any errors (except for IOExceptions). commandMToIO :: (forall x. (CommandM a -> IO x) -> IO x) -> CommandM a -- | Lift a TCM action transformer to a CommandM action transformer. liftCommandMT :: (forall x. TCM x -> TCM x) -> CommandM a -> CommandM a -- | Ditto, but restore state. liftCommandMTLocalState :: (forall x. TCM x -> TCM x) -> CommandM a -> CommandM a -- | Put a response by the callback function given by -- stInteractionOutputCallback. putResponse :: Response -> CommandM () -- | A Lens for theInteractionPoints. modifyTheInteractionPoints :: ([InteractionId] -> [InteractionId]) -> CommandM () -- | A Lens for oldInteractionScopes. modifyOldInteractionScopes :: (OldInteractionScopes -> OldInteractionScopes) -> CommandM () insertOldInteractionScope :: InteractionId -> ScopeInfo -> CommandM () removeOldInteractionScope :: InteractionId -> CommandM () getOldInteractionScope :: InteractionId -> CommandM ScopeInfo -- | Do setup and error handling for a command. handleCommand_ :: CommandM () -> CommandM () handleCommand :: (forall a. CommandM a -> CommandM a) -> CommandM () -> CommandM () -> CommandM () -- | Run an IOTCM value, catch the exceptions, emit output -- -- If an error happens the state of CommandM does not change, but -- stPersistent may change (which contains successfully loaded interfaces -- for example). runInteraction :: IOTCM -> CommandM () -- | If the next command from the command queue is anything but an actual -- command, then the command is returned. -- -- If the command is an IOTCM command, then the following happens: -- The given computation is applied to the command and executed. If an -- abort command is encountered (and acted upon), then the computation is -- interrupted, the persistent state and all options are restored, and -- some commands are sent to the frontend. If the computation was not -- interrupted, then its result is returned. maybeAbort :: (IOTCM -> CommandM a) -> CommandM (Command' (Maybe a)) -- | Creates a command queue, and forks a thread that writes commands to -- the queue. The queue is returned. initialiseCommandQueue :: IO Command -> IO CommandQueue -- | Can the command run even if the relevant file has not been loaded into -- the state? independent :: Interaction -> Bool -- | Should Resp_InteractionPoints be issued after the command has -- run? updateInteractionPointsAfter :: Interaction -> Bool -- | Interpret an interaction interpret :: Interaction -> CommandM () -- | Solved goals already instantiated internally The second argument -- potentially limits it to one specific goal. solveInstantiatedGoals :: Rewrite -> Maybe InteractionId -> CommandM () -- | cmd_load' file argv unsolvedOk cmd loads the module in file -- file, using argv as the command-line options. -- -- If type checking completes without any exceptions having been -- encountered then the command cmd r is executed, where -- r is the result of typeCheckMain. cmd_load' :: FilePath -> [String] -> Bool -> Mode -> (CheckResult -> CommandM a) -> CommandM a -- | Set envCurrentPath to theCurrentFile, if any. withCurrentFile :: CommandM a -> CommandM a atTopLevel :: CommandM a -> CommandM a -- | A "give"-like action (give, refine, etc). -- -- give_gen force ii rng s give_ref mk_newtxt acts on -- interaction point ii occupying range rng, placing -- the new content given by string s, and replacing ii -- by the newly created interaction points in the state if safety checks -- pass (unless force is applied). give_gen :: UseForce -> InteractionId -> Range -> String -> GiveRefine -> CommandM () highlightExpr :: Expr -> TCM () -- | Sorts interaction points based on their ranges. sortInteractionPoints :: (MonadInteractionPoints m, MonadError TCErr m, MonadFail m) => [InteractionId] -> m [InteractionId] -- | Displays the current goal, the given document, and the current -- context. -- -- Should not modify the state. cmd_goal_type_context_and :: GoalTypeAux -> Rewrite -> InteractionId -> Range -> String -> CommandM () -- | Shows all the top-level names in the given module, along with their -- types. showModuleContents :: Rewrite -> Range -> String -> CommandM () -- | Shows all the top-level names in scope which mention all the given -- identifiers in their type. searchAbout :: Rewrite -> Range -> String -> CommandM () -- | Explain why something is in scope. whyInScope :: String -> CommandM () -- | Sets the command line options and updates the status information. setCommandLineOpts :: CommandLineOptions -> CommandM () -- | Computes some status information. -- -- Does not change the state. status :: CommandM Status -- | Displays or updates status information. -- -- Does not change the state. displayStatus :: CommandM () -- | display_info does what display_info' False -- does, but additionally displays some status information (see -- status and displayStatus). display_info :: DisplayInfo -> CommandM () -- | Parses and scope checks an expression (using the "inside scope" as the -- scope), performs the given command with the expression as input, and -- returns the result and the time it takes. parseAndDoAtToplevel :: (Expr -> TCM a) -> String -> CommandM (Maybe CPUTime, a) maybeTimed :: CommandM a -> CommandM (Maybe CPUTime, a) -- | Tell to highlight the code using the given highlighting info (unless -- it is Nothing). tellToUpdateHighlighting :: Maybe (HighlightingInfo, HighlightingMethod, ModuleToSource) -> IO [Response] -- | Tells the Emacs mode to go to the first error position (if any). tellEmacsToJumpToError :: Range -> [Response] instance GHC.Show.Show Agda.Interaction.InteractionTop.GiveRefine instance GHC.Classes.Eq Agda.Interaction.InteractionTop.GiveRefine module Agda.Interaction.AgdaTop -- | repl is a fake ghci interpreter for both the Emacs the JSON -- frontend repl :: InteractionOutputCallback -> String -> TCM () -> TCM () module Agda.Interaction.EmacsTop -- | mimicGHCi is a fake ghci interpreter for the Emacs frontend and -- for interaction tests. -- -- mimicGHCi reads the Emacs frontend commands from stdin, -- interprets them and print the result into stdout. mimicGHCi :: TCM () -> TCM () namedMetaOf :: OutputConstraint Expr a -> a -- | Print open metas nicely. showGoals :: Goals -> TCM String -- | Serializing Info_Error showInfoError :: Info_Error -> TCM String explainWhyInScope :: forall m. MonadPretty m => WhyInScopeData -> m Doc -- | Pretty-prints the type of the meta-variable. prettyTypeOfMeta :: Rewrite -> InteractionId -> TCM Doc module Agda.Interaction.JSONTop -- | jsonREPL is a interpreter like mimicGHCi, but outputs -- JSON-encoded strings. -- -- jsonREPL reads Haskell values (that starts from IOTCM -- ...) from stdin, interprets them, and outputs JSON-encoded strings. -- into stdout. jsonREPL :: TCM () -> TCM () instance Agda.Interaction.JSON.EncodeTCM Agda.Syntax.Concrete.Name.NameInScope instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Concrete.Name.NameInScope instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.Status instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.Status instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Base.CommandState instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Base.CommandState instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Base.CurrentFile instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Base.CurrentFile instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.ResponseContextEntry instance Agda.Interaction.JSON.EncodeTCM (Agda.Syntax.Position.Position' ()) instance Data.Aeson.Types.ToJSON.ToJSON (Agda.Syntax.Position.Position' ()) instance Agda.Interaction.JSON.EncodeTCM Agda.Syntax.Position.Range instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Position.Range instance Agda.Interaction.JSON.EncodeTCM Agda.Syntax.Common.ProblemId instance Agda.Interaction.JSON.EncodeTCM Agda.Syntax.Common.MetaId instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Common.ProblemId instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Common.ModuleNameHash instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Common.MetaId instance Agda.Interaction.JSON.EncodeTCM Agda.Syntax.Common.InteractionId instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Common.InteractionId instance Agda.Interaction.JSON.EncodeTCM Agda.TypeChecking.Monad.Base.NamedMeta instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.GiveResult instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.GiveResult instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.MakeCaseVariant instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.MakeCaseVariant instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Base.Rewrite instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Base.Rewrite instance Agda.Interaction.JSON.EncodeTCM Agda.Utils.Time.CPUTime instance Data.Aeson.Types.ToJSON.ToJSON Agda.Utils.Time.CPUTime instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Base.ComputeMode instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Base.ComputeMode instance Agda.Interaction.JSON.EncodeTCM (Agda.Interaction.Base.OutputForm Agda.Syntax.Concrete.Expr Agda.Syntax.Concrete.Expr) instance Agda.Interaction.JSON.EncodeTCM Agda.Syntax.Internal.Blockers.Blocker instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.DisplayInfo instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.GoalTypeAux instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.Info_Error instance Agda.Interaction.JSON.EncodeTCM Agda.TypeChecking.Monad.Base.TCErr instance Agda.Interaction.JSON.EncodeTCM Agda.TypeChecking.Monad.Base.TCWarning instance Agda.Interaction.JSON.EncodeTCM Agda.Interaction.Response.Response -- | Agda main module. module Agda.Main -- | The main function runAgda :: [Backend] -> IO () -- | The main function without importing built-in backends runAgda' :: [Backend] -> IO () -- | Main execution mode data MainMode MainModeRun :: Interactor () -> MainMode MainModePrintHelp :: Help -> MainMode MainModePrintVersion :: MainMode MainModePrintAgdaDir :: MainMode -- | Determine the main execution mode to run, based on the configured -- backends and command line options. | This is pure. getMainMode :: MonadError String m => [Backend] -> Maybe AbsolutePath -> CommandLineOptions -> m MainMode type Interactor a = TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM a data FrontendType FrontEndEmacs :: FrontendType FrontEndJson :: FrontendType FrontEndRepl :: FrontendType emacsModeInteractor :: Interactor () jsonModeInteractor :: Interactor () replInteractor :: Maybe AbsolutePath -> Interactor () defaultInteractor :: AbsolutePath -> Interactor () getInteractor :: MonadError String m => [Backend] -> Maybe AbsolutePath -> CommandLineOptions -> m (Maybe (Interactor ())) -- | Run Agda with parsed command line options runAgdaWithOptions :: Interactor a -> String -> CommandLineOptions -> TCM a -- | Print usage information. printUsage :: [Backend] -> Help -> IO () backendUsage :: Backend -> String -- | Print version information. printVersion :: [Backend] -> IO () printAgdaDir :: IO () -- | What to do for bad options. optionError :: String -> IO () -- | Run a TCM action in IO; catch and pretty print errors. runTCMPrettyErrors :: TCM () -> IO () -- | If the error is an IO error, and the error message suggests that the -- problem is related to locales or code pages, print out some extra -- information. helpForLocaleError :: TCErr -> IO ()