-- 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, Epigram
--   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.0.1

-- | Basic data types for library management.
module Agda.Interaction.Library.Base

-- | A symbolic library name.
type LibName = String

-- | The special name "." is used to indicated that the current
--   directory should count as a project root.
libNameForCurrentDir :: LibName

-- | Content of a .agda-lib file.
data AgdaLibFile
AgdaLib :: LibName -> FilePath -> [FilePath] -> [LibName] -> 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]
emptyLibFile :: AgdaLibFile
instance GHC.Show.Show Agda.Interaction.Library.Base.AgdaLibFile

-- | Some IORefs to access option values in pure code
module Agda.Interaction.Options.IORefs

-- | In Pretty and String we want to know whether we are
--   allowed to insert unicode characters or not.
data UnicodeOrAscii
UnicodeOk :: UnicodeOrAscii
AsciiOnly :: UnicodeOrAscii
unicodeOrAscii :: IORef 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
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
builtinPathToEquiv :: String
builtinGlue :: String
builtin_glue :: String
builtin_unglue :: String
builtinFaceForall :: String
builtinId :: 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
builtinSetOmega :: String
builtinFromNat :: String
builtinFromNeg :: String
builtinFromString :: String
builtinQName :: String
builtinAgdaSort :: String
builtinAgdaSortSet :: String
builtinAgdaSortLit :: String
builtinAgdaSortUnsupported :: String
builtinHiding :: String
builtinHidden :: String
builtinInstance :: String
builtinVisible :: String
builtinRelevance :: String
builtinRelevant :: String
builtinIrrelevant :: String
builtinArg :: String
builtinAssoc :: String
builtinAssocLeft :: String
builtinAssocRight :: String
builtinAssocNon :: String
builtinPrecedence :: String
builtinPrecRelated :: String
builtinPrecUnrelated :: String
builtinFixity :: String
builtinFixityFixity :: String
builtinArgInfo :: String
builtinArgArgInfo :: String
builtinArgArg :: String
builtinAbs :: String
builtinAbsAbs :: String
builtinAgdaTerm :: String
builtinAgdaTermVar :: String
builtinAgdaTermLam :: String
builtinAgdaTermExtLam :: String
builtinAgdaTermDef :: String
builtinAgdaTermCon :: String
builtinAgdaTermPi :: String
builtinAgdaTermSort :: String
builtinAgdaTermLit :: String
builtinAgdaTermUnsupported :: String
builtinAgdaTermMeta :: String
builtinAgdaErrorPart :: String
builtinAgdaErrorPartString :: String
builtinAgdaErrorPartTerm :: String
builtinAgdaErrorPartName :: String
builtinAgdaLiteral :: String
builtinAgdaLitNat :: String
builtinAgdaLitWord64 :: String
builtinAgdaLitFloat :: String
builtinAgdaLitChar :: String
builtinAgdaLitString :: String
builtinAgdaLitQName :: String
builtinAgdaLitMeta :: String
builtinAgdaClause :: String
builtinAgdaClauseClause :: String
builtinAgdaClauseAbsurd :: String
builtinAgdaPattern :: String
builtinAgdaPatVar :: String
builtinAgdaPatCon :: String
builtinAgdaPatDot :: String
builtinAgdaPatLit :: String
builtinAgdaPatProj :: String
builtinAgdaPatAbsurd :: String
builtinAgdaDefinitionFunDef :: String
builtinAgdaDefinitionDataDef :: String
builtinAgdaDefinitionRecordDef :: String
builtinAgdaDefinitionDataConstructor :: String
builtinAgdaDefinitionPostulate :: String
builtinAgdaDefinitionPrimitive :: String
builtinAgdaDefinition :: String
builtinAgdaMeta :: String
builtinAgdaTCM :: String
builtinAgdaTCMReturn :: String
builtinAgdaTCMBind :: String
builtinAgdaTCMUnify :: String
builtinAgdaTCMTypeError :: String
builtinAgdaTCMInferType :: String
builtinAgdaTCMCheckType :: String
builtinAgdaTCMNormalise :: String
builtinAgdaTCMReduce :: String
builtinAgdaTCMCatchError :: String
builtinAgdaTCMGetContext :: String
builtinAgdaTCMExtendContext :: String
builtinAgdaTCMInContext :: String
builtinAgdaTCMFreshName :: String
builtinAgdaTCMDeclareDef :: String
builtinAgdaTCMDeclarePostulate :: String
builtinAgdaTCMDefineFun :: String
builtinAgdaTCMGetType :: String
builtinAgdaTCMGetDefinition :: String
builtinAgdaTCMQuoteTerm :: String
builtinAgdaTCMUnquoteTerm :: String
builtinAgdaTCMBlockOnMeta :: String
builtinAgdaTCMCommit :: String
builtinAgdaTCMIsMacro :: String
builtinAgdaTCMWithNormalisation :: String
builtinAgdaTCMDebugPrint :: String
builtinAgdaTCMNoConstraints :: String
builtinAgdaTCMRunSpeculative :: String

-- | Builtins that come without a definition in Agda syntax. These are
--   giving names to Agda internal concepts which cannot be assigned an
--   Agda type.
--   
--   An example would be a user-defined name for Set.
--   
--   {--}
--   
--   The type of Type would be Type : Level → Setω which
--   is not valid Agda.
builtinsNoDef :: [String]
sizeBuiltins :: [String]

-- | 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
instance GHC.Classes.Ord Agda.Termination.CutOff.CutOff
instance GHC.Classes.Eq Agda.Termination.CutOff.CutOff
instance GHC.Show.Show 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.Integer.Type.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.
OneHole :: (r -> a) -> 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)

-- | Finite bijections (implemented as a pair of tree maps).
module Agda.Utils.BiMap

-- | Finite bijective map from a to b. There, and back
--   again.
data BiMap a b
BiMap :: Map a b -> Map b a -> BiMap a b
[biMapThere] :: BiMap a b -> Map a b
[biMapBack] :: BiMap a b -> Map b a

-- | Lookup. O(log n).
lookup :: Ord a => a -> BiMap a b -> Maybe b

-- | Inverse lookup. O(log n).
invLookup :: Ord b => b -> BiMap a b -> Maybe a

-- | Empty bimap. O(1).
empty :: BiMap a b

-- | Singleton bimap. O(1).
singleton :: a -> b -> BiMap a b

-- | Insert. Overwrites existing value if present. O(Map.insert).
insert :: (Ord a, Ord b) => a -> b -> BiMap a b -> BiMap a b

-- | Left-biased Union. O(Map.union).
union :: (Ord a, Ord b) => BiMap a b -> BiMap a b -> BiMap a b

-- | Construct from a list of pairs.
--   
--   Does not check for actual bijectivity of constructed finite map. O(n
--   log n)
fromList :: (Ord a, Ord b) => [(a, b)] -> BiMap a b

-- | Turn into list, sorted ascendingly by first value. O(Map.toList)
toList :: BiMap a b -> [(a, b)]
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Eq (Agda.Utils.BiMap.BiMap a b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Agda.Utils.BiMap.BiMap a b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Agda.Utils.BiMap.BiMap a b)

module Agda.Utils.Char

-- | Convert a character in '0'..'9' into the corresponding digit
--   0..9.
decDigit :: Char -> Int

-- | Convert a character in '0'..'9','A'..'F','a'..'f' into the
--   corresponding digit 0..15.
hexDigit :: Char -> Int

-- | Convert a character in '0'..'7' into the corresponding digit
--   0..7.
octDigit :: Char -> Int

-- | Unicode characters are divided into letters, numbers, marks,
--   punctuation, symbols, separators (including spaces) and others
--   (including control characters).
--   
--   These are the tests that Char offers:
data UnicodeTest
IsControl :: UnicodeTest
IsSpace :: UnicodeTest
IsLower :: UnicodeTest
IsUpper :: UnicodeTest
IsAlpha :: UnicodeTest
IsAlphaNum :: UnicodeTest
IsPrint :: UnicodeTest
IsDigit :: UnicodeTest
IsOctDigit :: UnicodeTest
IsHexDigit :: UnicodeTest
IsLetter :: UnicodeTest
IsMark :: UnicodeTest
IsNumber :: UnicodeTest
IsPunctuation :: UnicodeTest
IsSymbol :: UnicodeTest
IsSeparator :: UnicodeTest

-- | Test names paired with their implementation.
unicodeTests :: [(UnicodeTest, Char -> Bool)]

-- | Find out which tests a character satisfies.
testChar :: Char -> [UnicodeTest]
instance GHC.Show.Show Agda.Utils.Char.UnicodeTest
instance GHC.Classes.Ord Agda.Utils.Char.UnicodeTest
instance GHC.Classes.Eq Agda.Utils.Char.UnicodeTest

-- | 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 is a bifunctor.
mapEither :: (a -> c) -> (b -> d) -> Either a b -> Either c d

-- | '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.
traverseEither :: Functor f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d)

-- | Returns True iff the argument is Right x for
--   some x.
--   
--   Note: from base >= 4.7.0.0 already present in
--   Data.Either.
isRight :: Either a b -> Bool

-- | Returns True iff the argument is Left x for
--   some x.
--   
--   Note: from base >= 4.7.0.0 already present in
--   Data.Either.
isLeft :: 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]

-- | Convert Maybe to Either ().
maybeToEither :: Maybe a -> Either () a

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

-- | Wrapper for Control.Monad.Except from the mtl library (>= 2.2.1)
module Agda.Utils.Except

-- | Error class for backward compatibility (from Control.Monad.Trans.Error
--   in transformers 0.3.0.0).
class Error a
noMsg :: Error a => a
strMsg :: Error a => String -> a

-- | A monad transformer that adds exceptions to other monads.
--   
--   ExceptT constructs a monad parameterized over two things:
--   
--   
--   
- e - The exception type.
--   
- m - The inner monad.
--   
--   
--   The return function yields a computation that produces the
--   given value, while >>= sequences two subcomputations,
--   exiting on the first exception.
data ExceptT e (m :: Type -> Type) a

-- | Map the unwrapped computation using the given function.
--   
--   
--   
- 
runExceptT (mapExceptT f m) = f
--   (runExceptT m)

--   
mapExceptT :: () => (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

-- | We cannot define data constructors synonymous, so we define the
--   mkExceptT function to be used instead of the data constructor
--   ExceptT.
mkExceptT :: m (Either e a) -> ExceptT e m a

-- | The strategy of combining computations that can throw exceptions by
--   bypassing bound functions from the point an exception is thrown to the
--   point that it is handled.
--   
--   Is parameterized over the type of error information and the monad type
--   constructor. It is common to use Either String as the
--   monad type constructor for an error monad in which error descriptions
--   take the form of strings. In that case and many other common cases the
--   resulting monad is already defined as an instance of the
--   MonadError class. You can also define your own error type
--   and/or use a monad type constructor other than Either
--   String or Either IOError. In
--   these cases you will have to explicitly define instances of the
--   MonadError class. (If you are using the deprecated
--   Control.Monad.Error or Control.Monad.Trans.Error, you
--   may also have to define an Error instance.)
class Monad m => MonadError e (m :: Type -> Type) | m -> e

-- | Is used within a monadic computation to begin exception processing.
throwError :: MonadError e m => e -> m a

-- | A handler function to handle previous errors and return to normal
--   execution. A common idiom is:
--   
--   
--   do { action1; action2; action3 } `catchError` handler
--   
--   
--   where the action functions can call throwError. Note
--   that handler and the do-block must have the same return type.
catchError :: MonadError e m => m a -> (e -> m a) -> m a

-- | The inverse of ExceptT.
runExceptT :: () => ExceptT e m a -> m (Either e a)
instance Agda.Utils.Except.Error GHC.Base.String

-- | Logically consistent comparison of floating point numbers.
module Agda.Utils.Float
floatEq :: Double -> Double -> Bool
floatLt :: Double -> Double -> Bool

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

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

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

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

-- | Flipped version of <$>.
--   
--   
--   (<&>) = flip fmap
--   
--   
--   
Examples
--   
--   Apply (+1) to a list, a Just and a Right:
--   
--   
--   >>> Just 2 <&> (+1)
--   Just 3
--   
--   
--   
--   >>> [1,2,3] <&> (+1)
--   [2,3,4]
--   
--   
--   
--   >>> Right 3 <&> (+1)
--   Right 4
--   
(<&>) :: Functor f => f a -> (a -> b) -> f 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)

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
topSort :: Ord n => [n] -> [(n, n)] -> Maybe [n]

module Agda.Utils.HashMap

-- | 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
FunBind :: [Match] -> Decl
PatSyn :: Pat -> Pat -> Decl
FakeDecl :: 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
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 :: String -> 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.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
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.ConDecl
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Pat
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Type
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.TyVarBind
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.QOp
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.QName
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Name
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.Literal
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.Strictness
instance GHC.Classes.Eq Agda.Utils.Haskell.Syntax.DataOrNew

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

-- | Binary IO.
module Agda.Utils.IO.Binary

-- | Returns a close function for the file together with the contents.
readBinaryFile' :: FilePath -> IO (ByteString, IO ())

-- | Text IO using the UTF8 character encoding.
module Agda.Utils.IO.UTF8

-- | Reads a UTF8-encoded text file and converts many character sequences
--   which may be interpreted as line or paragraph separators into '\n'.
readTextFile :: FilePath -> IO Text

-- | Writes UTF8-encoded text to the handle, which should be opened for
--   writing and in text mode. The native convention for line endings is
--   used.
--   
--   The handle's text encoding is not necessarily preserved, it is changed
--   to UTF8.
hPutStr :: Handle -> String -> IO ()

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

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

-- | 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 :: String -> Integer -> 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 :: String -> Integer -> Impossible

-- | We reached a program point without all the required primitives or
--   BUILTIN to proceed forward. MissingDefinitions needed forthis
ImpMissingDefinitions :: [String] -> String -> Impossible

-- | Abort by throwing an "impossible" error. You should not use this
--   function directly. Instead use the macro in undefined.h.
throwImpossible :: Impossible -> a

-- | Catch an "impossible" error, if possible.
catchImpossible :: IO a -> (Impossible -> IO a) -> IO a
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 (throwImpossible (Impossible
--   "srcfullAgdaUtilsEmpty.hs" 33)) 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 Data.Data.Data 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

-- | 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.ImpossibleTest
impossibleTest :: a

module Agda.Auto.NarrowingSearch
newtype Prio
Prio :: Int -> Prio
[getPrio] :: Prio -> Int
class Trav a blk | a -> blk
trav :: (Trav a blk, Monad m) => (forall b. Trav b blk => MM b blk -> m ()) -> a -> m ()
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.Classes.Ord Agda.Auto.NarrowingSearch.Cost
instance GHC.Classes.Eq Agda.Auto.NarrowingSearch.Cost
instance GHC.Num.Num Agda.Auto.NarrowingSearch.Cost
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 Agda.Auto.NarrowingSearch.Refinable Agda.Auto.NarrowingSearch.Choice blk
instance Agda.Auto.NarrowingSearch.Trav a blk => Agda.Auto.NarrowingSearch.Trav (Agda.Auto.NarrowingSearch.MM a blk) 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 (&lt; hi - 1) xs`
data IntSet

-- | No integers.
empty :: IntSet

-- | All integers.
full :: IntSet

-- | All integers `&lt; n`
below :: Integer -> IntSet

-- | All integers `&gt;= 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)

-- | Flipped version of <$>.
--   
--   
--   (<&>) = flip fmap
--   
--   
--   
Examples
--   
--   Apply (+1) to a list, a Just and a Right:
--   
--   
--   >>> Just 2 <&> (+1)
--   Just 3
--   
--   
--   
--   >>> [1,2,3] <&> (+1)
--   [2,3,4]
--   
--   
--   
--   >>> Right 3 <&> (+1)
--   Right 4
--   
(<&>) :: Functor f => f a -> (a -> b) -> f b
infixl 1 <&>

module Agda.Utils.IndexedList

-- | Existential wrapper for indexed types.
data Some :: (k -> *) -> *
[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 -> *) -> [x] -> *
[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 -> *
[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)

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

-- | 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 :: Monad 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])

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

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

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

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
errorWarnings :: Set WarningName
defaultWarningMode :: WarningMode

-- | 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 -> Maybe (WarningMode -> WarningMode)

-- | 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
LibUnknownField_ :: WarningName
EmptyAbstract_ :: WarningName
EmptyInstance_ :: WarningName
EmptyMacro_ :: WarningName
EmptyMutual_ :: WarningName
EmptyPostulate_ :: WarningName
EmptyPrivate_ :: WarningName
EmptyGeneralize_ :: WarningName
EmptyPrimitive_ :: WarningName
InvalidCatchallPragma_ :: WarningName
InvalidNoUniverseCheckPragma_ :: WarningName
InvalidTerminationCheckPragma_ :: WarningName
InvalidNoPositivityCheckPragma_ :: WarningName
MissingDefinitions_ :: WarningName
NotAllowedInMutual_ :: WarningName
PolarityPragmasButNotPostulates_ :: WarningName
PragmaNoTerminationCheck_ :: WarningName
PragmaCompiled_ :: WarningName
UnknownFixityInMixfixDecl_ :: WarningName
UnknownNamesInFixityDecl_ :: WarningName
UnknownNamesInPolarityPragmas_ :: WarningName
UselessAbstract_ :: WarningName
UselessInstance_ :: WarningName
UselessPrivate_ :: WarningName
OldBuiltin_ :: WarningName
EmptyRewritePragma_ :: WarningName
IllformedAsClause_ :: WarningName
UselessPublic_ :: WarningName
UnreachableClauses_ :: WarningName
UselessInline_ :: WarningName
WrongInstanceDeclaration_ :: WarningName
InstanceWithExplicitArg_ :: WarningName
InstanceNoOutputTypeName_ :: WarningName
InstanceArgWithExplicitArg_ :: WarningName
GenericWarning_ :: WarningName
DeprecationWarning_ :: WarningName
InversionDepthReached_ :: WarningName
TerminationIssue_ :: WarningName
CoverageIssue_ :: WarningName
CoverageNoExactSplit_ :: WarningName
ModuleDoesntExport_ :: WarningName
NotStrictlyPositive_ :: WarningName
UnsolvedMetaVariables_ :: WarningName
UnsolvedInteractionMetas_ :: WarningName
UnsolvedConstraints_ :: WarningName
GenericNonFatalError_ :: WarningName
SafeFlagPostulate_ :: WarningName
SafeFlagPragma_ :: WarningName
SafeFlagNonTerminating_ :: WarningName
SafeFlagTerminating_ :: WarningName
SafeFlagWithoutKFlagPrimEraseEquality_ :: WarningName
SafeFlagNoPositivityCheck_ :: WarningName
SafeFlagPolarity_ :: WarningName
SafeFlagNoUniverseCheck_ :: WarningName
UserWarning_ :: WarningName
WithoutKFlagPrimEraseEquality_ :: WarningName
CantGeneralizeOverSorts_ :: WarningName
AbsurdPatternRequiresNoRHS_ :: WarningName
InfectiveImport_ :: WarningName
CoInfectiveImport_ :: 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.Show.Show Agda.Interaction.Options.Warnings.WarningMode
instance GHC.Classes.Eq Agda.Interaction.Options.Warnings.WarningMode
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

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.Show.Show Agda.Interaction.Options.Help.Help
instance GHC.Classes.Eq Agda.Interaction.Options.Help.Help
instance GHC.Show.Show Agda.Interaction.Options.Help.HelpTopic
instance GHC.Classes.Eq Agda.Interaction.Options.Help.HelpTopic

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

-- | Nonempty lists.
module Agda.Utils.NonemptyList
data NonemptyList a
(:!) :: a -> [a] -> NonemptyList a
[headNe] :: NonemptyList a -> a
[tailNe] :: NonemptyList a -> [a]
infixr 5 :!

-- | Implementing conversion to list manually, since
--   Foldable.toList might recurse over the tail and, thus,
--   destroy sharing.
toList :: NonemptyList a -> [a]

-- | Converting a list (safe).
fromList :: [a] -> Maybe (NonemptyList a)

-- | Prepending an element.
consNe :: a -> NonemptyList a -> NonemptyList a

-- | Returns the union of the argument lists seen as sets. The order of the
--   elements in the result is not specified. Precondition: arguments
--   contain no duplicates.
unionNe :: Eq a => NonemptyList a -> NonemptyList a -> NonemptyList a

-- | Zip two nonempty lists.
zipWithNe :: (a -> b -> c) -> NonemptyList a -> NonemptyList b -> NonemptyList c

-- | Zip two nonempty lists.
zipNe :: NonemptyList a -> NonemptyList b -> NonemptyList (a, b)

-- | Case on a list, getting a nonempty list in the cons case.
caseListNe :: [a] -> b -> (NonemptyList a -> b) -> b

-- | Case on a list, with list last.
listCaseNe :: b -> (NonemptyList a -> b) -> [a] -> b

-- | Check if an element is present in a list.
elemNe :: Eq a => a -> NonemptyList a -> Bool
instance Data.Data.Data a => Data.Data.Data (Agda.Utils.NonemptyList.NonemptyList a)
instance Data.Traversable.Traversable Agda.Utils.NonemptyList.NonemptyList
instance Data.Foldable.Foldable Agda.Utils.NonemptyList.NonemptyList
instance GHC.Base.Functor Agda.Utils.NonemptyList.NonemptyList
instance GHC.Classes.Ord a => GHC.Classes.Ord (Agda.Utils.NonemptyList.NonemptyList a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.NonemptyList.NonemptyList a)
instance GHC.Base.Semigroup (Agda.Utils.NonemptyList.NonemptyList a)
instance GHC.Base.Applicative Agda.Utils.NonemptyList.NonemptyList
instance GHC.Base.Monad Agda.Utils.NonemptyList.NonemptyList
instance GHC.Show.Show a => GHC.Show.Show (Agda.Utils.NonemptyList.NonemptyList a)

-- | 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 Data.ByteString.Internal.ByteString
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.Base.HashMap k a)
instance Agda.Utils.Null.Null (Data.HashSet.Base.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

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

-- | Given a default value, a function and a Maybe value, yields the
--   default value if the Maybe value is Nothing and applies
--   the function to the value stored in the Just otherwise.
maybe :: () => b -> (a -> b) -> Maybe a -> b

-- | Given a default value and a Maybe, yield the default value if
--   the Maybe argument is Nothing and extract the value out
--   of the Just otherwise.
fromMaybe :: () => a -> Maybe a -> a

-- | Extracts the element out of a Just and throws an error if the
--   argument is Nothing.
fromJust :: () => Maybe a -> a

-- | Yields True iff the argument is Nothing.
isNothing :: () => Maybe a -> Bool

-- | Yields True iff the argument is of the form Just _.
isJust :: () => Maybe a -> Bool

-- | The type of strict optional values.
data Maybe a
Nothing :: Maybe a
Just :: !a -> Maybe a
toStrict :: Maybe a -> Maybe a
toLazy :: Maybe a -> Maybe a

-- | Analogous to listToMaybe in Data.Maybe.
listToMaybe :: [a] -> Maybe a

-- | Analogous to maybeToList in Data.Maybe.
maybeToList :: Maybe a -> [a]

-- | Analogous to catMaybes in Data.Maybe.
catMaybes :: [Maybe a] -> [a]

-- | Analogous to mapMaybe in Data.Maybe.
mapMaybe :: (a -> Maybe b) -> [a] -> [b]

-- | 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 Data.Data.Data a => Data.Data.Data (Data.Strict.Maybe.Maybe a)
instance GHC.Generics.Generic (Data.Strict.Maybe.Maybe a)
instance Agda.Utils.Null.Null (Data.Strict.Maybe.Maybe a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Strict.Maybe.Maybe a)
instance GHC.Base.Semigroup a => GHC.Base.Monoid (Data.Strict.Maybe.Maybe a)
instance Data.Foldable.Foldable Data.Strict.Maybe.Maybe
instance Data.Traversable.Traversable Data.Strict.Maybe.Maybe
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Strict.Maybe.Maybe a)
instance Data.Binary.Class.Binary a => Data.Binary.Class.Binary (Data.Strict.Maybe.Maybe a)

module Agda.Utils.Parser.ReadP
data ReadP t a

-- | Consumes and returns the next character. Fails if there is no input
--   left.
get :: ReadP t t

-- | Look-ahead: returns the part of the input that is left, without
--   consuming it.
look :: ReadP t [t]

-- | Symmetric choice.
(+++) :: ReadP t a -> ReadP t a -> ReadP t a
infixr 5 +++

-- | Local, exclusive, left-biased choice: If left parser locally produces
--   any result at all, then right parser is not used.
(<++) :: ReadP t a -> ReadP t a -> ReadP t a
infixr 5 <++

-- | Transforms a parser into one that does the same, but in addition
--   returns the exact characters read. IMPORTANT NOTE: gather gives
--   a runtime error if its first argument is built using any occurrences
--   of readS_to_P.
gather :: ReadP t a -> ReadP t ([t], a)

-- | Run a parser on a list of tokens. Returns the list of complete
--   matches.
parse :: ReadP t a -> [t] -> [a]
parse' :: ReadP t a -> [t] -> Either a [t]

-- | Always fails.
pfail :: ReadP t a

-- | Consumes and returns the next character, if it satisfies the specified
--   predicate.
satisfy :: (t -> Bool) -> ReadP t t

-- | Parses and returns the specified character.
char :: Eq t => t -> ReadP t t

-- | Parses and returns the specified string.
string :: Eq t => [t] -> ReadP t [t]

-- | Parses the first zero or more characters satisfying the predicate.
munch :: (t -> Bool) -> ReadP t [t]

-- | Parses the first one or more characters satisfying the predicate.
munch1 :: (t -> Bool) -> ReadP t [t]

-- | Skips all whitespace.
skipSpaces :: ReadP Char ()

-- | Combines all parsers in the specified list.
choice :: [ReadP t a] -> ReadP t a

-- | count n p parses n occurrences of p in
--   sequence. A list of results is returned.
count :: Int -> ReadP t a -> ReadP t [a]

-- | between open close p parses open, followed by
--   p and finally close. Only the value of p is
--   returned.
between :: ReadP t open -> ReadP t close -> ReadP t a -> ReadP t a

-- | option x p will either parse p or return x
--   without consuming any input.
option :: a -> ReadP t a -> ReadP t a

-- | optional p optionally parses p and always returns
--   ().
optional :: ReadP t a -> ReadP t ()

-- | Parses zero or more occurrences of the given parser.
many :: ReadP t a -> ReadP t [a]

-- | Parses one or more occurrences of the given parser.
many1 :: ReadP t a -> ReadP t [a]

-- | Like many, but discards the result.
skipMany :: ReadP t a -> ReadP t ()

-- | Like many1, but discards the result.
skipMany1 :: ReadP t a -> ReadP t ()

-- | sepBy p sep parses zero or more occurrences of p,
--   separated by sep. Returns a list of values returned by
--   p.
sepBy :: ReadP t a -> ReadP t sep -> ReadP t [a]

-- | sepBy1 p sep parses one or more occurrences of p,
--   separated by sep. Returns a list of values returned by
--   p.
sepBy1 :: ReadP t a -> ReadP t sep -> ReadP t [a]

-- | endBy p sep parses zero or more occurrences of p,
--   separated and ended by sep.
endBy :: ReadP t a -> ReadP t sep -> ReadP t [a]

-- | endBy p sep parses one or more occurrences of p,
--   separated and ended by sep.
endBy1 :: ReadP t a -> ReadP t sep -> ReadP t [a]

-- | chainr p op x parses zero or more occurrences of p,
--   separated by op. Returns a value produced by a right
--   associative application of all functions returned by op. If
--   there are no occurrences of p, x is returned.
chainr :: ReadP t a -> ReadP t (a -> a -> a) -> a -> ReadP t a

-- | chainl p op x parses zero or more occurrences of p,
--   separated by op. Returns a value produced by a left
--   associative application of all functions returned by op. If
--   there are no occurrences of p, x is returned.
chainl :: ReadP t a -> ReadP t (a -> a -> a) -> a -> ReadP t a

-- | Like chainl, but parses one or more occurrences of p.
chainl1 :: ReadP t a -> ReadP t (a -> a -> a) -> ReadP t a

-- | Like chainr, but parses one or more occurrences of p.
chainr1 :: ReadP t a -> ReadP t (a -> a -> a) -> ReadP t a

-- | manyTill p end parses zero or more occurrences of p,
--   until end succeeds. Returns a list of values returned by
--   p.
manyTill :: ReadP t a -> ReadP t end -> ReadP t [a]
instance GHC.Base.Functor (Agda.Utils.Parser.ReadP.P t)
instance GHC.Base.Functor (Agda.Utils.Parser.ReadP.ReadP t)
instance GHC.Base.Applicative (Agda.Utils.Parser.ReadP.ReadP t)
instance GHC.Base.Monad (Agda.Utils.Parser.ReadP.ReadP t)
instance GHC.Base.Alternative (Agda.Utils.Parser.ReadP.ReadP t)
instance GHC.Base.MonadPlus (Agda.Utils.Parser.ReadP.ReadP t)
instance GHC.Base.Applicative (Agda.Utils.Parser.ReadP.P t)
instance GHC.Base.Monad (Agda.Utils.Parser.ReadP.P t)
instance GHC.Base.Alternative (Agda.Utils.Parser.ReadP.P t)
instance GHC.Base.MonadPlus (Agda.Utils.Parser.ReadP.P t)

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.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.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.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.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.Integer.Type.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, 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

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 Data.Data.Data a => Data.Data.Data (Agda.Utils.Pointer.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)
instance Data.Typeable.Internal.Typeable a => Data.Data.Data (GHC.IORef.IORef a)

-- | 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
pwords :: String -> [Doc]
fwords :: String -> Doc

-- | Comma separated list, without the brackets.
prettyList_ :: Pretty a => [a] -> Doc

-- | Apply parens to Doc if boolean is true.
mparens :: Bool -> 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 . pretty
--   
pshow :: Show a => a -> 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

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

-- | "Paragraph fill" version of sep.
fsep :: [Doc] -> Doc

-- | "Paragraph fill" version of cat.
fcat :: [Doc] -> Doc

-- | Either hcat or vcat.
cat :: [Doc] -> Doc

-- | Either hsep or vcat.
sep :: [Doc] -> Doc

-- | Beside, separated by space, unless one of the arguments is
--   empty. <+> is associative, with identity
--   empty.
(<+>) :: Doc -> Doc -> Doc
infixl 6 <+>

-- | Beside. <> 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
--   
--   
--   
- (x $$ y) <> z = x $$ (y
--   <> z), if y non-empty.
--   
($$) :: Doc -> Doc -> Doc
infixl 5 $$

-- | 
--   punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]
--   
punctuate :: Doc -> [Doc] -> [Doc]

-- | 
--   hang d1 n d2 = sep [d1, nest n d2]
--   
hang :: Doc -> Int -> Doc -> Doc

-- | Nest (or indent) a document by a given number of positions (which may
--   also be negative). nest satisfies the laws:
--   
--   
--   
- 
nest 0 x = x

--   
- 
nest k (nest k' x) = nest (k+k')
--   x

--   
- 
nest k (x <> y) = nest k x
--   <> nest k y

--   
- 
nest k (x $$ y) = nest k x $$
--   nest k y

--   
- 
nest k empty = empty

--   
- x <> nest k y = x <> y,
--   if x non-empty
--   
--   
--   The side condition on the last law is needed because empty is a
--   left identity for <>.
nest :: Int -> Doc -> Doc

-- | List version of $$.
vcat :: [Doc] -> Doc

-- | List version of <+>.
hsep :: [Doc] -> Doc

-- | List version of <>.
hcat :: [Doc] -> Doc
braces :: Doc -> Doc
brackets :: Doc -> Doc
parens :: Doc -> Doc
doubleQuotes :: Doc -> Doc
quotes :: Doc -> Doc
rational :: Rational -> Doc
double :: Double -> Doc
float :: Float -> Doc
integer :: Integer -> Doc
int :: Int -> Doc
rbrace :: Doc
lbrace :: Doc
rbrack :: Doc
lbrack :: Doc
rparen :: Doc
lparen :: Doc
equals :: Doc
space :: Doc
colon :: Doc
comma :: Doc
semi :: Doc

-- | Returns True if the document is empty
isEmpty :: Doc -> Bool

-- | Some text, but without any width. Use for non-printing text such as a
--   HTML or Latex tags
zeroWidthText :: String -> Doc

-- | Some text with any width. (text s = sizedText (length s) s)
sizedText :: Int -> String -> Doc

-- | Same as text. Used to be used for Bytestrings.
ptext :: String -> Doc

-- | A document of height 1 containing a literal string. text
--   satisfies the following laws:
--   
--   
--   
- 
text s <> text t = text
--   (s++t)

--   
- text "" <> x = x, if x
--   non-empty
--   
--   
--   The side condition on the last law is necessary because
--   text "" has height 1, while empty has no
--   height.
text :: String -> Doc

-- | A document of height and width 1, containing a literal character.
char :: Char -> 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

-- | The default style (mode=PageMode, lineLength=100,
--   ribbonsPerLine=1.5).
style :: Style

-- | 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
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.Integer.Type.Integer
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.NonemptyList.NonemptyList a)
instance Data.Data.Data Text.PrettyPrint.HughesPJ.Doc

-- | 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:
--   
--   
--   
- k Type used for memoisation keys.
--   
- r The type of memoised values. (Yes, all memoised
--   values have to have the same type.)
--   
- tok The token type.
--   
- a The result type.
--   
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)

-- | 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
type CTrans r f = Constraint' r f -> Either String [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 Rigids r a
rigids :: Rigids r a => a -> Set r

-- | The flexibe variables contained in a pice of syntax.
class Flexs flex a | a -> flex
flexs :: Flexs flex a => a -> Set flex
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 GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Polarity
instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Polarity
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.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.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.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Flex
instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Flex
instance GHC.Classes.Ord Agda.TypeChecking.SizedTypes.Syntax.Rigid
instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.Syntax.Rigid
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 flex, Agda.TypeChecking.SizedTypes.Syntax.Flexs flex a) => Agda.TypeChecking.SizedTypes.Syntax.Flexs flex [a]
instance Agda.TypeChecking.SizedTypes.Syntax.Flexs flex (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' rigid flex)
instance GHC.Classes.Ord flex => Agda.TypeChecking.SizedTypes.Syntax.Flexs flex (Agda.TypeChecking.SizedTypes.Syntax.Constraint' rigid flex)
instance (GHC.Classes.Ord r, Agda.TypeChecking.SizedTypes.Syntax.Rigids r a) => Agda.TypeChecking.SizedTypes.Syntax.Rigids r [a]
instance Agda.TypeChecking.SizedTypes.Syntax.Rigids r (Agda.TypeChecking.SizedTypes.Syntax.SizeExpr' r f)
instance GHC.Classes.Ord r => Agda.TypeChecking.SizedTypes.Syntax.Rigids r (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 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.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)

-- | Constructing singleton collections.
module Agda.Utils.Singleton
class Singleton el coll | coll -> el
singleton :: Singleton el coll => el -> coll
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 (Agda.Utils.NonemptyList.NonemptyList 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.Base.HashSet a)
instance Data.Hashable.Class.Hashable k => Agda.Utils.Singleton.Singleton (k, a) (Data.HashMap.Base.HashMap k a)

-- | Create clusters of non-overlapping things.
module Agda.Utils.Cluster

-- | Characteristic identifiers.
type C = Int

-- | Given a function f :: a -> NonemptyList C which returns a
--   non-empty list of characteristics C 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 :: (a -> NonemptyList C) -> [a] -> [NonemptyList a]

-- | Partition a list of as paired with a non-empty list of
--   characteristics C into groups such that each element in a
--   group shares at least one characteristic with at least one other
--   element of the group.
cluster' :: [(a, NonemptyList C)] -> [NonemptyList 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

-- | 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.IntMap.Internal.IntMap a)
instance Agda.Utils.Size.Sized Data.IntSet.Internal.IntSet
instance Agda.Utils.Size.Sized (Data.Map.Internal.Map k a)
instance Agda.Utils.Size.Sized (Data.Set.Internal.Set a)
instance Agda.Utils.Size.Sized (Data.HashMap.Base.HashMap k a)
instance Agda.Utils.Size.Sized (Data.HashSet.Base.HashSet a)
instance Agda.Utils.Size.Sized (Data.Sequence.Internal.Seq a)

module Agda.Utils.Suffix

-- | Are we allowed to use unicode supscript characters?
subscriptAllowed :: UnicodeOrAscii

-- | Is the character one of the subscripts '₀'-'₉'?
isSubscriptDigit :: Char -> Bool

-- | Converts '0'-'9' to '₀'-'₉' unless
--   the user doesn't want us to use unicode characters
--   
--   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
NoSuffix :: Suffix

-- | Identifier ends in Int many primes.
Prime :: Int -> Suffix

-- | Identifier ends in number Int (ordinary digits).
Index :: Int -> Suffix

-- | Identifier ends in number Int (subscript digits).
Subscript :: Int -> Suffix

-- | Increase the suffix by one. If no suffix yet, put a subscript
--   1.
nextSuffix :: Suffix -> Suffix

-- | Parse suffix.
suffixView :: String -> (String, Suffix)

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

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

-- | Swap. (Only in Data.Tuple from base-4.3)
swap :: (a, b) -> (b, a)
fst3 :: (a, b, c) -> a
snd3 :: (a, b, c) -> b
thd3 :: (a, b, c) -> c
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)
newtype List2 a
List2 :: (a, a) -> List2 a
[list2] :: List2 a -> (a, a)
instance Data.Traversable.Traversable Agda.Utils.Tuple.List2
instance Data.Foldable.Foldable Agda.Utils.Tuple.List2
instance GHC.Base.Functor Agda.Utils.Tuple.List2
instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Utils.Tuple.List2 a)
instance GHC.Base.Applicative Agda.Utils.Tuple.List2

module Agda.Utils.Map
data EitherOrBoth a b
L :: a -> EitherOrBoth a b
B :: a -> b -> EitherOrBoth a b
R :: b -> EitherOrBoth a b

-- | Not very efficient (goes via a list), but it'll do.
unionWithM :: (Ord k, Monad m) => (a -> a -> m a) -> Map k a -> Map k a -> m (Map k a)
insertWithKeyM :: (Ord k, Monad m) => (k -> a -> a -> m a) -> k -> a -> Map k a -> m (Map k a)

-- | Big conjunction over a map.
allWithKey :: (k -> a -> Bool) -> Map k a -> Bool

-- | Filter a map based on the keys.
filterKeys :: (k -> Bool) -> Map k a -> Map k a

-- | Unzip a map.
unzip :: Map k (a, b) -> (Map k a, Map k b)
unzip3 :: Map k (a, b, c) -> (Map k a, Map k b, Map k c)

-- | 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. Cf. ifNull.
caseList :: [a] -> b -> (a -> [a] -> b) -> b

-- | Case distinction for lists, with list first. Cf. ifNull.
caseListM :: Monad m => m [a] -> m b -> (a -> [a] -> m b) -> m b

-- | Case distinction for lists, with list last.
listCase :: b -> (a -> [a] -> b) -> [a] -> b

-- | Head function (safe).
headMaybe :: [a] -> Maybe a

-- | Head function (safe). Returns a default value on empty lists.
--   
--   
--   headWithDefault 42 []      = 42
--   headWithDefault 42 [1,2,3] = 1
--   
headWithDefault :: a -> [a] -> a

-- | Tail function (safe).
tailMaybe :: [a] -> Maybe [a]

-- | Tail function (safe). Returns a default list on empty lists.
tailWithDefault :: [a] -> [a] -> [a]

-- | Last element (safe).
lastMaybe :: [a] -> Maybe a

-- | Last two elements (safe).
last2 :: [a] -> Maybe (a, a)

-- | Drop from the end of a list. dropEnd n = reverse . drop n .
--   reverse (Forces the whole list even for n==0.)
dropEnd :: forall a. Int -> [a] -> [a]

-- | Opposite of cons (:), safe.
uncons :: [a] -> Maybe (a, [a])

-- | Maybe cons. mcons ma as = maybeToList ma ++ as
mcons :: Maybe a -> [a] -> [a]

-- | init and last in one go, safe.
initLast :: [a] -> Maybe ([a], a)

-- | init, safe.
initMaybe :: [a] -> Maybe [a]

-- | Lookup function (partially safe).
(!!!) :: [a] -> Int -> Maybe a

-- | Lookup function with default value for index out of range. The name is
--   chosen akin to genericIndex.
indexWithDefault :: a -> [a] -> Int -> a

-- | Find an element satisfying a predicate and return it with its index.
--   TODO: more efficient implementation!?
findWithIndex :: (a -> Bool) -> [a] -> Maybe (a, Int)

-- | downFrom n = [n-1,..1,0]
downFrom :: Integral a => a -> [a]

-- | Update the first element of a list, if it exists.
updateHead :: (a -> a) -> [a] -> [a]

-- | Update the last element of a list, if it exists.
updateLast :: (a -> a) -> [a] -> [a]

-- | Update nth element of a list, if it exists. Precondition: the index is
--   >= 0.
updateAt :: Int -> (a -> a) -> [a] -> [a]

-- | A generalized version of partition. (Cf. mapMaybe
--   vs. filter).
mapEither :: (a -> Either b c) -> [a] -> ([b], [c])
deal :: (a -> Either b c) -> a -> ([b], [c]) -> ([b], [c])

-- | Split off the largest suffix whose elements satisfy a predicate.
--   
--   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] -> ([a], [a])

-- | A generalized version of takeWhile. (Cf. mapMaybe
--   vs. filter).
takeWhileJust :: (a -> Maybe b) -> [a] -> [b]

-- | A generalized version of span.
spanJust :: (a -> Maybe b) -> [a] -> ([b], [a])

-- | Partition a list into Nothings and Justs.
--   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.
filterAndRest :: (a -> Bool) -> [a] -> ([a], [a])

-- | Like mapMaybe, but additionally return the last partition of
--   the list where the function always returns Nothing.
mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b], [a])

-- | Drops from both lists simultaneously until one list is empty.
dropCommon :: [a] -> [b] -> ([a], [b])

-- | Sublist relation.
isSublistOf :: Eq a => [a] -> [a] -> Bool
type Prefix a = [a]
type Suffix a = [a]

-- | Check if a list has a given prefix. If so, return the list minus the
--   prefix.
stripPrefixBy :: (a -> a -> Bool) -> Prefix a -> [a] -> Maybe (Suffix a)

-- | stripSuffix suf xs = Just pre iff xs = pre ++ suf.
stripSuffix :: Eq a => Suffix a -> [a] -> Maybe (Prefix a)
type ReversedSuffix a = [a]

-- | stripReversedSuffix rsuf xs = Just pre iff xs = pre ++
--   reverse suf.
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

-- | Split a list into sublists. Generalisation of the prelude function
--   words.
--   
--   
--   words xs == wordsBy isSpace xs
--   
wordsBy :: (a -> Bool) -> [a] -> [[a]]

-- | Chop up a list in chunks of a given length.
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. > intercalate [x] (chopWhen (== x) xs) == xs
chopWhen :: (a -> Bool) -> [a] -> [[a]]

-- | All ways of removing one element from a list.
holes :: [a] -> [(a, [a])]

-- | Check whether a list is sorted.
--   
--   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.
distinct :: Eq a => [a] -> Bool

-- | An optimised version of distinct.
--   
--   Precondition: The list's length must fit in an Int.
fastDistinct :: Ord a => [a] -> Bool

-- | Checks if all the elements in the list are equal. Assumes that the
--   Eq instance stands for an equivalence relation.
allEqual :: Eq a => [a] -> Bool

-- | Returns an (arbitrary) representative for each list element that
--   occurs more than once.
duplicates :: Ord a => [a] -> [a]

-- | A variant of groupBy which applies the predicate to consecutive
--   pairs.
groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]

-- | groupOn f = groupBy ((==) `on` f) .
--   sortBy (compare `on` f).
groupOn :: Ord b => (a -> b) -> [a] -> [[a]]

-- | splitExactlyAt n xs = Just (ys, zs) iff xs = ys ++
--   zs and genericLength ys = n.
splitExactlyAt :: Integral n => n -> [a] -> Maybe ([a], [a])

-- | A generalised variant of elemIndex.
genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i

-- | Requires both lists to have the same length.
--   
--   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).
--   
--   
--   zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs
--   
zipWithKeepRest :: (a -> b -> b) -> [a] -> [b] -> [b]

-- | Efficient variant of nubBy for finite lists.
--   
--   Specification:
--   
--   
--   nubOn f xs == 'nubBy' ((==) `'on'` f) xs.
--   
nubOn :: Ord b => (a -> b) -> [a] -> [a]

-- | Efficient variant of nubBy for finite lists.
--   
--   Specification: For each list xs there is a list ys
--   which is a permutation of xs such that
--   
--   
--   uniqOn f xs == 'nubBy' ((==) `'on'` f) ys.
--   
--   
--   Furthermore
--   
--   
--   List.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs.
--   
uniqOn :: Ord b => (a -> b) -> [a] -> [a]

-- | Compute the common suffix of two lists.
commonSuffix :: Eq a => [a] -> [a] -> [a]

-- | Compute the common prefix of two lists.
commonPrefix :: Eq a => [a] -> [a] -> [a]
editDistanceSpec :: Eq a => [a] -> [a] -> Int
editDistance :: Eq a => [a] -> [a] -> Int

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

-- | Shows a non-negative integer using the characters ₀-₉ instead of 0-9
--   unless the user explicitly asked us to not use any unicode characters.
showIndex :: (Show i, Integral i) => i -> 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
newtype Str
Str :: String -> Str
[unStr] :: Str -> 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 GHC.Classes.Eq Agda.Utils.String.Str
instance GHC.Show.Show Agda.Utils.String.Str

-- | 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 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 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
type LineNumber = Int
runP :: P a -> (Either String a, [LibWarning'])

-- | Library Warnings.
data LibWarning'
UnknownField :: String -> LibWarning'
instance GHC.Show.Show Agda.Interaction.Library.Parse.GenericLine
instance Data.Data.Data Agda.Interaction.Library.Parse.LibWarning'
instance GHC.Show.Show Agda.Interaction.Library.Parse.LibWarning'

-- | 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)
instance GHC.Show.Show (Agda.Interaction.EmacsCommand.Lisp GHC.Base.String)

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 :: (Functor f, 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 :: (Functor f, 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 mapM_ :: Monad 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, Monad m, Monoid b) => (a -> m b) -> t a -> m b

-- | Generalized version of forM_ :: Monad m => [a] -> (a -> m
--   ()) -> m ()
forM' :: (Foldable t, Monad 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)

-- | A monadic version of mapMaybe :: (a -> Maybe b) ->
--   [a] -> [b].
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]

-- | The for version of mapMaybeM.
forMaybeM :: Monad 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

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

-- | 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
readM :: (Error e, MonadError e m, Read a) => String -> 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.
(<*>) :: 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 <$
instance Control.Monad.Fail.MonadFail Data.Functor.Identity.Identity

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

-- | Tries to establish if the two file paths point to the same file (or
--   directory).
(===) :: AbsolutePath -> AbsolutePath -> Bool
infix 4 ===

-- | 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
rootPath :: FilePath
instance Data.Hashable.Class.Hashable Agda.Utils.FileName.AbsolutePath
instance Data.Data.Data 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 a, Functor m, MonadIO m) => MonadBench a m | m -> a
getBenchmark :: MonadBench a m => m (Benchmark a)
getsBenchmark :: MonadBench a m => (Benchmark a -> c) -> m c
putBenchmark :: MonadBench a m => Benchmark a -> m ()
modifyBenchmark :: MonadBench a m => (Benchmark a -> Benchmark a) -> m ()

-- | We need to be able to terminate benchmarking in case of an exception.
finally :: MonadBench a m => m b -> m c -> m b

-- | Turn benchmarking on/off.
setBenchmarking :: MonadBench a m => BenchmarkOn a -> m ()

-- | Bill current account with time up to now. Switch to new account.
--   Return old account (if any).
switchBenchmarking :: MonadBench a m => Maybe (Account a) -> m (Maybe (Account a))

-- | Resets the account and the timing information.
reset :: MonadBench a m => m ()

-- | Bill a computation to a specific account. Works even if the
--   computation is aborted by an exception.
billTo :: MonadBench a m => Account a -> m c -> m c

-- | Bill a CPS function to an account. Can't handle exceptions.
billToCPS :: MonadBench a m => Account a -> ((b -> m c) -> m c) -> (b -> m c) -> m c

-- | Bill a pure computation to a specific account.
billPureTo :: MonadBench a m => Account a -> c -> m c
instance Agda.Utils.Benchmark.MonadBench a m => Agda.Utils.Benchmark.MonadBench a (Control.Monad.Trans.Reader.ReaderT r m)
instance Agda.Utils.Benchmark.MonadBench a m => Agda.Utils.Benchmark.MonadBench a (Control.Monad.Trans.State.Lazy.StateT r 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)

-- | 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 AbsolutePath
positionInvariant :: Position' a -> Bool

-- | The first position in a file: position 1, line 1, column 1.
startPos :: Maybe AbsolutePath -> 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 :: Position' a -> String -> 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

-- | 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 t
getRange :: HasRange t => t -> Range

-- | If it is also possible to set the range, this is the class.
--   
--   Instances should satisfy getRange (setRange r x) ==
--   r.
class HasRange t => SetRange t
setRange :: SetRange t => Range -> t -> t

-- | Killing the range of an object sets all range information to
--   noRange.
class KillRange a
killRange :: KillRange 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 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 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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Position.Range' a)
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Position.Interval' 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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Position.Position' 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.Integer.Type.Integer
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange [a]
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Utils.NonemptyList.NonemptyList a)
instance Agda.Syntax.Position.KillRange GHC.Base.String
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Data.Map.Internal.Map k 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 (GHC.Maybe.Maybe a)
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.HasRange Agda.Syntax.Position.Interval
instance Agda.Syntax.Position.HasRange Agda.Syntax.Position.Range
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.NonemptyList.NonemptyList 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 (GHC.Maybe.Maybe a)
instance (Agda.Syntax.Position.HasRange a, Agda.Syntax.Position.HasRange b) => Agda.Syntax.Position.HasRange (Data.Either.Either a b)
instance Agda.Utils.Null.Null (Agda.Syntax.Position.Range' a)
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Range' (Data.Strict.Maybe.Maybe a))
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Range' (GHC.Maybe.Maybe a))
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.Range' (Data.Strict.Maybe.Maybe a))
instance GHC.Show.Show Agda.Syntax.Position.IntervalWithoutFile
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Position.IntervalWithoutFile
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Interval' (Data.Strict.Maybe.Maybe a))
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.Interval' (Data.Strict.Maybe.Maybe a))
instance GHC.Show.Show Agda.Syntax.Position.PositionWithoutFile
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Position.PositionWithoutFile
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 GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Position.Position' (Data.Strict.Maybe.Maybe a))
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Position.Position' (Data.Strict.Maybe.Maybe a))

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
permute :: Permutation -> [a] -> [a]
safePermute :: Permutation -> [a] -> [Maybe 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

-- | 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 Data.Traversable.Traversable Agda.Utils.Permutation.Drop
instance Data.Foldable.Foldable Agda.Utils.Permutation.Drop
instance GHC.Base.Functor Agda.Utils.Permutation.Drop
instance Data.Data.Data a => Data.Data.Data (Agda.Utils.Permutation.Drop a)
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 Data.Data.Data Agda.Utils.Permutation.Permutation
instance GHC.Classes.Eq Agda.Utils.Permutation.Permutation
instance Agda.Utils.Permutation.DoDrop [a]
instance Agda.Utils.Permutation.DoDrop Agda.Utils.Permutation.Permutation
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Utils.Permutation.Drop a)
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 Agda.Syntax.Position.KillRange Agda.Utils.Permutation.Permutation

-- | Some common syntactic entities are defined in this module.
module Agda.Syntax.Common

-- | 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
data HasEta
NoEta :: HasEta
YesEta :: HasEta
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 one of
--   setHiding or mapHiding.
class LensHiding a
getHiding :: LensHiding a => a -> Hiding
setHiding :: LensHiding a => Hiding -> a -> a
mapHiding :: LensHiding 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

-- | 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 -> 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
defaultModality :: Modality

-- | 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
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.
inverseApplyModality :: LensModality a => Modality -> a -> a
lModRelevance :: Lens' Relevance Modality
lModQuantity :: Lens' Quantity Modality
class LensModality a
getModality :: LensModality a => a -> Modality
setModality :: LensModality a => Modality -> a -> a
mapModality :: LensModality 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

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

-- | Linear use {1} (could be updated destructively). Mostly TODO
--   (needs postponable constraints between quantities to compute uses).
Quantity1 :: Quantity

-- | Unrestricted use ℕ.
Quantityω :: Quantity
defaultQuantity :: Quantity

-- | m moreUsableQuantity m' means that an m can
--   be used where ever an m' is required.
moreQuantity :: Quantity -> Quantity -> Bool

-- | A thing of quantity 0 is unusable, all others are usable.
usableQuantity :: LensQuantity a => a -> Bool
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
class LensQuantity a
getQuantity :: LensQuantity a => a -> Quantity
setQuantity :: LensQuantity a => Quantity -> a -> a
mapQuantity :: LensQuantity a => (Quantity -> Quantity) -> a -> a

-- | 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]
defaultRelevance :: Relevance

-- | A lens to access the Relevance attribute in data structures.
--   Minimal implementation: getRelevance and one of
--   setRelevance or mapRelevance.
class LensRelevance a
getRelevance :: LensRelevance a => a -> Relevance
setRelevance :: LensRelevance a => Relevance -> a -> a
mapRelevance :: LensRelevance 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

-- | usableRelevance rel == False iff we cannot use a variable of
--   rel.
usableRelevance :: LensRelevance a => a -> Bool

-- | Relevance composition. Irrelevant is dominant,
--   Relevant is neutral.
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

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

-- | 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 one of
--   setOrigin or mapOrigin.
class LensOrigin a
getOrigin :: LensOrigin a => a -> Origin
setOrigin :: LensOrigin a => Origin -> a -> a
mapOrigin :: LensOrigin 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 one
--   of setFreeVariables or mapFreeVariables.
class LensFreeVariables a
getFreeVariables :: LensFreeVariables a => a -> FreeVariables
setFreeVariables :: LensFreeVariables a => FreeVariables -> a -> a
mapFreeVariables :: LensFreeVariables 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 -> ArgInfo
[argInfoHiding] :: ArgInfo -> Hiding
[argInfoModality] :: ArgInfo -> Modality
[argInfoOrigin] :: ArgInfo -> Origin
[argInfoFreeVariables] :: ArgInfo -> FreeVariables
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
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

-- | 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.
--   
--   
--   
-  cubical  When domFinite = True for the domain of
--   a Pi type, the elements should be compared by tabulating the
--   domain type. Only supported in case the domain type is primIsOne, to
--   obtain the correct equality for partial elements.
--   
data Dom e
Dom :: ArgInfo -> !Bool -> Maybe RString -> e -> Dom e
[domInfo] :: Dom e -> ArgInfo
[domFinite] :: Dom e -> !Bool
[domName] :: Dom e -> Maybe RString
[unDom] :: Dom e -> e
argFromDom :: Dom a -> Arg a
namedArgFromDom :: Dom 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

-- | 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 RString
unnamed :: a -> Named name a
named :: name -> a -> Named name a

-- | Accessor/editor for the nameOf component.
class LensNamed name a | a -> name
lensNamed :: LensNamed name a => Lens' (Maybe name) a
getNameOf :: LensNamed name a => a -> Maybe name
setNameOf :: LensNamed name a => Maybe name -> a -> a
mapNameOf :: LensNamed name a => (Maybe name -> Maybe name) -> a -> a

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

-- | 
--   setNamedArg a b = updateNamedArg (const b) a
--   
setNamedArg :: NamedArg a -> b -> NamedArg b

-- | 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
data DataOrRecord
IsData :: DataOrRecord
IsRecord :: DataOrRecord

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

-- | Visible from outside, but not exported when opening the module Used
--   for qualified constructors.
OnlyQualified :: Access

-- | Abstract or concrete
data IsAbstract
AbstractDef :: IsAbstract
ConcreteDef :: IsAbstract

-- | Is this definition eligible for instance search?
data IsInstance
InstanceDef :: IsInstance
NotInstanceDef :: IsInstance

-- | Is this a macro definition?
data IsMacro
MacroDef :: IsMacro
NotMacroDef :: IsMacro
type Nat = Int
type Arity = Nat

-- | The unique identifier of a name. Second argument is the top-level
--   module identifier.
data NameId
NameId :: {-# UNPACK #-} !Word64 -> {-# UNPACK #-} !Word64 -> NameId

-- | A meta variable identifier is just a natural number.
newtype MetaId
MetaId :: Nat -> MetaId
[metaId] :: MetaId -> Nat
newtype Constr a
Constr :: a -> Constr a

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

-- | 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 -> [ImportedName' n m] -> [Renaming' n m] -> Bool -> ImportDirective' n m
[importDirRange] :: ImportDirective' n m -> Range
[using] :: ImportDirective' n m -> Using' n m
[hiding] :: ImportDirective' n m -> [ImportedName' n m]
[impRenaming] :: ImportDirective' n m -> [Renaming' n m]

-- | Only for open. Exports the opened names from the current
--   module.
[publicOpen] :: ImportDirective' n m -> Bool
data Using' n m
UseEverything :: Using' n m
Using :: [ImportedName' n m] -> Using' n m

-- | Default is directive is private (use everything, but do not
--   export).
defaultImportDir :: ImportDirective' n m
isDefaultImportDir :: ImportDirective' n m -> Bool

-- | 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
setImportedName :: ImportedName' a a -> a -> ImportedName' a a
data Renaming' n m
Renaming :: ImportedName' n m -> ImportedName' n m -> 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

-- | 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).
type PositivityCheck = Bool

-- | Universe check? (Default is yes).
data UniverseCheck
YesUniverseCheck :: UniverseCheck
NoUniverseCheck :: UniverseCheck
instance Data.Data.Data 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.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 Data.Data.Data m => Data.Data.Data (Agda.Syntax.Common.TerminationCheck m)
instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.ImportDirective' n m)
instance (Data.Data.Data n, Data.Data.Data m) => Data.Data.Data (Agda.Syntax.Common.ImportDirective' n m)
instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.Renaming' n m)
instance (Data.Data.Data n, Data.Data.Data m) => Data.Data.Data (Agda.Syntax.Common.Renaming' n m)
instance (GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (Agda.Syntax.Common.Using' n m)
instance (Data.Data.Data n, Data.Data.Data m) => Data.Data.Data (Agda.Syntax.Common.Using' n m)
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 (Data.Data.Data n, Data.Data.Data m) => Data.Data.Data (Agda.Syntax.Common.ImportedName' n m)
instance Data.Data.Data 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 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 Data.Data.Data e => Data.Data.Data (Agda.Syntax.Common.MaybePlaceholder e)
instance Data.Data.Data Agda.Syntax.Common.PositionInName
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 Data.Data.Data Agda.Syntax.Common.MetaId
instance GHC.Real.Integral Agda.Syntax.Common.MetaId
instance GHC.Enum.Enum Agda.Syntax.Common.MetaId
instance GHC.Real.Real Agda.Syntax.Common.MetaId
instance GHC.Num.Num Agda.Syntax.Common.MetaId
instance GHC.Classes.Ord Agda.Syntax.Common.MetaId
instance GHC.Classes.Eq Agda.Syntax.Common.MetaId
instance GHC.Show.Show Agda.Syntax.Common.NameId
instance GHC.Generics.Generic Agda.Syntax.Common.NameId
instance Data.Data.Data Agda.Syntax.Common.NameId
instance GHC.Classes.Ord Agda.Syntax.Common.NameId
instance GHC.Classes.Eq Agda.Syntax.Common.NameId
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.Data.Data Agda.Syntax.Common.IsMacro
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 Data.Data.Data Agda.Syntax.Common.IsInstance
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 Data.Data.Data Agda.Syntax.Common.IsAbstract
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 Data.Data.Data Agda.Syntax.Common.Access
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 Data.Data.Data Agda.Syntax.Common.IsInfix
instance GHC.Show.Show Agda.Syntax.Common.DataOrRecord
instance GHC.Classes.Ord Agda.Syntax.Common.DataOrRecord
instance GHC.Classes.Eq Agda.Syntax.Common.DataOrRecord
instance Data.Data.Data Agda.Syntax.Common.DataOrRecord
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 Data.Data.Data Agda.Syntax.Common.ProjOrigin
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 Data.Data.Data Agda.Syntax.Common.ConOrigin
instance Data.Traversable.Traversable Agda.Syntax.Common.Dom
instance Data.Foldable.Foldable Agda.Syntax.Common.Dom
instance GHC.Base.Functor Agda.Syntax.Common.Dom
instance GHC.Show.Show e => GHC.Show.Show (Agda.Syntax.Common.Dom e)
instance GHC.Classes.Ord e => GHC.Classes.Ord (Agda.Syntax.Common.Dom e)
instance Data.Data.Data e => Data.Data.Data (Agda.Syntax.Common.Dom e)
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Common.Ranged a)
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 (Data.Data.Data name, Data.Data.Data a) => Data.Data.Data (Agda.Syntax.Common.Named name a)
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.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 Data.Data.Data e => Data.Data.Data (Agda.Syntax.Common.Arg e)
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.Data.Data Agda.Syntax.Common.ArgInfo
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 Data.Data.Data Agda.Syntax.Common.FreeVariables
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Common.WithOrigin a)
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.Data.Data Agda.Syntax.Common.Origin
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 Data.Data.Data Agda.Syntax.Common.Modality
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 Data.Data.Data Agda.Syntax.Common.Relevance
instance GHC.Classes.Ord Agda.Syntax.Common.Quantity
instance GHC.Enum.Bounded Agda.Syntax.Common.Quantity
instance GHC.Enum.Enum 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 Data.Data.Data Agda.Syntax.Common.Quantity
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Common.WithHiding a)
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.Data.Data Agda.Syntax.Common.Hiding
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 Data.Data.Data Agda.Syntax.Common.Overlappable
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 Data.Data.Data Agda.Syntax.Common.Induction
instance GHC.Classes.Ord Agda.Syntax.Common.HasEta
instance GHC.Classes.Eq Agda.Syntax.Common.HasEta
instance GHC.Show.Show Agda.Syntax.Common.HasEta
instance Data.Data.Data Agda.Syntax.Common.HasEta
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 Data.Data.Data Agda.Syntax.Common.FileType
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 Data.Data.Data Agda.Syntax.Common.Delayed
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.UniverseCheck
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.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.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.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 Agda.Utils.Pretty.Pretty Agda.Syntax.Common.MetaId
instance GHC.Show.Show Agda.Syntax.Common.MetaId
instance Control.DeepSeq.NFData 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.Syntax.Position.KillRange Agda.Syntax.Common.IsMacro
instance Agda.Syntax.Position.HasRange 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.Position.KillRange 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 Agda.Syntax.Position.KillRange Agda.Syntax.Common.ProjOrigin
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.ConOrigin
instance Agda.Utils.Functor.Decoration Agda.Syntax.Common.Dom
instance Agda.Syntax.Position.HasRange a => Agda.Syntax.Position.HasRange (Agda.Syntax.Common.Dom a)
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Common.Dom a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.Syntax.Common.Dom a)
instance Agda.Syntax.Common.LensArgInfo (Agda.Syntax.Common.Dom e)
instance Agda.Syntax.Common.LensHiding (Agda.Syntax.Common.Dom e)
instance Agda.Syntax.Common.LensModality (Agda.Syntax.Common.Dom e)
instance Agda.Syntax.Common.LensOrigin (Agda.Syntax.Common.Dom e)
instance Agda.Syntax.Common.LensFreeVariables (Agda.Syntax.Common.Dom e)
instance Agda.Syntax.Common.LensRelevance (Agda.Syntax.Common.Dom e)
instance Agda.Syntax.Common.LensQuantity (Agda.Syntax.Common.Dom e)
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 name (Agda.Syntax.Common.Named name a)
instance Agda.Syntax.Common.LensNamed name a => Agda.Syntax.Common.LensNamed name (Agda.Syntax.Common.Arg 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.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 GHC.Classes.Eq a => GHC.Classes.Eq (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.LensArgInfo Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.ArgInfo
instance Control.DeepSeq.NFData Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensHiding Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensModality Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensOrigin Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensFreeVariables Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensQuantity Agda.Syntax.Common.ArgInfo
instance Agda.Syntax.Common.LensFreeVariables Agda.Syntax.Common.FreeVariables
instance GHC.Base.Semigroup Agda.Syntax.Common.FreeVariables
instance GHC.Base.Monoid Agda.Syntax.Common.FreeVariables
instance Control.DeepSeq.NFData Agda.Syntax.Common.FreeVariables
instance Agda.Syntax.Common.LensOrigin Agda.Syntax.Common.Origin
instance Agda.Syntax.Common.LensOrigin (Agda.Syntax.Common.WithOrigin a)
instance Agda.Utils.Functor.Decoration Agda.Syntax.Common.WithOrigin
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.KillRange Agda.Syntax.Common.Origin
instance Control.DeepSeq.NFData Agda.Syntax.Common.Origin
instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Common.Modality
instance Agda.Syntax.Common.LensRelevance Agda.Syntax.Common.Relevance
instance Agda.Syntax.Common.LensModality Agda.Syntax.Common.Modality
instance GHC.Base.Semigroup Agda.Syntax.Common.Modality
instance GHC.Base.Monoid Agda.Syntax.Common.Modality
instance Agda.Utils.PartialOrd.PartialOrd Agda.Syntax.Common.Modality
instance Agda.Utils.POMonoid.POSemigroup Agda.Syntax.Common.Modality
instance Agda.Utils.POMonoid.POMonoid Agda.Syntax.Common.Modality
instance Agda.Utils.POMonoid.LeftClosedPOMonoid Agda.Syntax.Common.Modality
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Modality
instance Control.DeepSeq.NFData Agda.Syntax.Common.Modality
instance Agda.Syntax.Common.LensQuantity Agda.Syntax.Common.Modality
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.Relevance
instance GHC.Base.Monoid Agda.Syntax.Common.Relevance
instance Agda.Utils.POMonoid.POSemigroup Agda.Syntax.Common.Relevance
instance Agda.Utils.POMonoid.POMonoid Agda.Syntax.Common.Relevance
instance Agda.Utils.POMonoid.LeftClosedPOMonoid Agda.Syntax.Common.Relevance
instance Agda.Syntax.Common.LensQuantity Agda.Syntax.Common.Quantity
instance GHC.Base.Semigroup Agda.Syntax.Common.Quantity
instance GHC.Base.Monoid Agda.Syntax.Common.Quantity
instance Agda.Utils.PartialOrd.PartialOrd Agda.Syntax.Common.Quantity
instance Agda.Utils.POMonoid.POSemigroup Agda.Syntax.Common.Quantity
instance Agda.Utils.POMonoid.POMonoid Agda.Syntax.Common.Quantity
instance Agda.Utils.POMonoid.LeftClosedPOMonoid Agda.Syntax.Common.Quantity
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Quantity
instance Control.DeepSeq.NFData Agda.Syntax.Common.Quantity
instance Agda.Syntax.Common.LensHiding Agda.Syntax.Common.Hiding
instance Agda.Syntax.Common.LensHiding (Agda.Syntax.Common.WithHiding a)
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.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.Position.HasRange Agda.Syntax.Common.HasEta
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.HasEta
instance Control.DeepSeq.NFData Agda.Syntax.Common.HasEta
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Common.FileType
instance Agda.Syntax.Position.KillRange Agda.Syntax.Common.Delayed

-- | 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.Show.Show Agda.Syntax.Parser.Literate.Layer
instance GHC.Classes.Eq Agda.Syntax.Parser.Literate.LayerRole
instance GHC.Show.Show Agda.Syntax.Parser.Literate.LayerRole
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 :: Either Integer Integer -> MemoKey
PostLeftsK :: Either Integer Integer -> MemoKey
PreRightsK :: Either Integer Integer -> MemoKey
TopK :: MemoKey
AppK :: MemoKey
NonfixK :: MemoKey

-- | 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
String :: String -> Exp
Char :: Char -> Exp
Integer :: Integer -> Exp
Double :: Double -> Exp
Lambda :: Nat -> Exp -> Exp
Object :: Map MemberId 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
newtype MemberId
MemberId :: String -> MemberId
data Export
Export :: [MemberId] -> Exp -> Export
[expName] :: Export -> [MemberId]
[defn] :: Export -> Exp
data Module
Module :: GlobalId -> [Export] -> Maybe Exp -> Module
[modName] :: Module -> GlobalId
[exports] :: Module -> [Export]
[postscript] :: Module -> Maybe Exp
class Uses a
uses :: Uses a => a -> Set [MemberId]
class Globals a
globals :: Globals a => a -> Set GlobalId
instance GHC.Show.Show Agda.Compiler.JS.Syntax.Module
instance GHC.Show.Show Agda.Compiler.JS.Syntax.Export
instance GHC.Show.Show Agda.Compiler.JS.Syntax.Exp
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.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.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 Agda.Compiler.JS.Syntax.Globals a => Agda.Compiler.JS.Syntax.Globals [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 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 Agda.Compiler.JS.Syntax.Exp
instance Agda.Compiler.JS.Syntax.Uses Agda.Compiler.JS.Syntax.Export

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
br :: Int -> String
unescape :: Char -> String
unescapes :: String -> String
class Pretty a
pretty :: Pretty a => Nat -> Int -> a -> String
class Pretties a
pretties :: Pretties a => Nat -> Int -> a -> [String]
block :: Nat -> Int -> Exp -> String
block' :: Nat -> Int -> Exp -> String
modname :: GlobalId -> String
exports :: Nat -> Int -> Set [MemberId] -> [Export] -> String
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.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 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.Module

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
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.Classes.Eq (Agda.Auto.Syntax.Elr o)
instance GHC.Show.Show Agda.Auto.Syntax.EqReasoningState
instance GHC.Classes.Eq Agda.Auto.Syntax.EqReasoningState
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 blk => Agda.Auto.NarrowingSearch.Trav [a] blk
instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.MId, Agda.Auto.Syntax.CExp o) (Agda.Auto.Syntax.RefInfo o)
instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.TrBr a o) (Agda.Auto.Syntax.RefInfo o)
instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.Exp o) (Agda.Auto.Syntax.RefInfo o)
instance Agda.Auto.NarrowingSearch.Trav (Agda.Auto.Syntax.ArgList o) (Agda.Auto.Syntax.RefInfo 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
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 o t u | t u -> o
replace' :: Replace o t u => Nat -> MExp o -> t -> Reader (Nat, Nat) u
replace :: Replace o t u => Nat -> Nat -> MExp o -> 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 o t | t -> o
unify' :: Unify o t => t -> t -> StateT (Assignments o) Maybe ()
notequal' :: Unify o t => t -> t -> ReaderT (Nat, Nat) (StateT (Assignments o) IO) Bool
unify :: Unify o t => t -> t -> Maybe (Assignments o)
notequal :: Unify o 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 o t => Agda.Auto.CaseSplit.Unify o (Agda.Auto.NarrowingSearch.MM t (Agda.Auto.Syntax.RefInfo o))
instance Agda.Auto.CaseSplit.Unify o t => Agda.Auto.CaseSplit.Unify o (Agda.Auto.Syntax.Abs t)
instance Agda.Auto.CaseSplit.Unify o (Agda.Auto.Syntax.Exp o)
instance Agda.Auto.CaseSplit.Unify o (Agda.Auto.Syntax.ArgList o)
instance Agda.Auto.CaseSplit.Replace o t u => Agda.Auto.CaseSplit.Replace o (Agda.Auto.Syntax.Abs t) (Agda.Auto.Syntax.Abs u)
instance Agda.Auto.CaseSplit.Replace o (Agda.Auto.Syntax.Exp o) (Agda.Auto.Syntax.MExp o)
instance Agda.Auto.CaseSplit.Replace o t u => Agda.Auto.CaseSplit.Replace o (Agda.Auto.NarrowingSearch.MM t (Agda.Auto.Syntax.RefInfo o)) u
instance Agda.Auto.CaseSplit.Replace o (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)

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] -> [LexState] -> ParseFlags -> 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 contexts
[parseLayout] :: ParseState -> [LayoutContext]

-- | the state of the lexer (states can be nested so we need a stack)
[parseLexState] :: ParseState -> [LexState]

-- | parametrization of the parser
[parseFlags] :: ParseState -> ParseFlags

-- | 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 :: !AbsolutePath -> [String] -> ParseError

-- | The file which the error concerns.
[errPath] :: ParseError -> !AbsolutePath
[errValidExts] :: ParseError -> [String]
ReadFileError :: !AbsolutePath -> IOError -> ParseError

-- | The file which the error concerns.
[errPath] :: ParseError -> !AbsolutePath
[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

-- | 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 (if any) of a layout block. See
--   Agda.Syntax.Parser.Layout for more informaton.
data LayoutContext

-- | no layout
NoLayout :: LayoutContext

-- | layout at specified column
Layout :: Int32 -> LayoutContext

-- | 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 AbsolutePath -> 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 context.
topContext :: Parser LayoutContext
popContext :: Parser ()
pushContext :: LayoutContext -> Parser ()

-- | Should only be used at the beginning of a file. When we start parsing
--   we should be in layout mode. Instead of forcing zero indentation we
--   use the indentation of the first token.
pushCurrentContext :: 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 a => GHC.Show.Show (Agda.Syntax.Parser.Monad.ParseResult a)
instance Data.Data.Data Agda.Syntax.Parser.Monad.ParseWarning
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 Agda.Syntax.Parser.Monad.ParseState
instance GHC.Show.Show Agda.Syntax.Parser.Monad.ParseFlags
instance GHC.Show.Show Agda.Syntax.Parser.Monad.LayoutContext
instance GHC.Show.Show 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 GHC.Show.Show Agda.Syntax.Parser.Monad.ParseError
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Parser.Monad.ParseError
instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Monad.ParseError

-- | 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 GenPart
--   before it leaves the Happy code.
data HoleName

-- |  x -> y; 1st argument is the bound name (unused for now).
LambdaHole :: RString -> RString -> HoleName
[_bindHoleName] :: HoleName -> RString
[holeName] :: HoleName -> RString

-- | Simple named hole with hiding.
ExprHole :: RString -> HoleName
[holeName] :: HoleName -> RString

-- | Is the hole a binder?
isLambdaHole :: HoleName -> Bool

-- | Notation as provided by the syntax declaration.
type Notation = [GenPart]

-- | Part of a Notation
data GenPart

-- | Argument is the position of the hole (with binding) where the binding
--   should occur. First range is the rhs range and second is the binder.
BindHole :: Range -> Ranged Int -> GenPart

-- | Argument is where the expression should go.
NormalHole :: Range -> NamedArg (Ranged Int) -> GenPart

-- | An underscore in binding position.
WildHole :: Ranged Int -> GenPart
IdPart :: RString -> GenPart

-- | 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 :: GenPart -> Maybe Int

-- | Is the part a hole? WildHoles don't count since they don't correspond
--   to anything the user writes.
isAHole :: GenPart -> Bool

-- | Is the part a normal hole?
isNormalHole :: GenPart -> Bool

-- | Is the part a binder?
isBindingHole :: GenPart -> 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.
--   
--   Example:  ids = ["for", "x", "∈", "xs", "return", "e"] holes = [
--   LambdaHole "x" "e", ExprHole "xs" ]  creates the notation  [
--   IdPart "for" , BindHole 0 , IdPart "∈" , NormalHole 1 , IdPart
--   "return" , NormalHole 0 ] 
mkNotation :: [NamedArg HoleName] -> [RString] -> Either String Notation
noNotation :: Notation
instance GHC.Show.Show Agda.Syntax.Notation.NotationKind
instance GHC.Classes.Eq Agda.Syntax.Notation.NotationKind
instance GHC.Show.Show Agda.Syntax.Notation.GenPart
instance Data.Data.Data Agda.Syntax.Notation.GenPart
instance GHC.Classes.Eq Agda.Syntax.Notation.GenPart
instance GHC.Classes.Ord Agda.Syntax.Notation.GenPart
instance Agda.Syntax.Position.HasRange Agda.Syntax.Notation.GenPart
instance Agda.Syntax.Position.SetRange Agda.Syntax.Notation.GenPart
instance Agda.Syntax.Position.KillRange Agda.Syntax.Notation.GenPart
instance Control.DeepSeq.NFData Agda.Syntax.Notation.GenPart

-- | 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 -> [NamePart] -> Name
[nameRange] :: Name -> Range
[nameInScope] :: Name -> NameInScope
[nameNameParts] :: Name -> [NamePart]

-- | _.
NoName :: Range -> NameId -> Name
[nameRange] :: Name -> Range
[nameId] :: Name -> NameId

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

-- | Top-level module names. Used in connection with the file system.
--   
--   Invariant: The list must not be empty.
data TopLevelModuleName
TopLevelModuleName :: Range -> [String] -> TopLevelModuleName
[moduleNameRange] :: TopLevelModuleName -> Range
[moduleNameParts] :: TopLevelModuleName -> [String]
nameToRawName :: Name -> RawName
nameParts :: Name -> [NamePart]
nameStringParts :: Name -> [RawName]

-- | Parse a string to parts of a concrete name.
--   
--   Note: stringNameParts "_" == [Id "_"] == nameParts NoName{}
stringNameParts :: String -> [NamePart]

-- | 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?
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
nextStr :: String -> String

-- | Get the next version of the concrete name. For instance, nextName
--   "x" = "x₁". The name must not be a NoName.
nextName :: Name -> Name

-- | Get the first version of the concrete name that does not satisfy the
--   given predicate.
firstNonTakenName :: (Name -> Bool) -> Name -> Name

-- | Get a raw version of the name with all suffixes removed. For instance,
--   nameRoot "x₁₂₃" = "x". The name must not be a NoName.
nameRoot :: Name -> RawName
sameRoot :: Name -> Name -> Bool

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

-- | Is the name qualified?
isQualified :: QName -> Bool

-- | Turns a qualified name into a TopLevelModuleName. The qualified
--   name is assumed to represent a top-level module name.
toTopLevelModuleName :: QName -> TopLevelModuleName

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

-- | 
--   noName_ = noName noRange
--   
noName_ :: Name
noName :: Range -> Name

-- | Check whether a name is the empty name "_".
class IsNoName a
isNoName :: IsNoName a => a -> Bool
instance GHC.Classes.Ord Agda.Syntax.Concrete.Name.QName
instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.QName
instance Data.Data.Data Agda.Syntax.Concrete.Name.QName
instance Data.Data.Data Agda.Syntax.Concrete.Name.Name
instance Data.Data.Data Agda.Syntax.Concrete.Name.NameInScope
instance GHC.Show.Show Agda.Syntax.Concrete.Name.NameInScope
instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.NameInScope
instance Data.Data.Data Agda.Syntax.Concrete.Name.TopLevelModuleName
instance GHC.Show.Show Agda.Syntax.Concrete.Name.TopLevelModuleName
instance GHC.Generics.Generic Agda.Syntax.Concrete.Name.NamePart
instance Data.Data.Data Agda.Syntax.Concrete.Name.NamePart
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.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 GHC.Show.Show 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 GHC.Show.Show 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.NamePart]
instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.TopLevelModuleName
instance GHC.Classes.Ord Agda.Syntax.Concrete.Name.TopLevelModuleName
instance Agda.Utils.Size.Sized Agda.Syntax.Concrete.Name.TopLevelModuleName
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Name.TopLevelModuleName
instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Name.TopLevelModuleName
instance Agda.Syntax.Position.SetRange Agda.Syntax.Concrete.Name.TopLevelModuleName
instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.Name.TopLevelModuleName
instance GHC.Classes.Eq Agda.Syntax.Concrete.Name.NamePart
instance GHC.Classes.Ord Agda.Syntax.Concrete.Name.NamePart
instance GHC.Show.Show Agda.Syntax.Concrete.Name.NamePart
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Name.NamePart
instance Control.DeepSeq.NFData Agda.Syntax.Concrete.Name.NamePart

-- | Attributes: concrete syntax for ArgInfo, esp. modalities.
module Agda.Syntax.Concrete.Attribute

-- | An attribute is a modifier for ArgInfo.
data Attribute
RelevanceAttribute :: Relevance -> Attribute
QuantityAttribute :: Quantity -> Attribute

-- | (Conjunctive constraint.)
type LensAttribute a = (LensRelevance a, LensQuantity a)

-- | Modifiers for Relevance.
relevanceAttributeTable :: [(String, Relevance)]

-- | Modifiers for Quantity.
quantityAttributeTable :: [(String, Quantity)]

-- | Concrete syntax for all attributes.
attributesMap :: Map String Attribute

-- | Parsing a string into an attribute.
stringToAttribute :: String -> 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 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
relevanceAttributes :: [Attribute] -> [Attribute]
quantityAttributes :: [Attribute] -> [Attribute]
instance GHC.Show.Show Agda.Syntax.Concrete.Attribute.Attribute
instance GHC.Classes.Ord Agda.Syntax.Concrete.Attribute.Attribute
instance GHC.Classes.Eq Agda.Syntax.Concrete.Attribute.Attribute

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

-- | 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 :: NonemptyList QName -> AmbiguousQName
[unAmbQ] :: AmbiguousQName -> NonemptyList 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 -> Range -> Fixity' -> Bool -> Name
[nameId] :: Name -> !NameId
[nameConcrete] :: Name -> Name
[nameBindingSite] :: Name -> Range
[nameFixity] :: Name -> Fixity'
[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:
--   
--   
--   
- C: noRange.
--   
- D: the range of A.
--   
- E: the range of B.
--   
--   
--   Precondition: The number of module name name parts has to be at least
--   as large as the length of the list.
withRangesOf :: ModuleName -> [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
noModuleName :: ModuleName
commonParentModule :: ModuleName -> ModuleName -> ModuleName
qnameToList :: QName -> [Name]
qnameFromList :: [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

-- | Computes the TopLevelModuleName corresponding to the given
--   module name, which is assumed to represent a top-level module name.
--   
--   Precondition: The module name must be well-formed.
toTopLevelModuleName :: ModuleName -> TopLevelModuleName
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
isSubModuleOf :: 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 :: Name -> Name
sameRoot :: Name -> Name -> Bool

-- | Check whether a name is the empty name "_".
class IsNoName a
isNoName :: IsNoName a => a -> Bool
instance Data.Data.Data Agda.Syntax.Abstract.Name.AmbiguousQName
instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.AmbiguousQName
instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.AmbiguousQName
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 Data.Data.Data Agda.Syntax.Abstract.Name.QName
instance Data.Data.Data Agda.Syntax.Abstract.Name.ModuleName
instance GHC.Classes.Ord Agda.Syntax.Abstract.Name.ModuleName
instance GHC.Classes.Eq Agda.Syntax.Abstract.Name.ModuleName
instance Data.Data.Data Agda.Syntax.Abstract.Name.Name
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 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.Concrete.Name.LensInScope Agda.Syntax.Abstract.Name.QName
instance GHC.Show.Show 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 GHC.Show.Show Agda.Syntax.Abstract.Name.ModuleName
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.Concrete.Name.LensInScope Agda.Syntax.Abstract.Name.Name
instance GHC.Show.Show 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

module Agda.Syntax.Literal
data Literal
LitNat :: Range -> !Integer -> Literal
LitWord64 :: Range -> !Word64 -> Literal
LitFloat :: Range -> !Double -> Literal
LitString :: Range -> String -> Literal
LitChar :: Range -> !Char -> Literal
LitQName :: Range -> QName -> Literal
LitMeta :: Range -> AbsolutePath -> MetaId -> Literal
showString' :: String -> ShowS
showChar' :: Char -> ShowS
compareFloat :: Double -> Double -> Ordering
instance Data.Data.Data Agda.Syntax.Literal.Literal
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.HasRange Agda.Syntax.Literal.Literal
instance Agda.Syntax.Position.SetRange Agda.Syntax.Literal.Literal
instance Agda.Syntax.Position.KillRange Agda.Syntax.Literal.Literal
instance Control.DeepSeq.NFData Agda.Syntax.Literal.Literal

-- | 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
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 :: 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
data Compiled
Compiled :: TTerm -> [Bool] -> Compiled
[cTreeless] :: Compiled -> TTerm
[cArgUsage] :: Compiled -> [Bool]
pattern TPFn :: TPrim -> TTerm -> TTerm
pattern TPOp :: TPrim -> TTerm -> TTerm -> TTerm
isPrimEq :: TPrim -> Bool
mkTApp :: TTerm -> Args -> TTerm
tAppView :: 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
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 Data.Data.Data Agda.Syntax.Treeless.Compiled
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 Data.Data.Data Agda.Syntax.Treeless.TAlt
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 Data.Data.Data Agda.Syntax.Treeless.TTerm
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 Data.Data.Data Agda.Syntax.Treeless.TError
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 Data.Data.Data Agda.Syntax.Treeless.CaseInfo
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 Data.Data.Data Agda.Syntax.Treeless.CaseType
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 Data.Data.Data Agda.Syntax.Treeless.TPrim
instance GHC.Show.Show Agda.Syntax.Treeless.EvaluationStrategy
instance GHC.Classes.Eq Agda.Syntax.Treeless.EvaluationStrategy
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

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 :: [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
UnknownS :: Sort
data Pattern
ConP :: QName -> [Arg Pattern] -> Pattern
DotP :: Pattern
VarP :: String -> Pattern
LitP :: Literal -> Pattern
AbsurdP :: Pattern
ProjP :: QName -> Pattern
data Clause
Clause :: [Arg Pattern] -> Term -> Clause
AbsurdClause :: [Arg Pattern] -> Clause
data Definition
FunDef :: Type -> [Clause] -> Definition
DataDef :: Definition
RecordDef :: Definition
DataConstructor :: Definition
Axiom :: Definition
Primitive :: Definition
instance GHC.Show.Show Agda.Syntax.Reflected.Definition
instance GHC.Show.Show Agda.Syntax.Reflected.Sort
instance GHC.Show.Show Agda.Syntax.Reflected.Term
instance GHC.Show.Show Agda.Syntax.Reflected.Clause
instance GHC.Show.Show Agda.Syntax.Reflected.Pattern
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Reflected.Abs a)
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Reflected.Elim' a)

module Agda.Syntax.Parser.Tokens
data Token
TokKeyword :: Keyword -> Interval -> Token
TokId :: (Interval, String) -> Token
TokQId :: [(Interval, String)] -> Token
TokLiteral :: Literal -> Token
TokSymbol :: Symbol -> Interval -> Token
TokString :: (Interval, String) -> Token
TokSetN :: (Interval, Integer) -> Token
TokPropN :: (Interval, Integer) -> 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
KwMutual :: Keyword
KwAbstract :: Keyword
KwPrivate :: Keyword
KwInstance :: Keyword
KwOverlap :: Keyword
KwOpen :: Keyword
KwImport :: Keyword
KwModule :: Keyword
KwPrimitive :: Keyword
KwMacro :: Keyword
KwInfix :: Keyword
KwInfixL :: Keyword
KwInfixR :: Keyword
KwWith :: Keyword
KwRewrite :: Keyword
KwSet :: Keyword
KwProp :: 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
KwWARNING_ON_USAGE :: Keyword
KwMEASURE :: Keyword
KwDISPLAY :: Keyword
KwREWRITE :: Keyword
KwQuoteGoal :: Keyword
KwQuoteContext :: 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
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
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.Token
instance GHC.Classes.Eq Agda.Syntax.Parser.Tokens.Token
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.Keyword
instance GHC.Classes.Eq Agda.Syntax.Parser.Tokens.Keyword
instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Tokens.Token

-- | Definitions for fixity, precedence levels, and declared syntax.
module Agda.Syntax.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

-- | Decorating something with Fixity'.
data ThingWithFixity x
ThingWithFixity :: x -> Fixity' -> ThingWithFixity x

-- | 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
--   NormalHoles, Ids become IdParts. If Name
--   has no Holes, it returns noNotation.
syntaxOf :: Name -> Notation
noFixity' :: Fixity'

-- | Merges NewNotations that have the same precedence level and
--   notation, with two exceptions:
--   
--   
--   
- Operators and notations coming from syntax declarations are kept
--   separate.
--   
- If all instances of a given NewNotation have the
--   same precedence level or are "unrelated", then they are merged. They
--   get the given precedence level, if any, and otherwise they become
--   unrelated (but related to each other).
--   
--   
--   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]

-- | Sections, as well as non-sectioned operators.
data NotationSection
NotationSection :: NewNotation -> NotationKind -> Maybe PrecedenceLevel -> 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 PrecedenceLevel

-- | False for non-sectioned operators.
[sectIsSection] :: NotationSection -> Bool

-- | Converts a notation to a (non-)section.
noSection :: NewNotation -> NotationSection

-- | Precedence levels for operators.
data PrecedenceLevel

-- | No fixity declared.
Unrelated :: PrecedenceLevel

-- | Fixity level declared as the Integer.
Related :: !Integer -> PrecedenceLevel

-- | Associativity.
data Associativity
NonAssoc :: Associativity
LeftAssoc :: Associativity
RightAssoc :: Associativity

-- | Fixity of operators.
data Fixity
Fixity :: Range -> !PrecedenceLevel -> !Associativity -> Fixity

-- | Range of the whole fixity declaration.
[fixityRange] :: Fixity -> Range
[fixityLevel] :: Fixity -> !PrecedenceLevel
[fixityAssoc] :: Fixity -> !Associativity
noFixity :: Fixity
defaultFixity :: Fixity

-- | 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
_notaFixity :: Lens' Fixity NewNotation
_fixityAssoc :: Lens' Associativity Fixity
_fixityLevel :: Lens' PrecedenceLevel Fixity
instance GHC.Classes.Eq Agda.Syntax.Fixity.Precedence
instance Data.Data.Data Agda.Syntax.Fixity.Precedence
instance GHC.Show.Show Agda.Syntax.Fixity.Precedence
instance Data.Data.Data 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.Show.Show x => GHC.Show.Show (Agda.Syntax.Fixity.ThingWithFixity x)
instance Data.Data.Data x => Data.Data.Data (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.Show.Show Agda.Syntax.Fixity.Fixity'
instance Data.Data.Data Agda.Syntax.Fixity.Fixity'
instance GHC.Show.Show Agda.Syntax.Fixity.NotationSection
instance GHC.Show.Show Agda.Syntax.Fixity.NewNotation
instance GHC.Show.Show Agda.Syntax.Fixity.Fixity
instance Data.Data.Data Agda.Syntax.Fixity.Fixity
instance Data.Data.Data Agda.Syntax.Fixity.Associativity
instance GHC.Show.Show Agda.Syntax.Fixity.Associativity
instance GHC.Classes.Ord Agda.Syntax.Fixity.Associativity
instance GHC.Classes.Eq Agda.Syntax.Fixity.Associativity
instance Data.Data.Data Agda.Syntax.Fixity.PrecedenceLevel
instance GHC.Show.Show Agda.Syntax.Fixity.PrecedenceLevel
instance GHC.Classes.Ord Agda.Syntax.Fixity.PrecedenceLevel
instance GHC.Classes.Eq Agda.Syntax.Fixity.PrecedenceLevel
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Fixity.Precedence
instance Agda.Syntax.Position.KillRange x => Agda.Syntax.Position.KillRange (Agda.Syntax.Fixity.ThingWithFixity x)
instance GHC.Classes.Eq Agda.Syntax.Fixity.Fixity'
instance Agda.Syntax.Position.KillRange Agda.Syntax.Fixity.Fixity'
instance Control.DeepSeq.NFData Agda.Syntax.Fixity.Fixity'
instance GHC.Classes.Eq Agda.Syntax.Fixity.Fixity
instance GHC.Classes.Ord Agda.Syntax.Fixity.Fixity
instance Agda.Syntax.Position.HasRange Agda.Syntax.Fixity.Fixity
instance Agda.Syntax.Position.KillRange Agda.Syntax.Fixity.Fixity
instance Control.DeepSeq.NFData Agda.Syntax.Fixity.Fixity

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

-- | True iff the range is empty.
empty :: Range -> Bool

-- | 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
rangeToEndPoints :: Range -> Maybe (Int, Int)

-- | 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.Ranges
instance GHC.Classes.Eq Agda.Interaction.Highlighting.Range.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

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

-- | Keep only the edges that satisfy the predicate. O(n + e).
filterEdges :: (Edge n e -> Bool) -> Graph n e -> Graph 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.
sccs' :: Ord n => Graph n e -> [SCC n]

-- | The graph's strongly connected components, in reverse topological
--   order.
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]

-- | 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:
--   
--   
--   
- Zero edge differences are not added to the graph, thus avoiding
--   some zero edges.
--   
- Strongly connected components are used to avoid computing some
--   zero edges.
--   
--   
--   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

-- | 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.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.Classes.Eq n, GHC.Classes.Eq e) => GHC.Classes.Eq (Agda.Utils.Graph.AdjacencyMap.Unidirectional.Graph n e)
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.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 String (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 String [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 String (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 String ([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, Show r, Show f) => Polarities f -> HypGraph r f -> ConGraph r f -> Either String (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, Show r, Show f) => Polarities f -> HypGraph r f -> ConGraphs r f -> Either String (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 String ()

-- | 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, Show r, Show f) => Polarities f -> HypGraph r f -> [Constraint' r f] -> Solution r f -> Either String (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.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.Show.Show Agda.TypeChecking.SizedTypes.WarshallSolver.Label
instance GHC.Show.Show Agda.TypeChecking.SizedTypes.WarshallSolver.Weight
instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.WarshallSolver.Weight
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)

-- | 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.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 Data.Data.Data Agda.TypeChecking.Positivity.Occurrence.Occurrence
instance Data.Data.Data 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 Data.Data.Data 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 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 Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Occurrence.OccursWhere
instance Agda.Utils.Size.Sized Agda.TypeChecking.Positivity.Occurrence.OccursWhere
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Positivity.Occurrence.Where

-- | 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 :: Literal -> Expr

-- | ex: ? or {! ... !}
QuestionMark :: Range -> Maybe Nat -> Expr

-- | ex: _ or _A_5
Underscore :: Range -> Maybe String -> Expr

-- | before parsing operators
RawApp :: Range -> [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 -> [NamedArg (MaybePlaceholder (OpApp Expr))] -> 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 -> [LamBinding] -> Expr -> Expr

-- | ex: \ ()
AbsurdLam :: Range -> Hiding -> Expr

-- | ex: \ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }
ExtendedLam :: Range -> [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 :: Telescope -> Expr -> Expr

-- | ex: Set
Set :: Range -> Expr

-- | ex: Prop
Prop :: Range -> Expr

-- | ex: Set0, Set1, ..
SetN :: Range -> Integer -> Expr

-- | ex: Prop0, Prop1, ..
PropN :: Range -> Integer -> 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 -> [Declaration] -> Maybe Expr -> Expr

-- | ex: (e)
Paren :: Range -> Expr -> Expr

-- | ex: (| e |)
IdiomBrackets :: Range -> Expr -> Expr

-- | ex: do x <- m1; m2
DoBlock :: Range -> [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

-- | only used for printing telescopes
ETel :: Telescope -> Expr

-- | ex: quoteGoal x in e
QuoteGoal :: Range -> Name -> Expr -> Expr

-- | ex: quoteContext
QuoteContext :: Range -> Expr

-- | ex: quote, should be applied to a name
Quote :: Range -> Expr

-- | ex: quoteTerm, should be applied to a term
QuoteTerm :: Range -> Expr

-- | 
--   tactic solve | subgoal1 | .. | subgoalN
--   
Tactic :: Range -> Expr -> [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 -> [LamBinding] -> e -> OpApp e
Ordinary :: e -> OpApp e
fromOrdinary :: e -> OpApp e -> e
appView :: Expr -> AppView

-- | The Expr is not an application.
data AppView
AppView :: Expr -> [NamedArg Expr] -> AppView
isSingleIdentifierP :: Pattern -> Maybe Name
removeSingletonRawAppP :: Pattern -> Pattern

-- | 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}
DomainFree :: NamedArg BoundName -> LamBinding' a

-- | . (xs : e) or {xs : e}
DomainFull :: a -> LamBinding' a

-- | A typed binding.
type TypedBinding = TypedBinding' Expr
data TypedBinding' e

-- | Binding (x1 ... xn : A).
TBind :: Range -> [NamedArg BoundName] -> e -> TypedBinding' e

-- | Let binding (let Ds) or (open M args).
TLet :: Range -> [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' -> BoundName
[boundName] :: BoundName -> Name
[bnameFixity] :: BoundName -> Fixity'
mkBoundName_ :: Name -> BoundName
mkBoundName :: Name -> Fixity' -> BoundName

-- | A telescope is a sequence of typed bindings. Bound variables are in
--   scope in later types.
type Telescope = [TypedBinding]
countTelVars :: Telescope -> Nat

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

-- | 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 -> Name -> Expr -> Declaration

-- | Variables to be generalized, can be hidden and/or irrelevant.
Generalize :: Range -> [TypeSignature] -> Declaration

-- | Record field, can be hidden and/or irrelevant.
Field :: IsInstance -> Name -> Arg Expr -> Declaration
FunClause :: LHS -> RHS -> WhereClause -> Bool -> Declaration

-- | lone data signature in mutual block
DataSig :: Range -> Induction -> Name -> [LamBinding] -> Expr -> Declaration
Data :: Range -> Induction -> Name -> [LamBinding] -> Expr -> [TypeSignatureOrInstanceBlock] -> Declaration
DataDef :: Range -> Induction -> Name -> [LamBinding] -> [TypeSignatureOrInstanceBlock] -> Declaration

-- | lone record signature in mutual block
RecordSig :: Range -> Name -> [LamBinding] -> Expr -> Declaration
RecordDef :: Range -> Name -> Maybe (Ranged Induction) -> Maybe HasEta -> Maybe (Name, IsInstance) -> [LamBinding] -> [Declaration] -> Declaration

-- | The optional name is a name for the record constructor.
Record :: Range -> Name -> Maybe (Ranged Induction) -> Maybe HasEta -> Maybe (Name, IsInstance) -> [LamBinding] -> Expr -> [Declaration] -> Declaration
Infix :: Fixity -> [Name] -> Declaration

-- | notation declaration for a name
Syntax :: Name -> Notation -> Declaration
PatternSyn :: Range -> Name -> [Arg Name] -> Pattern -> Declaration
Mutual :: 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
InstanceB :: 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 :: Range -> [Name] -> Expr -> Declaration
UnquoteDef :: Range -> [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

-- | 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 = Expr
type WithExpr = 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 (many)
[lhsRewriteEqn] :: LHS -> [RewriteEqn]

-- | with e (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 -> [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 :: 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.
EllipsisP :: Range -> 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]
data LamClause
LamClause :: LHS -> RHS -> WhereClause -> Bool -> LamClause
[lamLHS] :: LamClause -> LHS
[lamRHS] :: LamClause -> RHS

-- | always NoWhere (see parser)
[lamWhere] :: LamClause -> WhereClause
[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
type WhereClause = WhereClause' [Declaration]
data WhereClause' decls

-- | No where clauses.
NoWhere :: WhereClause' decls

-- | Ordinary where.
AnyWhere :: decls -> WhereClause' decls

-- | Named where: module M where. The Access flag applies
--   to the Name (not the module contents!) and is propagated from
--   the parent function.
SomeWhere :: 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 -> [Declaration] -> DoStmt
data Pragma
OptionsPragma :: Range -> [String] -> Pragma
BuiltinPragma :: Range -> String -> QName -> Pragma
RewritePragma :: Range -> [QName] -> Pragma

-- | first string is backend name
ForeignPragma :: Range -> String -> String -> Pragma

-- | first string is backend name
CompilePragma :: Range -> String -> QName -> String -> Pragma
StaticPragma :: Range -> QName -> Pragma

-- | INLINE or NOINLINE
InlinePragma :: Range -> Bool -> QName -> Pragma

-- | Throws an internal error in the scope checker.
ImpossiblePragma :: Range -> 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 -> String -> 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 data/record type or mutual block.
NoPositivityCheckPragma :: Range -> Pragma
PolarityPragma :: Range -> Name -> [Occurrence] -> Pragma

-- | Applies to the following data/record type.
NoUniverseCheckPragma :: Range -> Pragma

-- | Modules: Top-level pragmas plus other top-level declarations.
type Module = ([Pragma], [Declaration])

-- | Decorating something with Fixity'.
data ThingWithFixity x
ThingWithFixity :: x -> Fixity' -> ThingWithFixity x
type HoleContent = HoleContent' Expr

-- | Extended content of an interaction hole.
data HoleContent' e

-- | 
--   e
--   
HoleContentExpr :: e -> HoleContent' e

-- | 
--   rewrite e0 | ... | en
--   
HoleContentRewrite :: [e] -> HoleContent' e

-- | 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.
topLevelModuleName :: Module -> TopLevelModuleName

-- | 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 Data.Traversable.Traversable Agda.Syntax.Concrete.HoleContent'
instance Data.Foldable.Foldable Agda.Syntax.Concrete.HoleContent'
instance GHC.Base.Functor Agda.Syntax.Concrete.HoleContent'
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 Data.Data.Data e => Data.Data.Data (Agda.Syntax.Concrete.OpApp e)
instance Data.Data.Data Agda.Syntax.Concrete.ModuleAssignment
instance Data.Data.Data Agda.Syntax.Concrete.DoStmt
instance Data.Data.Data Agda.Syntax.Concrete.LamClause
instance Data.Data.Data Agda.Syntax.Concrete.LHS
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 Data.Data.Data e => Data.Data.Data (Agda.Syntax.Concrete.TypedBinding' e)
instance Data.Data.Data Agda.Syntax.Concrete.ModuleApplication
instance Data.Data.Data Agda.Syntax.Concrete.Declaration
instance Data.Data.Data Agda.Syntax.Concrete.Expr
instance Data.Data.Data Agda.Syntax.Concrete.Pattern
instance Data.Data.Data Agda.Syntax.Concrete.Pragma
instance GHC.Show.Show Agda.Syntax.Concrete.OpenShortHand
instance GHC.Classes.Eq Agda.Syntax.Concrete.OpenShortHand
instance Data.Data.Data Agda.Syntax.Concrete.OpenShortHand
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Concrete.AsName' a)
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 Data.Data.Data decls => Data.Data.Data (Agda.Syntax.Concrete.WhereClause' decls)
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.Data.Data e => Data.Data.Data (Agda.Syntax.Concrete.RHS' e)
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Concrete.LamBinding' a)
instance GHC.Show.Show Agda.Syntax.Concrete.BoundName
instance GHC.Classes.Eq Agda.Syntax.Concrete.BoundName
instance Data.Data.Data Agda.Syntax.Concrete.BoundName
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Concrete.FieldAssignment' a)
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.TypedBinding
instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.LamBinding
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.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 Agda.Syntax.Concrete.DoStmt
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 Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Concrete.LamBinding' a)
instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.BoundName
instance Agda.Syntax.Position.KillRange Agda.Syntax.Concrete.BoundName
instance Control.DeepSeq.NFData Agda.Syntax.Concrete.BoundName
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)

-- | Pretty printer for the concrete syntax.
module Agda.Syntax.Concrete.Pretty

-- | 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 -> SpecialCharacters
[_dbraces] :: SpecialCharacters -> Doc -> Doc
[_lambda] :: SpecialCharacters -> Doc
[_arrow] :: SpecialCharacters -> Doc
[_forallQ] :: SpecialCharacters -> Doc
specialCharacters :: SpecialCharacters
braces' :: Doc -> Doc
dbraces :: Doc -> Doc
forallQ :: Doc
bracesAndSemicolons :: [Doc] -> Doc
arrow :: Doc
lambda :: 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
data NamedBinding
NamedBinding :: Bool -> NamedArg BoundName -> NamedBinding
[withHiding] :: NamedBinding -> Bool
[namedBinding] :: NamedBinding -> NamedArg BoundName
getLabel :: NamedArg a -> Maybe String
isLabeled :: NamedArg BoundName -> Bool
newtype Tel
Tel :: Telescope -> Tel
smashTel :: Telescope -> Telescope
pRecord :: Name -> Maybe (Ranged Induction) -> Maybe HasEta -> Maybe (Name, IsInstance) -> [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 (Agda.Syntax.Concrete.TypedBinding' Agda.Syntax.Concrete.Expr)
instance GHC.Show.Show (Agda.Syntax.Concrete.LamBinding' Agda.Syntax.Concrete.TypedBinding)
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' Agda.Syntax.Concrete.Expr)
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' [Agda.Syntax.Concrete.Declaration])
instance GHC.Show.Show Agda.Syntax.Concrete.ModuleApplication
instance GHC.Show.Show Agda.Syntax.Concrete.DoStmt
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.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 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.Fixity.Fixity
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Notation.GenPart
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Fixity.Fixity'
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Arg a)
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Common.Dom 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.ImportedName' a b)

-- | 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 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.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 Agda.Utils.Benchmark.MonadBench Agda.Benchmarking.Phase 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.
hasEllipsis' :: CPatternLike p => p -> AffineHole Pattern p
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 (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 -> [NamedArg (MaybePlaceholder (OpApp e))] -> ExprView e
HiddenArgV :: Named_ e -> ExprView e
InstanceArgV :: Named_ e -> ExprView e
LamV :: [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

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

-- | Either a wildcard (_), or an unqualified name (possibly
--   containing multiple name parts).
wildOrUnqualifiedName :: IsExpr e => Parser e (Maybe Name)

-- | Used to define the return type of opP.
type family OperatorType (k :: NotationKind) (e :: *) :: *

-- | A singleton type for NotationKind (except for the constructor
--   NoNotation).
data NK (k :: NotationKind) :: *
[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 mapM.
traverseExpr :: (ExprLike a, Monad m) => (Expr -> m Expr) -> a -> m a

-- | This is a reduce.
foldExpr :: (ExprLike a, Monoid m) => (Expr -> m) -> a -> m
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 (Agda.Syntax.Common.Named name 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 [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.MaybePlaceholder 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 (Agda.Syntax.Concrete.TypedBinding' 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.WhereClause' a)
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 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 => [Name] -> m ()
warnUnknownNamesInPolarityPragmas :: MonadFixityError m => [Name] -> m ()
warnUnknownFixityInMixfixDecl :: MonadFixityError m => [Name] -> m ()
warnPolarityPragmasButNotPostulates :: MonadFixityError m => [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)

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

-- | 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
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
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. NB: We put CatchallClause last so
--   that it is overwritten by other, more important, aspects in the emacs
--   mode.
TypeChecks :: OtherAspect
CatchallClause :: OtherAspect

-- | Meta information which can be associated with a character/character
--   range.
data Aspects
Aspects :: Maybe Aspect -> Set OtherAspect -> Maybe String -> Maybe DefinitionSite -> !TokenBased -> Aspects
[aspect] :: Aspects -> Maybe Aspect
[otherAspects] :: Aspects -> Set OtherAspect

-- | This note, if present, 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 -> Maybe String

-- | The definition site of the annotated thing, if applicable and known.
--   File positions are counted from 1.
[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.
[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 File is a mapping from file positions to meta information.
--   
--   The first position in the file has number 1.
newtype File
File :: IntMap Aspects -> File
[mapping] :: File -> IntMap Aspects

-- | Syntax highlighting information.
type HighlightingInfo = CompressedFile

-- | A variant of mempty with tokenBased set to
--   NotOnlyTokenBased.
parserBased :: Aspects

-- | singleton rs m is a file whose positions are those in
--   rs, and in which every position is associated with
--   m.
singleton :: Ranges -> Aspects -> File

-- | Like singleton, but with several Ranges instead of only
--   one.
several :: [Ranges] -> Aspects -> File

-- | Merges files.
merge :: File -> File -> File

-- | Returns the smallest position, if any, in the File.
smallestPos :: File -> Maybe Int

-- | Convert the File to a map from file positions (counting from 1)
--   to meta information.
toMap :: File -> IntMap Aspects

-- | A compressed File, in which consecutive positions with the same
--   Aspects are stored together.
newtype CompressedFile
CompressedFile :: [(Range, Aspects)] -> CompressedFile
[ranges] :: CompressedFile -> [(Range, Aspects)]

-- | Invariant for compressed files.
--   
--   Note that these files are not required to be maximally
--   compressed, because ranges are allowed to be empty, and the
--   Aspectss in adjacent ranges are allowed to be equal.
compressedFileInvariant :: CompressedFile -> Bool

-- | Compresses a file by merging consecutive positions with equal meta
--   information into longer ranges.
compress :: File -> CompressedFile

-- | Decompresses a compressed file.
decompress :: CompressedFile -> File

-- | Clear any highlighting info for the given ranges. Used to make sure
--   unsolved meta highlighting overrides error highlighting.
noHighlightingInRange :: Ranges -> CompressedFile -> CompressedFile

-- | singletonC rs m is a file whose positions are those in
--   rs, and in which every position is associated with
--   m.
singletonC :: Ranges -> Aspects -> CompressedFile

-- | Like singletonR, but with a list of Ranges instead of
--   a single one.
severalC :: [Ranges] -> Aspects -> CompressedFile

-- | splitAtC p f splits the compressed file f into
--   (f1, f2), where all the positions in f1 are <
--   p, and all the positions in f2 are >= p.
splitAtC :: Int -> CompressedFile -> (CompressedFile, CompressedFile)
selectC :: Range -> CompressedFile -> CompressedFile

-- | Returns the smallest position, if any, in the CompressedFile.
smallestPosC :: CompressedFile -> Maybe Int

-- | Merges compressed files.
mergeC :: CompressedFile -> CompressedFile -> CompressedFile
instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.CompressedFile
instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.CompressedFile
instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.File
instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.File
instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.Aspects
instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.TokenBased
instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.TokenBased
instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.DefinitionSite
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.Show.Show Agda.Interaction.Highlighting.Precise.Aspect
instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.Aspect
instance GHC.Show.Show Agda.Interaction.Highlighting.Precise.NameKind
instance GHC.Classes.Eq Agda.Interaction.Highlighting.Precise.NameKind
instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.CompressedFile
instance GHC.Base.Monoid Agda.Interaction.Highlighting.Precise.CompressedFile
instance GHC.Base.Semigroup Agda.Interaction.Highlighting.Precise.File
instance GHC.Base.Monoid Agda.Interaction.Highlighting.Precise.File
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 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

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

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

-- | Strings are the warnings and the (non-fatal) errors
Info_CompilationOk :: String -> String -> DisplayInfo
Info_Constraints :: String -> DisplayInfo

-- | Strings are the goals, the warnings and the (non-fatal) errors
Info_AllGoalsWarnings :: String -> String -> String -> DisplayInfo
Info_Time :: Doc -> DisplayInfo

-- | When an error message is displayed this constructor should be used, if
--   appropriate.
Info_Error :: String -> DisplayInfo

-- | Info_Intro denotes two different types of errors TODO: split
--   these into separate constructors
Info_Intro :: Doc -> 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 :: Doc -> DisplayInfo
Info_SearchAbout :: Doc -> DisplayInfo
Info_WhyInScope :: Doc -> DisplayInfo
Info_NormalForm :: Doc -> DisplayInfo
Info_GoalType :: Doc -> DisplayInfo
Info_CurrentGoal :: Doc -> DisplayInfo
Info_InferredType :: Doc -> DisplayInfo
Info_Context :: Doc -> DisplayInfo
Info_HelperFunction :: Doc -> DisplayInfo
Info_Version :: DisplayInfo

-- | Status information.
data Status
Status :: Bool -> Bool -> Status

-- | Are implicit arguments displayed?
[sShowImplicitArguments] :: 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:
--   
--   
--   
- Convert the response into a Aspect representation and print
--   it on standard output (suitable for inter-process communication).
--   
- Put the response into a mutable variable stored in the closure of
--   the InteractionOutputCallback function. (suitable for
--   intra-process communication).
--   
type InteractionOutputCallback = Response -> TCM ()

-- | The default InteractionOutputCallback function prints certain
--   things to stdout (other things generate internal errors).
defaultInteractionOutputCallback :: InteractionOutputCallback
instance GHC.Show.Show Agda.Interaction.Response.DisplayInfo

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

-- | O(n). Reexport lookup.
lookup :: Eq k => k -> AssocList k v -> 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

-- | 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 DataOrRecord -> Scope
[scopeName] :: Scope -> ModuleName
[scopeParents] :: Scope -> [ModuleName]
[scopeNameSpaces] :: Scope -> ScopeNameSpaces
[scopeImports] :: Scope -> Map QName ModuleName
[scopeDatatypeModule] :: Scope -> Maybe DataOrRecord

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

-- | Visible (as qualified) from outside, but not exported when opening the
--   module. Used for qualified constructors.
OnlyQualifiedNS :: 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
[scopeVarsToBind] :: ScopeInfo -> LocalVars
[scopeLocals] :: ScopeInfo -> LocalVars
[scopePrecedence] :: ScopeInfo -> PrecedenceStack
[scopeInverseName] :: ScopeInfo -> NameMap
[scopeInverseModule] :: ScopeInfo -> ModuleMap
[scopeInScope] :: ScopeInfo -> InScopeSet

-- | Maps concrete names to fixities
[scopeFixities] :: ScopeInfo -> Fixities

-- | Maps concrete names to polarities
[scopePolarities] :: ScopeInfo -> Polarities
type NameMap = Map QName (NonemptyList QName)
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 Binder

-- | λ (currently also used for Π and module parameters)
LambdaBound :: Binder

-- | 
--   f ... =
--   
PatternBound :: Binder

-- | 
--   let ... in
--   
LetBound :: Binder

-- | 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 -> Binder -> [AbstractName] -> LocalVar

-- | Unique ID of local variable.
[localVar] :: LocalVar -> Name

-- | Kind of binder used to introduce the variable (λ,
--   let, ...).
[localBinder] :: LocalVar -> Binder

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

-- | Lens for scopeVarsToBind.
updateVarsToBind :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo
setVarsToBind :: LocalVars -> ScopeInfo -> ScopeInfo

-- | Lens for scopeLocals.
updateScopeLocals :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo
setScopeLocals :: LocalVars -> ScopeInfo -> ScopeInfo
mapScopeInfo :: (Scope -> Scope) -> 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
[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 Eq 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

-- | For the sake of parsing left-hand sides, we distinguish constructor
--   and record field names from defined names.
data KindOfName

-- | Constructor name.
ConName :: KindOfName

-- | Record field name.
FldName :: KindOfName

-- | Ordinary defined name.
DefName :: 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.
QuotableName :: KindOfName

-- | A list containing all name kinds.
allKindsOfNames :: [KindOfName]

-- | 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 :: Functor m => (QName -> m QName) -> AbstractName -> m AbstractName

-- | Van Laarhoven lens on amodName.
lensAmodName :: Functor m => (ModuleName -> m ModuleName) -> AbstractModule -> m AbstractModule
data ResolvedName

-- | Local variable bound by λ, Π, module telescope, pattern, let.
VarName :: Name -> Binder -> ResolvedName
[resolvedVar] :: ResolvedName -> Name

-- | What kind of binder?
[resolvedBinder] :: ResolvedName -> Binder

-- | Function, data/record type, postulate.
DefinedName :: Access -> AbstractName -> ResolvedName

-- | Record field name. Needs to be distinguished to parse copatterns.
FieldName :: NonemptyList AbstractName -> ResolvedName

-- | Data or record constructor name.
ConstructorName :: NonemptyList AbstractName -> ResolvedName

-- | Name of pattern synonym.
PatternSynResName :: NonemptyList AbstractName -> ResolvedName

-- | Unbound name.
UnknownName :: ResolvedName
mergeNames :: Eq a => ThingsInScope 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.
mapScope' :: 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)

-- | 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 names to a scope.
addNamesToScope :: NameSpaceId -> Name -> [AbstractName] -> 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
type UsingOrHiding = Either Using [ImportedName]
usingOrHiding :: ImportDirective -> UsingOrHiding

-- | Apply an ImportDirective to a scope.
applyImportDirective :: ImportDirective -> Scope -> Scope

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

-- | Remove names that can only be used qualified (when opening a scope)
removeOnlyQualified :: Scope -> Scope

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

-- | Compute a flattened scope. Only include unqualified names or names
--   qualified by modules in the first argument.
flattenScope :: [[Name]] -> ScopeInfo -> Map QName [AbstractName]

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

-- | Find the concrete names that map (uniquely) to a given abstract name.
--   Sort by length, shortest first.
inverseScopeLookup :: Either ModuleName QName -> ScopeInfo -> [QName]
inverseScopeLookup' :: AllowAmbiguousNames -> Either ModuleName QName -> ScopeInfo -> [QName]
recomputeInverseScopeMaps :: ScopeInfo -> ScopeInfo

-- | Find the concrete names that map (uniquely) to a given abstract
--   qualified name. Sort by length, shortest first.
inverseScopeLookupName :: QName -> ScopeInfo -> [QName]
inverseScopeLookupName' :: AllowAmbiguousNames -> QName -> ScopeInfo -> [QName]

-- | Find the concrete names that map (uniquely) to a given abstract module
--   name. Sort by length, shortest first.
inverseScopeLookupModule :: ModuleName -> ScopeInfo -> [QName]
prettyNameSpace :: NameSpace -> [Doc]

-- | Add first string only if list is non-empty.
blockOfLines :: Doc -> [Doc] -> [Doc]
instance GHC.Classes.Eq Agda.Syntax.Scope.Base.AllowAmbiguousNames
instance GHC.Classes.Eq Agda.Syntax.Scope.Base.ResolvedName
instance GHC.Show.Show Agda.Syntax.Scope.Base.ResolvedName
instance Data.Data.Data Agda.Syntax.Scope.Base.ResolvedName
instance GHC.Show.Show Agda.Syntax.Scope.Base.ScopeInfo
instance Data.Data.Data Agda.Syntax.Scope.Base.ScopeInfo
instance GHC.Show.Show Agda.Syntax.Scope.Base.Scope
instance GHC.Classes.Eq Agda.Syntax.Scope.Base.Scope
instance Data.Data.Data Agda.Syntax.Scope.Base.Scope
instance GHC.Show.Show Agda.Syntax.Scope.Base.NameSpace
instance GHC.Classes.Eq Agda.Syntax.Scope.Base.NameSpace
instance Data.Data.Data Agda.Syntax.Scope.Base.NameSpace
instance GHC.Show.Show Agda.Syntax.Scope.Base.AbstractModule
instance Data.Data.Data Agda.Syntax.Scope.Base.AbstractModule
instance GHC.Show.Show Agda.Syntax.Scope.Base.LocalVar
instance Data.Data.Data Agda.Syntax.Scope.Base.LocalVar
instance GHC.Show.Show Agda.Syntax.Scope.Base.AbstractName
instance Data.Data.Data Agda.Syntax.Scope.Base.AbstractName
instance GHC.Show.Show Agda.Syntax.Scope.Base.NameMetadata
instance Data.Data.Data Agda.Syntax.Scope.Base.NameMetadata
instance GHC.Show.Show Agda.Syntax.Scope.Base.WhyInScope
instance Data.Data.Data Agda.Syntax.Scope.Base.WhyInScope
instance GHC.Enum.Bounded Agda.Syntax.Scope.Base.KindOfName
instance GHC.Enum.Enum Agda.Syntax.Scope.Base.KindOfName
instance Data.Data.Data Agda.Syntax.Scope.Base.KindOfName
instance GHC.Show.Show Agda.Syntax.Scope.Base.KindOfName
instance GHC.Classes.Eq Agda.Syntax.Scope.Base.KindOfName
instance GHC.Classes.Eq Agda.Syntax.Scope.Base.Binder
instance GHC.Show.Show Agda.Syntax.Scope.Base.Binder
instance Data.Data.Data Agda.Syntax.Scope.Base.Binder
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 Data.Data.Data Agda.Syntax.Scope.Base.NameSpaceId
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.ResolvedName
instance GHC.Classes.Eq 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 Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.Scope
instance Agda.Utils.Pretty.Pretty 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 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 GHC.Classes.Eq Agda.Syntax.Scope.Base.AbstractName
instance GHC.Classes.Ord 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 Agda.Utils.Pretty.Pretty Agda.Syntax.Scope.Base.NameSpaceId

-- | Utilities related to Geniplate.
module Agda.Utils.Geniplate

-- | A localised instance of instanceUniverseBiT. The generated
--   universeBi functions neither descend into the types in
--   dontDescendInto, nor into the types in the list argument.
instanceUniverseBiT' :: [TypeQ] -> TypeQ -> Q [Dec]

-- | A localised instance of instanceTransformBiMT. The generated
--   transformBiM functions neither descend into the types in
--   dontDescendInto, nor into the types in the list argument.
instanceTransformBiMT' :: [TypeQ] -> TypeQ -> TypeQ -> Q [Dec]

-- | Types which Geniplate should not descend into.
dontDescendInto :: [TypeQ]

-- | 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 appbda 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
DefInfo :: Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> DeclInfo -> DefInfo
[defFixity] :: DefInfo -> Fixity'
[defAccess] :: DefInfo -> Access
[defAbstract] :: DefInfo -> IsAbstract
[defInstance] :: DefInfo -> IsInstance
[defMacro] :: DefInfo -> IsMacro
[defInfo] :: DefInfo -> DeclInfo
mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo

-- | Same as mkDefInfo but where we can also give the
--   IsInstance
mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo
data DeclInfo
DeclInfo :: Name -> Range -> DeclInfo
[declName] :: DeclInfo -> Name
[declRange] :: DeclInfo -> Range
data MutualInfo
MutualInfo :: TerminationCheck Name -> PositivityCheck -> Range -> MutualInfo
[mutualTermCheck] :: MutualInfo -> TerminationCheck Name
[mutualPositivityCheck] :: MutualInfo -> PositivityCheck
[mutualRange] :: MutualInfo -> Range
newtype LHSInfo
LHSRange :: Range -> LHSInfo

-- | 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?
[patOrigin] :: ConPatInfo -> ConOrigin
[patInfo] :: ConPatInfo -> PatInfo
[patLazy] :: ConPatInfo -> ConPatLazy

-- | Has the constructor pattern a dotted (forced) constructor?
data ConPatLazy

-- | Dotted constructor.
ConPatLazy :: ConPatLazy

-- | Ordinary constructor.
ConPatEager :: ConPatLazy
instance GHC.Classes.Eq Agda.Syntax.Info.ConPatInfo
instance Data.Data.Data Agda.Syntax.Info.ConPatInfo
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 Data.Data.Data Agda.Syntax.Info.ConPatLazy
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 Agda.Utils.Null.Null Agda.Syntax.Info.PatInfo
instance GHC.Classes.Eq Agda.Syntax.Info.PatInfo
instance Data.Data.Data Agda.Syntax.Info.PatInfo
instance Agda.Utils.Null.Null Agda.Syntax.Info.LHSInfo
instance GHC.Classes.Eq Agda.Syntax.Info.LHSInfo
instance GHC.Show.Show Agda.Syntax.Info.LHSInfo
instance Data.Data.Data Agda.Syntax.Info.LHSInfo
instance GHC.Classes.Eq Agda.Syntax.Info.MutualInfo
instance GHC.Show.Show Agda.Syntax.Info.MutualInfo
instance Data.Data.Data Agda.Syntax.Info.MutualInfo
instance GHC.Classes.Eq Agda.Syntax.Info.DefInfo
instance GHC.Show.Show Agda.Syntax.Info.DefInfo
instance Data.Data.Data Agda.Syntax.Info.DefInfo
instance GHC.Classes.Eq Agda.Syntax.Info.DeclInfo
instance GHC.Show.Show Agda.Syntax.Info.DeclInfo
instance Data.Data.Data Agda.Syntax.Info.DeclInfo
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 Data.Data.Data Agda.Syntax.Info.LetInfo
instance GHC.Classes.Eq Agda.Syntax.Info.ModuleInfo
instance Data.Data.Data Agda.Syntax.Info.ModuleInfo
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 Data.Data.Data Agda.Syntax.Info.AppInfo
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 Data.Data.Data Agda.Syntax.Info.ExprInfo
instance GHC.Classes.Eq Agda.Syntax.Info.MetaInfo
instance GHC.Show.Show Agda.Syntax.Info.MetaInfo
instance Data.Data.Data Agda.Syntax.Info.MetaInfo
instance GHC.Show.Show Agda.Syntax.Info.ModuleInfo
instance GHC.Show.Show 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 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.MutualInfo
instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.MutualInfo
instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.MutualInfo
instance Agda.Syntax.Position.HasRange Agda.Syntax.Info.DefInfo
instance Agda.Syntax.Position.SetRange Agda.Syntax.Info.DefInfo
instance Agda.Syntax.Position.KillRange Agda.Syntax.Info.DefInfo
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 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 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 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

-- | 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 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 GHC.Arr.Ix i => GHC.Arr.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 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 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:
--   
--   
--   
- lt (less than) if the j-th argument to the
--   target function is structurally strictly smaller than the
--   i-th pattern.
--   
- le (less than or equal) if the j-th argument to
--   the target function is structurally smaller than the
--   i-th pattern.
--   
- unknown otherwise.
--   
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.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 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.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 Agda.Termination.Order.NotWorse (Agda.Termination.CallMatrix.CallMatrix' Agda.Termination.Order.Order)
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

-- | Converts a list of calls with associated meta information to a call
--   graph.
fromList :: [Call cinfo] -> CallGraph cinfo

-- | 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.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:
--   
--   
--   
- Whitespace characters other than '\t' and '\n' are translated to '
--   '.
--   
- Non-ASCII alphabetical characters are translated to 'z'.
--   
- Other non-ASCII printable characters are translated to '+'.
--   
- Everything else is translated to '\1'.
--   
--   
--   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.
type 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 ()

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

-- | 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 either when seeing an open brace
--   (openBrace) or at the next token (newLayoutContext).
--   
--   Update: we don't use braces for layout anymore.
layout :: LexState

-- | We enter this state from newLayoutContext 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 newLayoutContext.
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)

-- | 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.Show.Show Agda.Syntax.Parser.Parser.RHSOrTypeSigs
instance GHC.Show.Show Agda.Syntax.Parser.Parser.RecordDirective
instance GHC.Classes.Eq Agda.Syntax.Parser.Parser.RecordDirective
instance Agda.Syntax.Position.HasRange Agda.Syntax.Parser.Parser.Attr
instance Agda.Syntax.Position.SetRange Agda.Syntax.Parser.Parser.Attr

-- | 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 :: LexAction r -> LexAction r

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

-- | Parse a literal.
literal :: Read a => (Range -> a -> Literal) -> LexAction Token

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

-- | 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' = case x of { True -> False; False -> ...
--   
--   
--   At the ... the layout context would be
--   
--   
--   [NoLayout, Layout 4, Layout 0]
--   
--   
--   The closest layout block is the one containing the case
--   branches. This block starts with an open brace ('{') and so
--   doesn't use layout. The second closest block is the where
--   clause. Here, there is no open brace so the block is started by the
--   x' token which has indentation 4. Finally there is a
--   top-level layout block with indentation 0.
module Agda.Syntax.Parser.Layout

-- | Executed upon lexing an open brace ('{'). Enters the
--   NoLayout context.
openBrace :: LexAction Token

-- | Executed upon lexing a close brace ('}'). Exits the current
--   layout context. This might look a bit funny--the lexer will happily
--   use a close brace to close a context open by a virtual brace. This is
--   not a problem since the parser will make sure the braces are
--   appropriately matched.
closeBrace :: LexAction Token

-- | Executed for layout keywords. Enters the layout state and
--   performs the given action.
withLayout :: LexAction r -> LexAction r

-- | Executed for the first token in each line (see bol). Checks the
--   position of the token relative to the current layout context. If the
--   token is
--   
--   
--   
- to the left : Exit the current context and a return virtual
--   close brace (stay in the bol state).
--   
- same column : Exit the bol state and return a
--   virtual semi colon.
--   
- to the right : Exit the bol state and continue
--   lexing.
--   
--   
--   If the current block doesn't use layout (i.e. it was started by
--   openBrace) all positions are considered to be to the
--   right.
offsideRule :: LexAction Token

-- | Start a new layout context. This is one of two ways to get out of the
--   layout state (the other is openBrace). There are two
--   possibilities:
--   
--   
--   
- The current token is to the right of the current layout context
--   (or we're in a no layout context).
--   
- The current token is to the left of or in the same column as the
--   current context.
--   
--   
--   In the first case everything is fine and we enter a new layout context
--   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.
newLayoutContext :: 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
--   newLayoutContext).
emptyLayout :: LexAction Token

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:
--   
--   
--   
- sort and color annotations,
--   
- projections.
--   
class TermSize a
termSize :: TermSize a => a -> Int
tsize :: TermSize a => a -> Sum Int
class IsProjElim e
isProjElim :: IsProjElim e => e -> Maybe (ProjOrigin, QName)

-- | Pick the better name suggestion, i.e., the one that is not just
--   underscore.
class Suggest a b
suggest :: Suggest a b => a -> b -> 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)]
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

-- | View type as equality type.
data EqualityView
EqualityType :: Sort -> QName -> [Arg Term] -> Arg Term -> Arg Term -> Arg Term -> EqualityView

-- | Sort of this type.
[eqtSort] :: EqualityView -> Sort

-- | Builtin EQUALITY.
[eqtName] :: EqualityView -> QName

-- | Hidden. Empty or Level.
[eqtParams] :: EqualityView -> [Arg Term]

-- | Hidden
[eqtType] :: EqualityView -> Arg Term

-- | NotHidden
[eqtLhs] :: EqualityView -> Arg Term

-- | NotHidden
[eqtRhs] :: EqualityView -> Arg Term

-- | reduced
OtherType :: 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
--   (throwImpossible (Impossible
--   "srcfullAgdaSyntaxInternal.hs" 614)). Apply this to
--   closed terms you want to use in a non-empty context. Γ ⊢ EmptyS :
--   ()
EmptyS :: Empty -> Substitution' a

-- | Substitution extension, `cons'.  Γ ⊢ u : Aρ Γ ⊢ ρ : Δ
--   ---------------------- Γ ⊢ u :# ρ : Δ, A 
(:#) :: a -> Substitution' a -> Substitution' a

-- | Strengthening substitution. First argument is (throwImpossible
--   (Impossible "srcfullAgdaSyntaxInternal.hs" 627)).
--   Apply this to a term which does not contain variable 0 to lower all de
--   Bruijn indices by one.  Γ ⊢ ρ : Δ --------------------------- Γ ⊢
--   Strengthen ρ : Δ, A 
Strengthen :: Empty -> Substitution' a -> Substitution' a

-- | Weakning 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 b | b -> a
patternVars :: PatternVars a b => b -> [Arg (Either a Term)]

-- | The ConPatternInfo states whether the constructor belongs to
--   a record type (Just) or data type (Nothing). In the
--   former case, the PatOrigin 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 :: Maybe PatOrigin -> Bool -> Maybe (Arg Type) -> Bool -> ConPatternInfo

-- | Nothing if data constructor. Just if record
--   constructor.
[conPRecord] :: ConPatternInfo -> Maybe PatOrigin

-- | 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
--   (forcingTranslation) 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 :: PatOrigin -> x -> Pattern' x

-- | 
--   .t
--   
DotP :: PatOrigin -> 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 :: 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 :: PatOrigin -> Term -> Term -> x -> Pattern' x

-- | Used for HITs, the QName should be the one from primHComp.
DefP :: PatOrigin -> 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

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

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

-- | Named pattern arguments.
type NAPs = [NamedArg DeBruijnPattern]

-- | Blocked t without the t.
type Blocked_ = Blocked ()

-- | Something where a meta variable may block reduction.
data Blocked t
Blocked :: MetaId -> t -> Blocked t
[theBlockingMeta] :: Blocked t -> MetaId
[ignoreBlocking] :: Blocked t -> t
NotBlocked :: NotBlocked -> t -> Blocked t
[blockingStatus] :: Blocked t -> NotBlocked
[ignoreBlocking] :: Blocked t -> t

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

-- | The Elim is neutral and blocks a pattern match.
StuckOn :: Elim -> NotBlocked

-- | Not enough arguments were supplied to complete the matching.
Underapplied :: NotBlocked

-- | We matched an absurd clause, results in a neutral Def.
AbsurdMatch :: NotBlocked

-- | We ran out of clauses, 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 :: NotBlocked

-- | Reduction was not blocked, we reached a whnf which can be anything but
--   a stuck Def.
ReallyNotBlocked :: NotBlocked

-- | An atomic term of type Level.
data LevelAtom

-- | A meta variable targeting Level under some eliminations.
MetaLevel :: MetaId -> Elims -> LevelAtom

-- | A term of type Level whose reduction is blocked by a meta.
BlockedLevel :: MetaId -> Term -> LevelAtom

-- | A neutral term of type Level.
NeutralLevel :: NotBlocked -> Term -> LevelAtom

-- | Introduced by instantiate, removed by reduce.
UnreducedLevel :: Term -> LevelAtom
data PlusLevel

-- | n, to represent Setₙ.
ClosedLevel :: Integer -> PlusLevel

-- | n + ℓ.
Plus :: Integer -> LevelAtom -> PlusLevel

-- | A level is a maximum expression of 0..n PlusLevel expressions
--   each of which is a number or an atom plus a number.
--   
--   The empty maximum is the canonical representation for level 0.
newtype Level
Max :: [PlusLevel] -> Level

-- | Sorts.
data Sort

-- | Set ℓ.
Type :: Level -> Sort

-- | Prop ℓ.
Prop :: Level -> Sort

-- | Setω.
Inf :: Sort

-- | SizeUniv, a sort inhabited by type Size.
SizeUniv :: Sort

-- | Sort of the pi type.
PiSort :: Sort -> Abs Sort -> Sort

-- | Sort of another sort.
UnivSort :: Sort -> Sort
MetaS :: {-# UNPACK #-} !MetaId -> Elims -> Sort

-- | A postulated sort.
DefS :: QName -> Elims -> Sort

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

-- | Types are terms with a sort annotation.
data Type' a
El :: Sort -> a -> Type' a
[_getSort] :: Type' a -> Sort
[unEl] :: Type' 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

-- | Names in binders and arguments.
type ArgName = String
type Elims = [Elim] " eliminations ordered left-to-right."
type Elim = Elim' Term

-- | 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
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.
Dummy :: String -> 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 -> Induction -> [Arg QName] -> ConHead

-- | The name of the constructor.
[conName] :: ConHead -> QName

-- | Record constructors can be coinductive.
[conInductive] :: ConHead -> Induction

-- | The name of the record fields. Empty list for data constructors.
--   Arg is stored since the info in the constructor args might not
--   be accurate because of subtyping (issue #2170).
[conFields] :: ConHead -> [Arg QName]
type NamedArgs = [NamedArg Term]

-- | Type of argument lists.
type Args = [Arg Term]
argNameToString :: ArgName -> String
stringToArgName :: String -> ArgName
appendArgNames :: ArgName -> ArgName -> ArgName
nameToArgName :: Name -> ArgName
namedArgName :: NamedArg Name -> ArgName

-- | 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 -> NotBlocked -> NotBlocked
clausePats :: Clause -> [Arg DeBruijnPattern]
patVarNameToString :: PatVarName -> String
nameToPatVarName :: Name -> PatVarName
varP :: a -> Pattern' a
dotP :: Term -> 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 origin of a pattern
patternOrigin :: Pattern' x -> Maybe PatOrigin

-- | Does the pattern perform a match that could fail?
properlyMatching :: DeBruijnPattern -> Bool
isEqualityType :: EqualityView -> Bool
isPathType :: PathView -> 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

-- | Aux: A dummy term to constitute a dummy termlevelsort/type.
dummyTerm' :: String -> Int -> Term

-- | Aux: A dummy level to constitute a level/sort.
dummyLevel' :: String -> Int -> Level

-- | A dummy term created at location. Note: use macro (dummyTerm
--   "srcfullAgdaSyntaxInternal.hs" 763) !
dummyTerm :: String -> Int -> Term

-- | A dummy level created at location. Note: use macro (dummyLevel
--   "srcfullAgdaSyntaxInternal.hs" 768) !
dummyLevel :: String -> Int -> Level

-- | A dummy sort created at location. Note: use macro (dummySort
--   "srcfullAgdaSyntaxInternal.hs" 773) !
dummySort :: String -> Int -> Sort

-- | A dummy type created at location. Note: use macro (dummyType
--   "srcfullAgdaSyntaxInternal.hs" 778) !
dummyType :: String -> Int -> Type

-- | Context entries without a type have this dummy type. Note: use macro
--   (dummyDom "srcfullAgdaSyntaxInternal.hs" 783) !
dummyDom :: String -> Int -> Dom Type
unreducedLevel :: Term -> Level

-- | Top sort (Setomega).
topSort :: Type
sort :: Sort -> Type
varSort :: Int -> Sort
tmSort :: Term -> Sort
levelSuc :: Level -> Level
mkType :: Integer -> Sort
mkProp :: Integer -> Sort
isSort :: Term -> Maybe Sort
impossibleTerm :: String -> Int -> 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
blockingMeta :: Blocked t -> Maybe MetaId
blocked :: MetaId -> a -> Blocked a
notBlocked :: a -> Blocked a

-- | Removing a topmost DontCare constructor.
stripDontCare :: Term -> Term

-- | Doesn't do any reduction.
arity :: Type -> Nat

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

-- | Drop Apply constructor. (Safe)
isApplyElim :: Elim' a -> Maybe (Arg a)
isApplyElim' :: Empty -> Elim' a -> Arg a

-- | Drop Apply constructors. (Safe)
allApplyElims :: [Elim' a] -> Maybe [Arg a]

-- | Split at first non-Apply
splitApplyElims :: [Elim' a] -> ([Arg a], [Elim' a])

-- | Discards Proj f entries.
argsFromElims :: Elims -> Args

-- | Drop Proj constructors. (Safe)
allProjElims :: Elims -> Maybe [(ProjOrigin, QName)]
pDom :: LensHiding a => a -> Doc -> Doc

-- | A meta variable identifier is just a natural number.
newtype MetaId
MetaId :: Nat -> MetaId
[metaId] :: MetaId -> Nat
instance Data.Generics.Geniplate.UniverseBi [Agda.Syntax.Internal.Term] Agda.Syntax.Internal.Term
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Substitution' a)
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Term
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Clause
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Tele (Agda.Syntax.Common.Dom a))
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Level
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.PlusLevel
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.LevelAtom
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Sort
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.Type
instance Agda.Utils.Pretty.Pretty tm => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Elim' tm)
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Internal.DBPatVar
instance Agda.Utils.Pretty.Pretty a => Agda.Utils.Pretty.Pretty (Agda.Syntax.Internal.Pattern' a)
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 Agda.Syntax.Internal.PlusLevel
instance Control.DeepSeq.NFData Agda.Syntax.Internal.LevelAtom
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Agda.Syntax.Internal.Elim' a)
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Internal.Elims Agda.Syntax.Internal.Term
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Internal.Args Agda.Syntax.Internal.Term
instance Data.Generics.Geniplate.UniverseBi ([Agda.Syntax.Internal.Type], [Agda.Syntax.Internal.Clause]) Agda.Syntax.Internal.Term
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Internal.Elims Agda.Syntax.Internal.Pattern
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Internal.Args Agda.Syntax.Internal.Pattern
instance Data.Generics.Geniplate.UniverseBi ([Agda.Syntax.Internal.Type], [Agda.Syntax.Internal.Clause]) Agda.Syntax.Internal.Pattern
instance GHC.Show.Show Agda.Syntax.Internal.IntervalView
instance Data.Data.Data a => Data.Data.Data (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.Clause
instance Data.Data.Data Agda.Syntax.Internal.Clause
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 Data.Data.Data x => Data.Data.Data (Agda.Syntax.Internal.Pattern' x)
instance GHC.Show.Show Agda.Syntax.Internal.ConPatternInfo
instance Data.Data.Data Agda.Syntax.Internal.ConPatternInfo
instance GHC.Classes.Eq Agda.Syntax.Internal.DBPatVar
instance GHC.Show.Show Agda.Syntax.Internal.DBPatVar
instance Data.Data.Data Agda.Syntax.Internal.DBPatVar
instance GHC.Classes.Eq Agda.Syntax.Internal.PatOrigin
instance GHC.Show.Show Agda.Syntax.Internal.PatOrigin
instance Data.Data.Data Agda.Syntax.Internal.PatOrigin
instance Data.Traversable.Traversable Agda.Syntax.Internal.Blocked
instance Data.Foldable.Foldable Agda.Syntax.Internal.Blocked
instance GHC.Base.Functor Agda.Syntax.Internal.Blocked
instance GHC.Show.Show t => GHC.Show.Show (Agda.Syntax.Internal.Blocked t)
instance Data.Traversable.Traversable Agda.Syntax.Internal.Type'
instance Data.Foldable.Foldable Agda.Syntax.Internal.Type'
instance GHC.Base.Functor Agda.Syntax.Internal.Type'
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Internal.Type' a)
instance Data.Data.Data a => Data.Data.Data (Agda.Syntax.Internal.Type' a)
instance GHC.Show.Show Agda.Syntax.Internal.Sort
instance Data.Data.Data Agda.Syntax.Internal.Sort
instance Data.Data.Data Agda.Syntax.Internal.LevelAtom
instance GHC.Show.Show Agda.Syntax.Internal.LevelAtom
instance Data.Data.Data Agda.Syntax.Internal.PlusLevel
instance GHC.Show.Show Agda.Syntax.Internal.PlusLevel
instance Data.Data.Data Agda.Syntax.Internal.Level
instance GHC.Show.Show Agda.Syntax.Internal.Level
instance GHC.Show.Show Agda.Syntax.Internal.Term
instance Data.Data.Data Agda.Syntax.Internal.Term
instance Data.Data.Data Agda.Syntax.Internal.NotBlocked
instance GHC.Show.Show Agda.Syntax.Internal.NotBlocked
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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Internal.Tele 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 Data.Data.Data a => Data.Data.Data (Agda.Syntax.Internal.Abs a)
instance Data.Traversable.Traversable Agda.Syntax.Internal.Elim'
instance Data.Foldable.Foldable Agda.Syntax.Internal.Elim'
instance GHC.Base.Functor Agda.Syntax.Internal.Elim'
instance GHC.Show.Show a => GHC.Show.Show (Agda.Syntax.Internal.Elim' a)
instance Data.Data.Data a => Data.Data.Data (Agda.Syntax.Internal.Elim' a)
instance GHC.Show.Show Agda.Syntax.Internal.ConHead
instance Data.Data.Data Agda.Syntax.Internal.ConHead
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 Agda.Syntax.Internal.LevelAtom
instance Agda.Syntax.Internal.TermSize a => Agda.Syntax.Internal.TermSize (Agda.Syntax.Internal.Substitution' a)
instance Agda.Syntax.Internal.IsProjElim Agda.Syntax.Internal.Elim
instance Agda.Syntax.Internal.Suggest GHC.Base.String GHC.Base.String
instance Agda.Syntax.Internal.Suggest (Agda.Syntax.Internal.Abs a) (Agda.Syntax.Internal.Abs b)
instance Agda.Syntax.Internal.Suggest GHC.Base.String (Agda.Syntax.Internal.Abs b)
instance Agda.Syntax.Internal.Suggest Agda.Syntax.Abstract.Name.Name (Agda.Syntax.Internal.Abs b)
instance Agda.Syntax.Internal.SgTel (Agda.Syntax.Internal.ArgName, Agda.Syntax.Common.Dom Agda.Syntax.Internal.Type)
instance Agda.Syntax.Internal.SgTel (Agda.Syntax.Common.Dom (Agda.Syntax.Internal.ArgName, Agda.Syntax.Internal.Type))
instance Agda.Syntax.Internal.SgTel (Agda.Syntax.Common.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.Syntax.Internal.PatternVars a (Agda.Syntax.Common.Arg (Agda.Syntax.Internal.Pattern' a))
instance Agda.Syntax.Internal.PatternVars a (Agda.Syntax.Common.NamedArg (Agda.Syntax.Internal.Pattern' a))
instance Agda.Syntax.Internal.PatternVars a b => Agda.Syntax.Internal.PatternVars a [b]
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.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.Syntax.Position.KillRange Agda.Syntax.Internal.ConPatternInfo
instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.DBPatVar
instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.PatOrigin
instance GHC.Base.Semigroup Agda.Syntax.Internal.Blocked_
instance GHC.Base.Monoid Agda.Syntax.Internal.Blocked_
instance GHC.Base.Applicative Agda.Syntax.Internal.Blocked
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Blocked a)
instance Agda.Syntax.Internal.LensSort (Agda.Syntax.Internal.Type' a)
instance Agda.Syntax.Internal.LensSort a => Agda.Syntax.Internal.LensSort (Agda.Syntax.Common.Dom a)
instance Agda.Syntax.Internal.LensSort a => Agda.Syntax.Internal.LensSort (Agda.Syntax.Common.Arg a)
instance Agda.Syntax.Internal.LensSort a => Agda.Syntax.Internal.LensSort (Agda.Syntax.Internal.Abs a)
instance Agda.Utils.Functor.Decoration Agda.Syntax.Internal.Type'
instance GHC.Base.Semigroup Agda.Syntax.Internal.NotBlocked
instance GHC.Base.Monoid Agda.Syntax.Internal.NotBlocked
instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Term
instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.Level
instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.PlusLevel
instance Agda.Syntax.Position.KillRange Agda.Syntax.Internal.LevelAtom
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.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 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.Syntax.Common.LensOrigin (Agda.Syntax.Internal.Elim' a)
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.Syntax.Internal.Elim' 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

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

-- | 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.Common.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.LevelAtom
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' 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 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))
--   
--   
--   
- Jason C. Reed, PhD thesis, page 106
--   
--   
--   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).
module Agda.TypeChecking.Free.Lazy
type MetaSet = Set MetaId

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

-- | In arguments of metas. The set of metas is used by
--   'NonLinMatch' to generate the right blocking information.
Flexible :: MetaSet -> FlexRig

-- | In arguments to variables and definitions.
WeaklyRigid :: FlexRig

-- | In top position, or only under inductive record constructors.
Unguarded :: FlexRig

-- | Under at least one and only inductive constructors.
StronglyRigid :: FlexRig

-- | FlexRig composition. For accumulating the context of a
--   variable.
--   
--   Flexible is dominant. Once we are under a meta, we are flexible
--   regardless what else comes.
--   
--   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 :: FlexRig -> FlexRig -> FlexRig

-- | Occurrence of free variables is classified by several dimensions.
--   Currently, we have FlexRig and Relevance.
data VarOcc
VarOcc :: FlexRig -> Relevance -> VarOcc
[varFlexRig] :: VarOcc -> FlexRig
[varRelevance] :: VarOcc -> Relevance

-- | When we extract information about occurrence, we care most about about
--   StronglyRigid Relevant occurrences.
maxVarOcc :: VarOcc -> VarOcc -> VarOcc
topVarOcc :: VarOcc
botVarOcc :: VarOcc

-- | First argument is the outer occurrence and second is the inner.
composeVarOcc :: VarOcc -> VarOcc -> VarOcc

-- | Any representation 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`.
class (Semigroup a, Monoid a) => IsVarSet a

-- | Laws * Respects monoid operations: ``` withVarOcc o mempty == mempty
--   withVarOcc o (x <> y) == withVarOcc o x <> withVarOcc o y
--   ``` * Respects VarOcc composition ``` withVarOcc (composeVarOcc o1 o2)
--   = withVarOcc o1 . withVarOcc o2 ```
withVarOcc :: IsVarSet a => VarOcc -> a -> a
type TheVarMap = IntMap VarOcc
newtype VarMap
VarMap :: TheVarMap -> VarMap
[theVarMap] :: VarMap -> TheVarMap
mapVarMap :: (TheVarMap -> TheVarMap) -> VarMap -> VarMap

-- | 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 c
FreeEnv :: !IgnoreSorts -> !FlexRig -> !Relevance -> (Maybe Variable -> c) -> FreeEnv c

-- | Ignore free variables in sorts.
[feIgnoreSorts] :: FreeEnv c -> !IgnoreSorts

-- | Are we flexible or rigid?
[feFlexRig] :: FreeEnv c -> !FlexRig

-- | What is the current relevance?
[feRelevance] :: FreeEnv c -> !Relevance

-- | Method to return a single variable.
[feSingleton] :: FreeEnv c -> Maybe Variable -> c
type Variable = Int
type SingleVar c = Variable -> c

-- | The initial context.
initFreeEnv :: Monoid c => SingleVar c -> FreeEnv c
type FreeM c = Reader (FreeEnv c) c

-- | Run function for FreeM.
runFreeM :: IsVarSet c => SingleVar c -> IgnoreSorts -> FreeM c -> c

-- | Base case: a variable.
variable :: IsVarSet c => Int -> FreeM c

-- | Subtract, but return Nothing if result is negative.
subVar :: Int -> Maybe Variable -> Maybe Variable

-- | Going under a binder.
bind :: FreeM a -> FreeM a
bind' :: Nat -> FreeM a -> FreeM a

-- | Changing the FlexRig context.
go :: FlexRig -> FreeM a -> FreeM a

-- | Changing the Relevance.
goRel :: Relevance -> FreeM a -> FreeM a

-- | What happens to the variables occurring under a constructor?
underConstructor :: ConHead -> FreeM a -> FreeM a

-- | Gather free variables in a collection.
class Free a
freeVars' :: (Free a, IsVarSet c) => a -> FreeM c
instance Agda.Utils.Singleton.Singleton (Agda.TypeChecking.Free.Lazy.Variable, Agda.TypeChecking.Free.Lazy.VarOcc) Agda.TypeChecking.Free.Lazy.VarMap
instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.VarMap
instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.IgnoreSorts
instance GHC.Classes.Eq Agda.TypeChecking.Free.Lazy.IgnoreSorts
instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.VarOcc
instance GHC.Classes.Eq Agda.TypeChecking.Free.Lazy.VarOcc
instance GHC.Show.Show Agda.TypeChecking.Free.Lazy.FlexRig
instance GHC.Classes.Ord Agda.TypeChecking.Free.Lazy.FlexRig
instance GHC.Classes.Eq Agda.TypeChecking.Free.Lazy.FlexRig
instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Type' a)
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 Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.LevelAtom
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free [a]
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (GHC.Maybe.Maybe a)
instance (Agda.TypeChecking.Free.Lazy.Free a, Agda.TypeChecking.Free.Lazy.Free b) => Agda.TypeChecking.Free.Lazy.Free (a, b)
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Elim' a)
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Common.Arg a)
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Common.Dom a)
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Abs a)
instance Agda.TypeChecking.Free.Lazy.Free a => Agda.TypeChecking.Free.Lazy.Free (Agda.Syntax.Internal.Tele a)
instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.Clause
instance Agda.TypeChecking.Free.Lazy.Free Agda.Syntax.Internal.EqualityView
instance GHC.Base.Semigroup c => GHC.Base.Semigroup (Agda.TypeChecking.Free.Lazy.FreeM c)
instance (GHC.Base.Semigroup c, GHC.Base.Monoid c) => GHC.Base.Monoid (Agda.TypeChecking.Free.Lazy.FreeM c)
instance GHC.Base.Semigroup Agda.TypeChecking.Free.Lazy.VarMap
instance GHC.Base.Monoid Agda.TypeChecking.Free.Lazy.VarMap
instance Agda.TypeChecking.Free.Lazy.IsVarSet Agda.TypeChecking.Free.Lazy.VarMap
instance Agda.Syntax.Common.LensRelevance Agda.TypeChecking.Free.Lazy.VarOcc

-- | 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))
--   
--   
--   
- Jason C. Reed, PhD thesis, page 106
--   
--   
--   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).
module Agda.TypeChecking.Free

-- | Free variables of a term, (disjointly) partitioned into strongly and
--   and weakly rigid variables, flexible variables and irrelevant
--   variables.
data FreeVars
FV :: VarSet -> VarSet -> VarSet -> IntMap MetaSet -> VarSet -> FreeVars

-- | Variables under only and at least one inductive constructor(s).
[stronglyRigidVars] :: FreeVars -> 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] :: FreeVars -> VarSet

-- | Ordinary rigid variables, e.g., in arguments of variables or
--   functions.
[weaklyRigidVars] :: FreeVars -> 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] :: FreeVars -> IntMap MetaSet

-- | Variables in irrelevant arguments and under a DontCare, i.e.,
--   in irrelevant positions.
[irrelevantVars] :: FreeVars -> VarSet
newtype VarCounts
VarCounts :: IntMap Int -> VarCounts
[varCounts] :: VarCounts -> IntMap Int

-- | Gather free variables in a collection.
class Free a

-- | Any representation 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`.
class (Semigroup a, Monoid a) => IsVarSet a

-- | Laws * Respects monoid operations: ``` withVarOcc o mempty == mempty
--   withVarOcc o (x <> y) == withVarOcc o x <> withVarOcc o y
--   ``` * Respects VarOcc composition ``` withVarOcc (composeVarOcc o1 o2)
--   = withVarOcc o1 . withVarOcc o2 ```
withVarOcc :: IsVarSet a => VarOcc -> a -> a

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

-- | Compute free variables.
runFree :: (IsVarSet c, Free a) => SingleVar c -> IgnoreSorts -> a -> c

-- | Rigid variables: either strongly rigid, unguarded, or weakly rigid.
rigidVars :: FreeVars -> VarSet

-- | All but the irrelevant variables.
relevantVars :: FreeVars -> VarSet

-- | allVars fv includes irrelevant variables.
allVars :: FreeVars -> VarSet

-- | Collect all free variables.
allFreeVars :: Free a => a -> VarSet

-- | Collect all free variables together with information about their
--   occurrence.
allFreeVarsWithOcc :: Free a => a -> TheVarMap

-- | Collect all relevant free variables, excluding the "unused" ones.
allRelevantVars :: Free a => a -> VarSet

-- | Collect all relevant free variables, possibly ignoring sorts.
allRelevantVarsIgnoring :: Free a => IgnoreSorts -> a -> VarSet
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 a => Nat -> a -> Bool
relevantInIgnoringSortAnn :: Free a => Nat -> a -> Bool
data Occurrence
NoOccurrence :: Occurrence
Irrelevantly :: Occurrence

-- | Under at least one and only inductive constructors.
StronglyRigid :: Occurrence

-- | In top position, or only under inductive record constructors.
Unguarded :: Occurrence

-- | In arguments to variables and definitions.
WeaklyRigid :: Occurrence

-- | In arguments of metas.
Flexible :: MetaSet -> Occurrence

-- | Occurrence of free variables is classified by several dimensions.
--   Currently, we have FlexRig and Relevance.
data VarOcc
VarOcc :: FlexRig -> Relevance -> VarOcc
[varFlexRig] :: VarOcc -> FlexRig
[varRelevance] :: VarOcc -> Relevance

-- | Compute an occurrence of a single variable in a piece of internal
--   syntax.
occurrence :: Free a => Nat -> a -> Occurrence

-- | Is the term entirely closed (no free variables)?
closed :: Free a => a -> Bool

-- | Doesn't go inside solved metas, but collects the variables from a
--   metavariable application X ts as flexibleVars.
freeVars :: (IsVarSet c, Singleton Variable c, Free a) => a -> c
freeVars' :: (Free a, IsVarSet c) => a -> FreeM c
type MetaSet = Set MetaId
instance GHC.Base.Monoid a => GHC.Base.Monoid (Agda.TypeChecking.Free.RelevantIn a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Agda.TypeChecking.Free.RelevantIn a)
instance GHC.Show.Show Agda.TypeChecking.Free.Occurrence
instance GHC.Classes.Eq Agda.TypeChecking.Free.Occurrence
instance GHC.Show.Show Agda.TypeChecking.Free.FreeVars
instance GHC.Classes.Eq Agda.TypeChecking.Free.FreeVars
instance Agda.TypeChecking.Free.Lazy.IsVarSet a => Agda.TypeChecking.Free.Lazy.IsVarSet (Agda.TypeChecking.Free.RelevantIn a)
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.Utils.Null.Null Agda.TypeChecking.Free.FreeVars
instance GHC.Base.Semigroup Agda.TypeChecking.Free.FreeVars
instance GHC.Base.Monoid Agda.TypeChecking.Free.FreeVars
instance Agda.Utils.Singleton.Singleton Agda.TypeChecking.Free.Lazy.Variable Agda.TypeChecking.Free.FreeVars
instance Agda.TypeChecking.Free.Lazy.IsVarSet Agda.TypeChecking.Free.FreeVars
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 t => Subst t a | a -> t
applySubst :: Subst t a => Substitution' t -> a -> a
raise :: Subst t a => Nat -> a -> a
raiseFrom :: Subst t a => Nat -> Nat -> a -> a

-- | Replace de Bruijn index i by a Term in something.
subst :: Subst t a => Int -> t -> a -> a
strengthen :: Subst t a => Empty -> 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 t a => Nat -> t -> 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 :: Subst a 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 :: Subst a 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 => Empty -> [Maybe a] -> Substitution' a -> Substitution' a
parallelS :: DeBruijn a => [a] -> Substitution' a
compactS :: DeBruijn a => Empty -> [Maybe a] -> Substitution' a

-- | Γ ⊢ (strengthenS ⊥ |Δ|) : Γ,Δ
strengthenS :: Empty -> Int -> Substitution' a
lookupS :: Subst a a => Substitution' a -> Nat -> a

-- | Instantiate an abstraction. Strict in the term.
absApp :: Subst t a => Abs a -> t -> a

-- | Instantiate an abstraction. Lazy in the term, which allow it to be
--   (throwImpossible (Impossible
--   "srcfullAgdaTypeCheckingSubstitute/Class.hs" 236)) in
--   the case where the variable shouldn't be used but we cannot use
--   noabsApp. Used in Apply.
lazyAbsApp :: Subst t a => Abs a -> t -> a

-- | Instantiate an abstraction that doesn't use its argument.
noabsApp :: Subst t a => Empty -> Abs a -> a
absBody :: Subst t a => Abs a -> a
mkAbs :: (Subst t a, Free a) => ArgName -> a -> Abs a
reAbs :: (Subst t 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 t 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 :: Subst Term a => Int -> (a -> Term -> Term) -> a -> Term -> Term
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Abstract.Name.QName

-- | 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 -> SplitTrees' a -> SplitTree' a

-- | Arg. no to split at.
[splitArg] :: SplitTree' a -> Arg Int

-- | Sub split trees.
[splitTrees] :: SplitTree' a -> SplitTrees' a

-- | 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) -> Maybe Int -> SplitTreeLabel a

-- | Nothing for root of split tree
[lblConstructorName] :: SplitTreeLabel a -> Maybe a
[lblSplitArg] :: SplitTreeLabel a -> Maybe (Arg Int)
[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 Data.Data.Data 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 GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a)
instance Data.Data.Data a => Data.Data.Data (Agda.TypeChecking.Coverage.SplitTree.SplitTree' a)
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 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)

-- | 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.Integer.Type.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' 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.Common.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.Abs 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.Tele 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.LevelAtom
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.
Fail :: 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.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 Data.Data.Data a => Data.Data.Data (Agda.TypeChecking.CompiledClause.CompiledClauses' a)
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 Data.Data.Data c => Data.Data.Data (Agda.TypeChecking.CompiledClause.Case 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 Data.Data.Data c => Data.Data.Data (Agda.TypeChecking.CompiledClause.WithArity c)
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 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 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)

-- | 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 Agda.Syntax.Internal.LevelAtom
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' 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.Common.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)

-- | 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
type HoleContent = HoleContent' Expr
type Patterns = [NamedArg Pattern]
type Pattern = Pattern' Expr
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 :: 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
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 -> [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 -> [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 -> [Expr] -> [Clause] -> RHS
RewriteRHS :: [(QName, Expr)] -> [ProblemEq] -> RHS -> WhereDeclarations -> RHS

-- | The QNames are the names of the generated with functions, one
--   for each Expr.
[rewriteExprs] :: RHS -> [(QName, Expr)]

-- | 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 SpineClause = Clause' SpineLHS
type Clause = Clause' LHS
data WhereDeclarations
WhereDecls :: Maybe ModuleName -> [Declaration] -> WhereDeclarations
[whereModule] :: WhereDeclarations -> Maybe ModuleName
[whereDecls] :: WhereDeclarations -> [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.
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]

-- | 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:
--   
--   
--   
- We would have to typecheck the type A several times.
--   
- If A contains a meta variable or hole, it would be
--   duplicated by such a translation.
--   
--   
--   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 -> [NamedArg BindName] -> Expr -> TypedBinding

-- | E.g. (let x = e) or (let open M).
TLet :: Range -> [LetBinding] -> TypedBinding

-- | A lambda binding is either domain free or typed.
data LamBinding

-- | . x or {x} or .x or {x = y}
DomainFree :: NamedArg BindName -> LamBinding

-- | . (xs:e) or {xs:e} or (let Ds)
DomainFull :: TypedBinding -> LamBinding
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 -> Expr -> 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. | LetGeneralize DefInfo
--   ArgInfo Expr
LetDeclaredVariable :: BindName -> LetBinding
data Pragma
OptionsPragma :: [String] -> Pragma

-- | ResolvedName is not UnknownName. Name can be ambiguous
--   e.g. for built-in constructors.
BuiltinPragma :: String -> ResolvedName -> Pragma

-- | Builtins that do not come with a definition, but declare a name for an
--   Agda concept.
BuiltinNoDefPragma :: String -> QName -> Pragma
RewritePragma :: QName -> Pragma
CompilePragma :: String -> 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
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
class GetDefInfo a
getDefInfo :: GetDefInfo a => a -> Maybe DefInfo
data Declaration

-- | Type signature (can be irrelevant, but not hidden).
--   
--   The fourth argument contains an optional assignment of polarities to
--   arguments.
Axiom :: Axiom -> DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> Expr -> Declaration

-- | First argument is set of generalizable variables used in the type.
Generalize :: Set QName -> DefInfo -> ArgInfo -> QName -> Expr -> Declaration

-- | record field
Field :: DefInfo -> QName -> Arg Expr -> Declaration

-- | primitive function
Primitive :: DefInfo -> QName -> Expr -> Declaration

-- | a bunch of mutually recursive definitions
Mutual :: MutualInfo -> [Declaration] -> Declaration
Section :: ModuleInfo -> 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 -> Expr -> Declaration

-- | the LamBindings are DomainFree and bind the parameters
--   of the datatype.
DataDef :: DefInfo -> QName -> UniverseCheck -> DataDefParams -> [Constructor] -> Declaration

-- | lone record signature
RecSig :: DefInfo -> QName -> GeneralizeTelescope -> Expr -> Declaration

-- | The LamBindings are DomainFree and bind the parameters
--   of the datatype. The Expr gives the constructor type telescope,
--   (x1 : A1)..(xn : An) -> Prop, and the optional name is the
--   constructor's name.
RecDef :: DefInfo -> QName -> UniverseCheck -> Maybe (Ranged Induction) -> Maybe HasEta -> Maybe QName -> DataDefParams -> Expr -> [Declaration] -> Declaration

-- | Only for highlighting purposes
PatternSynDef :: QName -> [Arg Name] -> Pattern' Void -> Declaration
UnquoteDecl :: MutualInfo -> [DefInfo] -> [QName] -> Expr -> Declaration
UnquoteDef :: [DefInfo] -> [QName] -> Expr -> Declaration

-- | scope annotation
ScopedDecl :: ScopeInfo -> [Declaration] -> Declaration
data ScopeCopyInfo
ScopeCopyInfo :: Ren ModuleName -> Ren QName -> ScopeCopyInfo
[renModules] :: ScopeCopyInfo -> Ren ModuleName
[renNames] :: ScopeCopyInfo -> Ren QName

-- | Renaming (generic).
type Ren a = [(a, a)]

-- | Is a type signature a postulate or a function signature?
data Axiom

-- | A function signature.
FunSig :: Axiom

-- | Not a function signature, i.e., a postulate (in user input) or another
--   (e.g. data/record) type signature (internally).
NoFunSig :: Axiom
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.
Def :: QName -> Expr

-- | Projection (overloaded).
Proj :: ProjOrigin -> AmbiguousQName -> Expr

-- | Constructor (overloaded).
Con :: AmbiguousQName -> Expr

-- | Pattern synonym.
PatternSyn :: AmbiguousQName -> Expr

-- | Macro.
Macro :: QName -> Expr

-- | Literal.
Lit :: 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 -> QName -> [Clause] -> Expr

-- | Dependent function space Γ → A.
Pi :: ExprInfo -> Telescope -> Expr -> Expr

-- | Like a Pi, but the ordering is not known
Generalized :: Set QName -> Expr -> Expr

-- | Non-dependent function space.
Fun :: ExprInfo -> Arg Expr -> Expr -> Expr

-- | Set, Set1, Set2, ...
Set :: ExprInfo -> Integer -> Expr

-- | Prop, Prop1, Prop2, ...
Prop :: ExprInfo -> Integer -> Expr

-- | let bs in e.
Let :: ExprInfo -> [LetBinding] -> Expr -> Expr

-- | Only used when printing telescopes.
ETel :: Telescope -> Expr

-- | Record construction.
Rec :: ExprInfo -> RecordAssigns -> Expr

-- | Record update.
RecUpdate :: ExprInfo -> Expr -> Assigns -> Expr

-- | Scope annotation.
ScopedExpr :: ScopeInfo -> Expr -> Expr

-- | Binds Name to current type in Expr.
QuoteGoal :: ExprInfo -> Name -> Expr -> Expr

-- | Returns the current context.
QuoteContext :: ExprInfo -> Expr

-- | Quote an identifier QName.
Quote :: ExprInfo -> Expr

-- | Quote a term.
QuoteTerm :: ExprInfo -> Expr

-- | The splicing construct: unquote ...
Unquote :: ExprInfo -> Expr

-- | 
--   tactic e x1 .. xn | y1 | .. | yn
--   
Tactic :: ExprInfo -> Expr -> [NamedArg Expr] -> [NamedArg Expr] -> Expr

-- | For printing DontCare from Syntax.Internal.
DontCare :: Expr -> 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

-- | Smart constructor for Generalized
generalized :: Set QName -> Expr -> Expr
initCopyInfo :: ScopeCopyInfo
noDataDefParams :: DataDefParams
noWhereDecls :: WhereDeclarations
class SubstExpr a
substExpr :: SubstExpr a => [(Name, Expr)] -> a -> a
type PatternSynDefns = Map QName PatternSynDefn
type PatternSynDefn = ([Arg Name], Pattern' Void)
class NameToExpr a
nameExpr :: 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

-- | Extracts all the names which are declared in a Declaration.
--   This does not include open public or let expressions, but it does
--   include local modules, where clauses and the names of extended
--   lambdas.
class AllNames a
allNames :: AllNames a => a -> Seq QName

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

-- | Check whether a name is the empty name "_".
class IsNoName a
isNoName :: IsNoName a => a -> Bool

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

-- | 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 :: NonemptyList QName -> AmbiguousQName
[unAmbQ] :: AmbiguousQName -> NonemptyList 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 -> Range -> Fixity' -> Bool -> Name
[nameId] :: Name -> !NameId
[nameConcrete] :: Name -> Name
[nameBindingSite] :: Name -> Range
[nameFixity] :: Name -> Fixity'
[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:
--   
--   
--   
- C: noRange.
--   
- D: the range of A.
--   
- E: the range of B.
--   
--   
--   Precondition: The number of module name name parts has to be at least
--   as large as the length of the list.
withRangesOf :: ModuleName -> [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
noModuleName :: ModuleName
commonParentModule :: ModuleName -> ModuleName -> ModuleName
qnameToList :: QName -> [Name]
qnameFromList :: [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

-- | Computes the TopLevelModuleName corresponding to the given
--   module name, which is assumed to represent a top-level module name.
--   
--   Precondition: The module name must be well-formed.
toTopLevelModuleName :: ModuleName -> TopLevelModuleName
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
isSubModuleOf :: 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 :: Name -> Name
sameRoot :: Name -> Name -> Bool
instance Agda.Syntax.Abstract.SubstExpr a => Agda.Syntax.Abstract.SubstExpr [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 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.Assign
instance Agda.Syntax.Abstract.SubstExpr Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Abstract.SubstExpr Agda.Syntax.Abstract.LetBinding
instance Agda.Syntax.Abstract.SubstExpr Agda.Syntax.Abstract.TypedBinding
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.Abstract.AllNames a => Agda.Syntax.Abstract.AllNames [a]
instance Agda.Syntax.Abstract.AllNames a => Agda.Syntax.Abstract.AllNames (GHC.Maybe.Maybe a)
instance Agda.Syntax.Abstract.AllNames a => Agda.Syntax.Abstract.AllNames (Agda.Syntax.Common.Arg a)
instance Agda.Syntax.Abstract.AllNames a => Agda.Syntax.Abstract.AllNames (Agda.Syntax.Common.Named name a)
instance (Agda.Syntax.Abstract.AllNames a, Agda.Syntax.Abstract.AllNames b) => Agda.Syntax.Abstract.AllNames (a, b)
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.Name.QName
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.Declaration
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.Clause
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.RHS
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.WhereDeclarations
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.LamBinding
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.TypedBinding
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.LetBinding
instance Agda.Syntax.Abstract.AllNames Agda.Syntax.Abstract.ModuleApplication
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Expr)
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.BindName)
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.LHSCore)
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Info.ModuleInfo
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.Name.ModuleName
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.Declaration
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration (Agda.Syntax.Abstract.Pattern' Data.Void.Void)
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.Pattern
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.TypedBinding
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.LamBinding
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.LetBinding
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.Expr
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.Name.AmbiguousQName
instance Data.Generics.Geniplate.UniverseBi Agda.Syntax.Abstract.Declaration Agda.Syntax.Abstract.Name.QName
instance GHC.Classes.Eq Agda.Syntax.Abstract.SpineLHS
instance GHC.Show.Show Agda.Syntax.Abstract.SpineLHS
instance Data.Data.Data Agda.Syntax.Abstract.SpineLHS
instance GHC.Show.Show Agda.Syntax.Abstract.ProblemEq
instance Data.Data.Data Agda.Syntax.Abstract.ProblemEq
instance GHC.Classes.Eq Agda.Syntax.Abstract.Pragma
instance GHC.Show.Show Agda.Syntax.Abstract.Pragma
instance Data.Data.Data Agda.Syntax.Abstract.Pragma
instance GHC.Classes.Eq Agda.Syntax.Abstract.GeneralizeTelescope
instance GHC.Show.Show Agda.Syntax.Abstract.GeneralizeTelescope
instance Data.Data.Data Agda.Syntax.Abstract.GeneralizeTelescope
instance GHC.Classes.Eq Agda.Syntax.Abstract.ModuleApplication
instance GHC.Show.Show Agda.Syntax.Abstract.ModuleApplication
instance Data.Data.Data Agda.Syntax.Abstract.ModuleApplication
instance GHC.Classes.Eq Agda.Syntax.Abstract.LetBinding
instance GHC.Show.Show Agda.Syntax.Abstract.LetBinding
instance Data.Data.Data Agda.Syntax.Abstract.LetBinding
instance GHC.Classes.Eq Agda.Syntax.Abstract.TypedBinding
instance GHC.Show.Show Agda.Syntax.Abstract.TypedBinding
instance Data.Data.Data Agda.Syntax.Abstract.TypedBinding
instance GHC.Classes.Eq Agda.Syntax.Abstract.LamBinding
instance GHC.Show.Show Agda.Syntax.Abstract.LamBinding
instance Data.Data.Data Agda.Syntax.Abstract.LamBinding
instance GHC.Classes.Eq Agda.Syntax.Abstract.DataDefParams
instance GHC.Show.Show Agda.Syntax.Abstract.DataDefParams
instance Data.Data.Data Agda.Syntax.Abstract.DataDefParams
instance GHC.Show.Show Agda.Syntax.Abstract.Declaration
instance Data.Data.Data Agda.Syntax.Abstract.Declaration
instance GHC.Classes.Eq Agda.Syntax.Abstract.WhereDeclarations
instance GHC.Show.Show Agda.Syntax.Abstract.WhereDeclarations
instance Data.Data.Data Agda.Syntax.Abstract.WhereDeclarations
instance GHC.Show.Show Agda.Syntax.Abstract.RHS
instance Data.Data.Data Agda.Syntax.Abstract.RHS
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 Data.Data.Data lhs => Data.Data.Data (Agda.Syntax.Abstract.Clause' lhs)
instance GHC.Show.Show Agda.Syntax.Abstract.LHS
instance Data.Data.Data Agda.Syntax.Abstract.LHS
instance GHC.Show.Show Agda.Syntax.Abstract.Expr
instance Data.Data.Data Agda.Syntax.Abstract.Expr
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 Data.Data.Data e => Data.Data.Data (Agda.Syntax.Abstract.LHSCore' 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 Data.Data.Data e => Data.Data.Data (Agda.Syntax.Abstract.Pattern' e)
instance Data.Data.Data Agda.Syntax.Abstract.ScopeCopyInfo
instance GHC.Show.Show Agda.Syntax.Abstract.ScopeCopyInfo
instance GHC.Classes.Eq Agda.Syntax.Abstract.ScopeCopyInfo
instance GHC.Show.Show Agda.Syntax.Abstract.Axiom
instance GHC.Classes.Ord Agda.Syntax.Abstract.Axiom
instance GHC.Classes.Eq Agda.Syntax.Abstract.Axiom
instance Data.Data.Data Agda.Syntax.Abstract.Axiom
instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.BindName
instance Agda.Syntax.Position.SetRange Agda.Syntax.Abstract.BindName
instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.BindName
instance Data.Data.Data Agda.Syntax.Abstract.BindName
instance GHC.Show.Show Agda.Syntax.Abstract.BindName
instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.SpineLHS
instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.SpineLHS
instance Agda.Syntax.Abstract.GetDefInfo Agda.Syntax.Abstract.Declaration
instance GHC.Classes.Eq Agda.Syntax.Abstract.ProblemEq
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 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 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.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 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 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 Agda.Utils.Pretty.Pretty Agda.Syntax.Abstract.ScopeCopyInfo
instance Agda.Syntax.Position.KillRange Agda.Syntax.Abstract.ScopeCopyInfo
instance GHC.Classes.Eq Agda.Syntax.Abstract.BindName
instance GHC.Classes.Ord Agda.Syntax.Abstract.BindName

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 i | b -> i
labelPatVars :: LabelPatVars a b i => a -> State [i] 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 i => b -> a
labelPatVars :: (LabelPatVars a b i, Traversable f, LabelPatVars a' b' i, f a' ~ a, f b' ~ b) => a -> State [i] 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 i, Traversable f, LabelPatVars a' b' i, f a' ~ a, f b' ~ b) => b -> a

-- | Augment pattern variables with their de Bruijn index.
numberPatVars :: LabelPatVars a b Int => Int -> Permutation -> a -> b
unnumberPatVars :: LabelPatVars a b i => b -> a
dbPatPerm :: [NamedArg DeBruijnPattern] -> Maybe Permutation

-- | Computes the permutation from the clause telescope to the pattern
--   variables.
--   
--   Use as fromMaybe (throwImpossible (Impossible
--   "srcfullAgdaSyntaxInternal/Pattern.hs" 131)) .
--   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 (throwImpossible (Impossible
--   "srcfullAgdaSyntaxInternal/Pattern.hs" 155)) .
--   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 x | p -> x

-- | Get the list of pattern variables annotated with modalities.
patternVarModalities :: PatternVarModalities p x => p -> [(x, Modality)]
instance Agda.Syntax.Internal.Pattern.PatternVarModalities a x => Agda.Syntax.Internal.Pattern.PatternVarModalities [a] x
instance Agda.Syntax.Internal.Pattern.PatternVarModalities a x => Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Common.Named s a) x
instance Agda.Syntax.Internal.Pattern.PatternVarModalities a x => Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Common.Arg a) x
instance Agda.Syntax.Internal.Pattern.PatternVarModalities a x => Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Internal.Elim' a) x
instance Agda.Syntax.Internal.Pattern.PatternVarModalities (Agda.Syntax.Internal.Pattern' x) 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 i => Agda.Syntax.Internal.Pattern.LabelPatVars (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b) i
instance Agda.Syntax.Internal.Pattern.LabelPatVars a b i => Agda.Syntax.Internal.Pattern.LabelPatVars (Agda.Syntax.Common.Named x a) (Agda.Syntax.Common.Named x b) i
instance Agda.Syntax.Internal.Pattern.LabelPatVars a b i => Agda.Syntax.Internal.Pattern.LabelPatVars [a] [b] i
instance Agda.Syntax.Internal.Pattern.LabelPatVars Agda.Syntax.Internal.Pattern Agda.Syntax.Internal.DeBruijnPattern GHC.Types.Int
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]

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

-- | Gather top-level AsPatterns to expose underlying pattern.
asView :: Pattern -> ([Name], Pattern)

-- | Check whether we are dealing with a universe.
isSet :: Expr -> Bool

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

-- | 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, Applicative m) => (Expr -> m Expr -> m Expr) -> a -> 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, Monoid m) => (Expr -> m) -> a -> m
traverseExpr :: (ExprLike a, Applicative m, Monad m) => (Expr -> m Expr) -> a -> m a
mapExpr :: ExprLike a => (Expr -> Expr) -> a -> a
instance GHC.Base.Functor Agda.Syntax.Abstract.Views.AppView'
instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Expr
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 (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 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.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.TypedBinding
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.Pattern' a)
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.WhereDeclarations
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.LHS
instance Agda.Syntax.Abstract.Views.ExprLike a => Agda.Syntax.Abstract.Views.ExprLike (Agda.Syntax.Abstract.LHSCore' a)
instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.SpineLHS
instance Agda.Syntax.Abstract.Views.ExprLike Agda.Syntax.Abstract.Declaration

-- | 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 :: NonemptyList 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 a p | p -> a

-- | Fold pattern.
foldrAPattern :: (APatternLike a p, Monoid m) => (Pattern' a -> m -> m) -> p -> m

-- | Fold pattern.
foldrAPattern :: (APatternLike a p, Monoid m, Foldable f, APatternLike a b, f b ~ p) => (Pattern' a -> m -> m) -> p -> m

-- | Traverse pattern.
traverseAPatternM :: (APatternLike a p, Monad m) => (Pattern' a -> m (Pattern' a)) -> (Pattern' a -> m (Pattern' a)) -> p -> m p

-- | Traverse pattern.
traverseAPatternM :: (APatternLike a p, Traversable f, APatternLike a q, f q ~ p, Monad m) => (Pattern' a -> m (Pattern' a)) -> (Pattern' a -> m (Pattern' a)) -> p -> m p

-- | Compute from each subpattern a value and collect them all in a monoid.
foldAPattern :: (APatternLike a p, Monoid m) => (Pattern' a -> m) -> p -> m

-- | Traverse pattern(s) with a modification before the recursive descent.
preTraverseAPatternM :: (APatternLike a b, Monad m) => (Pattern' a -> m (Pattern' a)) -> b -> m b

-- | Traverse pattern(s) with a modification after the recursive descent.
postTraverseAPatternM :: (APatternLike a b, Monad m) => (Pattern' a -> m (Pattern' a)) -> b -> m b

-- | Map pattern(s) with a modification after the recursive descent.
mapAPattern :: APatternLike a p => (Pattern' a -> Pattern' a) -> p -> p

-- | Collect pattern variables in left-to-right textual order.
patternVars :: forall a p. APatternLike a p => p -> [Name]

-- | Check if a pattern contains a specific (sub)pattern.
containsAPattern :: APatternLike a p => (Pattern' a -> Bool) -> p -> Bool

-- | Check if a pattern contains an absurd pattern. For instance, suc
--   (), does so.
--   
--   Precondition: contains no pattern synonyms.
containsAbsurdPattern :: APatternLike a p => p -> Bool

-- | Check if a pattern contains an @-pattern.
--   
--   Precondition: contains no pattern synonyms.
containsAsPattern :: APatternLike a 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 a 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 -> [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 a (Agda.Syntax.Abstract.Pattern' a)
instance Agda.Syntax.Abstract.Pattern.APatternLike a b => Agda.Syntax.Abstract.Pattern.APatternLike a (Agda.Syntax.Common.Arg b)
instance Agda.Syntax.Abstract.Pattern.APatternLike a b => Agda.Syntax.Abstract.Pattern.APatternLike a (Agda.Syntax.Common.Named n b)
instance Agda.Syntax.Abstract.Pattern.APatternLike a b => Agda.Syntax.Abstract.Pattern.APatternLike a [b]
instance Agda.Syntax.Abstract.Pattern.APatternLike a b => Agda.Syntax.Abstract.Pattern.APatternLike a (GHC.Maybe.Maybe b)
instance Agda.Syntax.Abstract.Pattern.APatternLike a b => Agda.Syntax.Abstract.Pattern.APatternLike a (Agda.Syntax.Concrete.FieldAssignment' b)
instance (Agda.Syntax.Abstract.Pattern.APatternLike a b, Agda.Syntax.Abstract.Pattern.APatternLike a c) => Agda.Syntax.Abstract.Pattern.APatternLike a (b, c)
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 -> *) -> *) (n :: l) (as :: [k]) :: l
type family Map (f :: Function k l -> *) (as :: [k]) :: [l]
data ConsMap0 :: (Function k l -> *) -> Function k (Function [l] [l] -> *) -> *
data ConsMap1 :: (Function k l -> *) -> k -> Function [l] [l] -> *
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 :: [*]) (r :: *) = Foldr (->) r as
type Products (as :: [*]) = Foldr (,) () as

-- | IsBase t is 'True whenever t is *not* a
--   function space.
type family IsBase (t :: *) :: 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 family Domains' (t :: *) :: [*]
type family CoDomain (t :: *) :: *
type family CoDomain' (t :: *) :: *

-- | 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 :: * -> * -> *
data Constant0 :: Function a (Function b a -> *) -> *
data Constant1 :: * -> Function b a -> *
type family Apply (t :: Function k l -> *) (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 Change monad.
data Change 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 = a -> Change a

-- | Replace result of updating with original input if nothing has changed.
sharing :: Updater a -> Updater a

-- | Blindly run an updater.
runUpdater :: Updater a -> a -> (a, Bool)

-- | Mark a computation as dirty.
dirty :: Updater a
ifDirty :: 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 GHC.Base.Monad Agda.Utils.Update.Change
instance GHC.Base.Applicative Agda.Utils.Update.Change
instance GHC.Base.Functor Agda.Utils.Update.Change
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 Agda.Utils.Update.MonadChange Agda.Utils.Update.Change
instance GHC.Base.Monad m => Agda.Utils.Update.MonadChange (Agda.Utils.Update.ChangeT m)
instance Agda.Utils.Update.MonadChange Data.Functor.Identity.Identity

-- | Preprocess Declarations, producing NiceDeclarations.
--   
--   
--   
- Attach fixity and syntax declarations to the definition they refer
--   to.
--   
- Distribute the following attributes to the individual definitions:
--   abstract, instance, postulate,
--   primitive, private, termination pragmas.
--   
- Gather the function clauses belonging to one function
--   definition.
--   
- Expand ellipsis ... in function clauses following
--   with.
--   
- Infer mutual blocks. A block starts when a lone signature is
--   encountered, and ends when all lone signatures have seen their
--   definition.
--   
- Report basic well-formedness error, when one of the above
--   transformation fails. When possible, errors should be deferred to the
--   scope checking phase (ConcreteToAbstract), where we are in the TCM and
--   can produce more informative error messages.
--   
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 -> Name -> Arg Expr -> NiceDeclaration
PrimitiveFunction :: Range -> Access -> IsAbstract -> Name -> Expr -> NiceDeclaration
NiceMutual :: Range -> TerminationCheck -> 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 -> Catchall -> Declaration -> NiceDeclaration
FunSig :: Range -> Access -> IsAbstract -> IsInstance -> IsMacro -> ArgInfo -> TerminationCheck -> 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 -> Name -> [Clause] -> NiceDeclaration
NiceDataDef :: Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> [LamBinding] -> [NiceConstructor] -> NiceDeclaration
NiceRecDef :: Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> Name -> Maybe (Ranged Induction) -> Maybe HasEta -> Maybe (Name, IsInstance) -> [LamBinding] -> [Declaration] -> NiceDeclaration
NicePatternSyn :: Range -> Name -> [Arg Name] -> Pattern -> NiceDeclaration
NiceGeneralize :: Range -> Access -> ArgInfo -> Name -> Expr -> NiceDeclaration
NiceUnquoteDecl :: Range -> Access -> IsAbstract -> IsInstance -> TerminationCheck -> [Name] -> Expr -> NiceDeclaration
NiceUnquoteDef :: Range -> Access -> IsAbstract -> TerminationCheck -> [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

-- | The exception type.
data DeclarationException
MultipleEllipses :: Pattern -> DeclarationException
InvalidName :: Name -> DeclarationException
DuplicateDefinition :: Name -> DeclarationException
MissingWithClauses :: Name -> LHS -> DeclarationException
WrongDefinition :: Name -> DataRecOrFun -> DataRecOrFun -> DeclarationException
Codata :: Range -> DeclarationException
DeclarationPanic :: String -> DeclarationException
WrongContentBlock :: KindOfBlock -> Range -> DeclarationException

-- | in a mutual block, a clause could belong to any of the [Name]
--   type signatures
AmbiguousFunClauses :: LHS -> [Name] -> DeclarationException

-- | In a mutual block, all or none need a MEASURE pragma. Range is of
--   mutual block.
InvalidMeasureMutual :: Range -> DeclarationException
UnquoteDefRequiresSignature :: [Name] -> DeclarationException
BadMacroDef :: NiceDeclaration -> DeclarationException

-- | Non-fatal errors encountered in the Nicifier
data DeclarationWarning

-- | Empty abstract block.
EmptyAbstract :: 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 variable block.
EmptyGeneralize :: Range -> DeclarationWarning

-- | Empty primitive block.
EmptyPrimitive :: Range -> DeclarationWarning

-- | A {-# CATCHALL #-} pragma that does not precede a function clause.
InvalidCatchallPragma :: 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 {-# TERMINATING #-} and {-# NON_TERMINATING #-} pragma that does not
--   apply to any function.
InvalidTerminationCheckPragma :: Range -> DeclarationWarning
MissingDefinitions :: [Name] -> DeclarationWarning
NotAllowedInMutual :: Range -> String -> 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
UnknownFixityInMixfixDecl :: [Name] -> DeclarationWarning
UnknownNamesInFixityDecl :: [Name] -> DeclarationWarning
UnknownNamesInPolarityPragmas :: [Name] -> DeclarationWarning
UselessAbstract :: Range -> DeclarationWarning
UselessInstance :: Range -> DeclarationWarning
UselessPrivate :: Range -> DeclarationWarning

-- | 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 Control.Monad.Error.Class.MonadError Agda.Syntax.Concrete.Definitions.DeclarationException Agda.Syntax.Concrete.Definitions.Nice
instance Control.Monad.State.Class.MonadState Agda.Syntax.Concrete.Definitions.NiceEnv Agda.Syntax.Concrete.Definitions.Nice
instance GHC.Base.Monad Agda.Syntax.Concrete.Definitions.Nice
instance GHC.Base.Applicative Agda.Syntax.Concrete.Definitions.Nice
instance GHC.Base.Functor Agda.Syntax.Concrete.Definitions.Nice
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.DeclarationException
instance Data.Data.Data Agda.Syntax.Concrete.Definitions.DeclarationException
instance Data.Data.Data Agda.Syntax.Concrete.Definitions.DataRecOrFun
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.InMutual
instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.InMutual
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.KindOfBlock
instance GHC.Classes.Ord Agda.Syntax.Concrete.Definitions.KindOfBlock
instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.KindOfBlock
instance Data.Data.Data Agda.Syntax.Concrete.Definitions.KindOfBlock
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.DeclarationWarning
instance Data.Data.Data Agda.Syntax.Concrete.Definitions.DeclarationWarning
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.NiceDeclaration
instance Data.Data.Data Agda.Syntax.Concrete.Definitions.NiceDeclaration
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.Clause
instance Data.Data.Data Agda.Syntax.Concrete.Definitions.Clause
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.NiceDeclaration
instance Agda.Syntax.Concrete.Definitions.MakePrivate Agda.Syntax.Concrete.Definitions.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.NiceDeclaration
instance Agda.Syntax.Concrete.Definitions.MakeAbstract Agda.Syntax.Concrete.Definitions.Clause
instance Agda.Syntax.Concrete.Definitions.MakeAbstract Agda.Syntax.Concrete.WhereClause
instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.DeclarationException
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.DeclarationException
instance GHC.Classes.Eq Agda.Syntax.Concrete.Definitions.DataRecOrFun
instance GHC.Show.Show Agda.Syntax.Concrete.Definitions.DataRecOrFun
instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.DeclarationWarning
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.DeclarationWarning
instance Agda.Syntax.Position.HasRange Agda.Syntax.Concrete.Definitions.NiceDeclaration
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Concrete.Definitions.NiceDeclaration

module Agda.Syntax.Parser

-- | Wrapped Parser type.
data Parser a
parse :: Parser a -> String -> PM a
parsePosString :: Parser a -> Position -> String -> PM a
parseFile :: Show a => Parser a -> AbsolutePath -> String -> PM (a, 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 :: AbsolutePath -> 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 :: !AbsolutePath -> [String] -> ParseError

-- | The file which the error concerns.
[errPath] :: ParseError -> !AbsolutePath
[errValidExts] :: ParseError -> [String]
ReadFileError :: !AbsolutePath -> IOError -> ParseError

-- | The file which the error concerns.
[errPath] :: ParseError -> !AbsolutePath
[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

-- | A monad for handling parse results
newtype PM a
PM :: ExceptT ParseError (StateT [ParseWarning] IO) a -> PM a
[unPM] :: PM a -> ExceptT ParseError (StateT [ParseWarning] IO) a
runPMIO :: MonadIO m => PM a -> m (Either ParseError a, [ParseWarning])
instance Control.Monad.IO.Class.MonadIO Agda.Syntax.Parser.PM
instance Control.Monad.Error.Class.MonadError Agda.Syntax.Parser.Monad.ParseError 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

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

-- | Computing the free variables of a term.
--   
--   This is the old version of 'Free', using IntSets for
--   the separate variable categories. We keep it as a specification.
--   
--   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))
--   
--   
--   
- Jason C. Reed, PhD thesis, page 106
--   
--   
--   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).
module Agda.TypeChecking.Free.Old

-- | Free variables of a term, (disjointly) partitioned into strongly and
--   and weakly rigid variables, flexible variables and irrelevant
--   variables.
data FreeVars
FV :: VarSet -> VarSet -> VarSet -> VarSet -> VarSet -> FreeVars

-- | Variables under only and at least one inductive constructor(s).
[stronglyRigidVars] :: FreeVars -> 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] :: FreeVars -> VarSet

-- | Ordinary rigid variables, e.g., in arguments of variables.
[weaklyRigidVars] :: FreeVars -> VarSet

-- | Variables occuring in arguments of metas. These are only potentially
--   free, depending how the meta variable is instantiated.
[flexibleVars] :: FreeVars -> VarSet

-- | Variables in irrelevant arguments and under a DontCare, i.e.,
--   in irrelevant positions.
[irrelevantVars] :: FreeVars -> VarSet
class Free a

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

-- | Doesn't go inside solved metas, but collects the variables from a
--   metavariable application X ts as flexibleVars.
freeVars :: Free a => a -> FreeVars
freeVarsIgnore :: Free a => IgnoreSorts -> a -> FreeVars

-- | allVars fv includes irrelevant variables.
allVars :: FreeVars -> VarSet

-- | All but the irrelevant variables.
relevantVars :: FreeVars -> VarSet

-- | Rigid variables: either strongly rigid, unguarded, or weakly rigid.
rigidVars :: FreeVars -> VarSet
freeIn :: Free a => Nat -> a -> Bool

-- | Is the variable bound by the abstraction actually used?
isBinderUsed :: Free a => Abs a -> Bool
freeInIgnoringSorts :: Free a => Nat -> a -> Bool
freeInIgnoringSortAnn :: Free a => Nat -> a -> Bool
relevantIn :: Free a => Nat -> a -> Bool
relevantInIgnoringSortAnn :: Free a => Nat -> a -> Bool
data Occurrence
NoOccurrence :: Occurrence
Irrelevantly :: Occurrence

-- | Under at least one and only inductive constructors.
StronglyRigid :: Occurrence

-- | In top position, or only under inductive record constructors.
Unguarded :: Occurrence

-- | In arguments to variables and definitions.
WeaklyRigid :: Occurrence

-- | In arguments of metas.
Flexible :: Occurrence
occurrence :: Nat -> FreeVars -> Occurrence
instance GHC.Show.Show Agda.TypeChecking.Free.Old.IgnoreSorts
instance GHC.Classes.Eq Agda.TypeChecking.Free.Old.IgnoreSorts
instance GHC.Show.Show Agda.TypeChecking.Free.Old.Occurrence
instance GHC.Classes.Eq Agda.TypeChecking.Free.Old.Occurrence
instance GHC.Show.Show Agda.TypeChecking.Free.Old.FreeVars
instance GHC.Classes.Eq Agda.TypeChecking.Free.Old.FreeVars
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.Sort
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.Level
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.LevelAtom
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free [a]
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free (GHC.Maybe.Maybe a)
instance (Agda.TypeChecking.Free.Old.Free a, Agda.TypeChecking.Free.Old.Free b) => Agda.TypeChecking.Free.Old.Free (a, b)
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free (Agda.Syntax.Internal.Elim' a)
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free (Agda.Syntax.Common.Arg a)
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free (Agda.Syntax.Common.Dom a)
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free (Agda.Syntax.Internal.Abs a)
instance Agda.TypeChecking.Free.Old.Free a => Agda.TypeChecking.Free.Old.Free (Agda.Syntax.Internal.Tele a)
instance Agda.TypeChecking.Free.Old.Free Agda.Syntax.Internal.Clause
instance GHC.Base.Semigroup Agda.TypeChecking.Free.Old.FreeT
instance GHC.Base.Monoid Agda.TypeChecking.Free.Old.FreeT
instance GHC.Base.Semigroup Agda.TypeChecking.Free.Old.FreeVars
instance GHC.Base.Monoid Agda.TypeChecking.Free.Old.FreeVars

-- | 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.Classes.Ord Agda.Utils.Warshall.Node
instance GHC.Classes.Eq Agda.Utils.Warshall.Node
instance GHC.Show.Show Agda.Utils.Warshall.Rigid
instance GHC.Classes.Ord Agda.Utils.Warshall.Rigid
instance GHC.Classes.Eq Agda.Utils.Warshall.Rigid
instance GHC.Classes.Eq Agda.Utils.Warshall.Weight
instance GHC.Show.Show Agda.Utils.Warshall.SizeExpr
instance (GHC.Show.Show a, GHC.Show.Show b, GHC.Show.Show c) => GHC.Show.Show (Agda.Utils.Warshall.LegendMatrix a b c)
instance GHC.Show.Show Agda.Utils.Warshall.Constraint
instance GHC.Show.Show Agda.Utils.Warshall.Node
instance GHC.Show.Show 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
Value :: Bool -> WithDefault
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)

module Agda.Utils.Zipper
class Zipper z where {
    type family Carrier z;
    type family 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 Data.Type.Equality.~ 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

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

-- | Get all include pathes for a list of libraries to use.
libraryIncludePaths :: Maybe FilePath -> [AgdaLibFile] -> [LibName] -> LibM [FilePath]

-- | A symbolic library name.
type LibName = String

-- | Throws Doc exceptions, still collects LibWarnings.
type LibM = ExceptT Doc (WriterT [LibWarning] IO)
data LibWarning
LibWarning :: LibPositionInfo -> LibWarning' -> LibWarning
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

-- | 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.LibError'
instance Data.Data.Data Agda.Interaction.Library.LibWarning
instance GHC.Show.Show Agda.Interaction.Library.LibWarning
instance Data.Data.Data Agda.Interaction.Library.LibPositionInfo
instance GHC.Show.Show Agda.Interaction.Library.LibPositionInfo
instance GHC.Show.Show Agda.Interaction.Library.VersionView
instance GHC.Classes.Eq Agda.Interaction.Library.VersionView
instance GHC.Show.Show Agda.Interaction.Library.LibrariesFile
instance Agda.Utils.Pretty.Pretty Agda.Interaction.Library.LibWarning
instance Agda.Utils.Pretty.Pretty Agda.Interaction.Library.Parse.LibWarning'

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

module Agda.Interaction.Options
data CommandLineOptions
Options :: String -> Maybe FilePath -> [FilePath] -> [AbsolutePath] -> [LibName] -> Maybe FilePath -> Bool -> Bool -> Bool -> Maybe Help -> Bool -> Bool -> Bool -> Bool -> Maybe FilePath -> Bool -> Bool -> Bool -> HtmlHighlight -> Maybe FilePath -> FilePath -> FilePath -> Maybe FilePath -> Bool -> Bool -> Bool -> PragmaOptions -> Bool -> CommandLineOptions
[optProgramName] :: CommandLineOptions -> String
[optInputFile] :: CommandLineOptions -> Maybe FilePath
[optIncludePaths] :: CommandLineOptions -> [FilePath]
[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
[optShowVersion] :: CommandLineOptions -> Bool
[optShowHelp] :: CommandLineOptions -> Maybe Help
[optInteractive] :: CommandLineOptions -> Bool
[optGHCiInteraction] :: CommandLineOptions -> Bool
[optJSONInteraction] :: CommandLineOptions -> Bool
[optOptimSmashing] :: CommandLineOptions -> Bool

-- | In the absence of a path the project root is used.
[optCompileDir] :: CommandLineOptions -> Maybe FilePath
[optGenerateVimFile] :: CommandLineOptions -> Bool
[optGenerateLaTeX] :: CommandLineOptions -> Bool
[optGenerateHTML] :: CommandLineOptions -> Bool
[optHTMLHighlight] :: CommandLineOptions -> HtmlHighlight
[optDependencyGraph] :: CommandLineOptions -> Maybe FilePath
[optLaTeXDir] :: CommandLineOptions -> FilePath
[optHTMLDir] :: CommandLineOptions -> FilePath
[optCSSFile] :: CommandLineOptions -> Maybe FilePath
[optIgnoreInterfaces] :: CommandLineOptions -> Bool
[optIgnoreAllInterfaces] :: CommandLineOptions -> Bool
[optForcing] :: CommandLineOptions -> Bool
[optPragmaOptions] :: CommandLineOptions -> PragmaOptions

-- | Should the top-level module only be scope-checked, and not
--   type-checked?
[optOnlyScopeChecking] :: CommandLineOptions -> Bool

-- | Options which can be set in a pragma.
data PragmaOptions
PragmaOptions :: Bool -> Bool -> Bool -> Verbosity -> Bool -> Bool -> Bool -> Bool -> CutOff -> Bool -> Bool -> Bool -> WithDefault  'True -> WithDefault  'True -> Bool -> Bool -> Bool -> Bool -> WithDefault  'False -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Int -> Bool -> Int -> Bool -> Bool -> Bool -> WarningMode -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> PragmaOptions
[optShowImplicit] :: PragmaOptions -> Bool
[optShowIrrelevant] :: PragmaOptions -> Bool
[optUseUnicode] :: PragmaOptions -> Bool
[optVerbose] :: PragmaOptions -> Verbosity
[optProp] :: PragmaOptions -> Bool
[optAllowUnsolved] :: PragmaOptions -> Bool
[optDisablePositivity] :: PragmaOptions -> Bool
[optTerminationCheck] :: PragmaOptions -> Bool

-- | Cut off structural order comparison at some depth in termination
--   checker?
[optTerminationDepth] :: PragmaOptions -> CutOff
[optCompletenessCheck] :: PragmaOptions -> Bool
[optUniverseCheck] :: PragmaOptions -> Bool
[optOmegaInOmega] :: PragmaOptions -> Bool
[optSizedTypes] :: PragmaOptions -> WithDefault  'True
[optGuardedness] :: PragmaOptions -> WithDefault  'True
[optInjectiveTypeConstructors] :: PragmaOptions -> Bool
[optUniversePolymorphism] :: PragmaOptions -> Bool
[optIrrelevantProjections] :: PragmaOptions -> Bool

-- | irrelevant levels, irrelevant data matching
[optExperimentalIrrelevance] :: PragmaOptions -> Bool
[optWithoutK] :: 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

-- | Can rewrite rules be added and used?
[optRewriting] :: PragmaOptions -> Bool
[optCubical] :: PragmaOptions -> Bool

-- | Should system generated projections ProjSystem be printed
--   postfix (True) or prefix (False).
[optPostfixProjections] :: PragmaOptions -> Bool
[optInstanceSearchDepth] :: PragmaOptions -> Int
[optOverlappingInstances] :: PragmaOptions -> Bool
[optInversionMaxDepth] :: PragmaOptions -> Int
[optSafe] :: PragmaOptions -> Bool
[optDoubleCheck] :: PragmaOptions -> Bool

-- | Should conversion checker use syntactic equality shortcut?
[optSyntacticEquality] :: PragmaOptions -> Bool
[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

-- | 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 = ExceptT String IO
runOptM :: OptM a -> IO (Either String a)

-- | Each OptDescr describes a single option.
--   
--   The arguments to Option are:
--   
--   
--   
- list of short option characters
--   
- list of long option strings (without "--")
--   
- argument descriptor
--   
- explanation of option for user
--   
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
type Verbosity = Trie String Int
data HtmlHighlight
HighlightAll :: HtmlHighlight
HighlightCode :: HtmlHighlight
HighlightAuto :: HtmlHighlight

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

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

-- | Removes RTS options from a list of options.
stripRTS :: [String] -> [String]
defaultOptions :: CommandLineOptions
defaultInteractionOptions :: PragmaOptions
defaultVerbosity :: Verbosity

-- | 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 :: PragmaOptions -> [String]

-- | If any these options have changed, then the file will be rechecked.
--   Boolean options are negated to mention non-default options, where
--   possible.
restartOptions :: [(PragmaOptions -> RestartCodomain, String)]

-- | An infective option is an option that if used in one module, must be
--   used in all modules that depend on this module.
infectiveOptions :: [(PragmaOptions -> Bool, String)]

-- | A coinfective option is an option that if used in one module, must be
--   used in all modules that this module depends on.
coinfectiveOptions :: [(PragmaOptions -> Bool, String)]
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

-- | Returns the absolute default lib dir. This directory is used to store
--   the Primitive.agda file.
defaultLibDir :: IO FilePath
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
instance GHC.Classes.Eq Agda.Interaction.Options.RestartCodomain
instance GHC.Show.Show Agda.Interaction.Options.CommandLineOptions
instance GHC.Classes.Eq Agda.Interaction.Options.PragmaOptions
instance GHC.Show.Show Agda.Interaction.Options.PragmaOptions
instance GHC.Classes.Eq Agda.Interaction.Options.HtmlHighlight
instance GHC.Show.Show Agda.Interaction.Options.HtmlHighlight

module Agda.TypeChecking.Monad.Base
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
class Monad m => ReadTCState m
getTCState :: ReadTCState m => m TCState
withTCState :: ReadTCState m => (TCState -> TCState) -> m a -> m a
data PreScopeState
PreScopeState :: !CompressedFile -> !Signature -> !Set ModuleName -> !ModuleToSource -> !VisitedModules -> !ScopeInfo -> !PatternSynDefns -> !PatternSynDefns -> !Maybe (Set QName) -> !PragmaOptions -> !BuiltinThings PrimFun -> !DisplayForms -> !InstanceTable -> !Map BackendName [ForeignCode] -> !InteractionId -> !Map QName String -> !Map QName String -> PreScopeState

-- | Highlighting info for tokens (but not those tokens for which
--   highlighting exists in stSyntaxInfo).
[stPreTokens] :: PreScopeState -> !CompressedFile

-- | Imported declared identifiers. Those most not be serialized!
[stPreImports] :: PreScopeState -> !Signature
[stPreImportedModules] :: PreScopeState -> !Set ModuleName
[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 String

-- | Locally defined UserWarnings, to be stored in the
--   Interface
[stPreLocalUserWarnings] :: PreScopeState -> !Map QName String
type DisambiguatedNames = IntMap QName
data PostScopeState
PostScopeState :: !CompressedFile -> !DisambiguatedNames -> !MetaStore -> !InteractionPoints -> !Constraints -> !Constraints -> !Bool -> !Set QName -> !Signature -> !Map ModuleName CheckpointId -> !DisplayForms -> !Maybe ModuleName -> !TempInstanceTable -> !Map Name [Name] -> !Map Name [Name] -> !Statistics -> ![TCWarning] -> !Map MutualId MutualBlock -> !BuiltinThings PrimFun -> !MetaId -> !MutualId -> !ProblemId -> !CheckpointId -> !Int -> !NameId -> !Bool -> !Bool -> PostScopeState

-- | Highlighting info.
[stPostSyntaxInfo] :: PostScopeState -> !CompressedFile

-- | 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
[stPostMetaStore] :: PostScopeState -> !MetaStore
[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
[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 -> !Map Name [Name]

-- | Map keeping track of which names could maybe be shadowed by another
--   name
[stPostShadowingNames] :: PostScopeState -> !Map Name [Name]

-- | 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
[stPostConsideringInstance] :: PostScopeState -> !Bool

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

-- | A part of the state which is not reverted when an error is thrown or
--   the state is reset.
data PersistentTCState
PersistentTCSt :: DecodedModules -> CommandLineOptions -> InteractionOutputCallback -> !Benchmark -> !Statistics -> !Maybe LoadedFileCache -> [Backend] -> PersistentTCState
[stDecodedModules] :: PersistentTCState -> DecodedModules
[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.
[stLoadedFileCache] :: PersistentTCState -> !Maybe LoadedFileCache

-- | Current backends with their options
[stPersistBackends] :: PersistentTCState -> [Backend]
data LoadedFileCache
LoadedFileCache :: !CachedTypeCheckLog -> !CurrentTypeCheckLog -> LoadedFileCache
[lfcCached] :: LoadedFileCache -> !CachedTypeCheckLog
[lfcCurrent] :: LoadedFileCache -> !CurrentTypeCheckLog

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

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

-- | A complete log for a module will look like this:
--   
--   
--   
- Pragmas
--   
- EnterSection, entering the main module.
--   
- 'Decl'/'EnterSection'/'LeaveSection', for declarations and nested
--   modules
--   
- LeaveSection, leaving the main module.
--   
data TypeCheckAction
EnterSection :: !ModuleInfo -> !ModuleName -> !Telescope -> TypeCheckAction
LeaveSection :: !ModuleName -> TypeCheckAction

-- | Never a Section or ScopeDecl
Decl :: !Declaration -> TypeCheckAction
Pragmas :: !PragmaOptions -> TypeCheckAction

-- | Empty persistent state.
initPersistentState :: PersistentTCState

-- | Empty state of type checker.
initPreScopeState :: PreScopeState
initPostScopeState :: PostScopeState
initState :: TCState
stTokens :: Lens' CompressedFile TCState
stImports :: Lens' Signature TCState
stImportedModules :: Lens' (Set ModuleName) TCState
stModuleToSource :: Lens' ModuleToSource TCState
stVisitedModules :: Lens' VisitedModules TCState
stScope :: Lens' ScopeInfo TCState
stPatternSyns :: Lens' PatternSynDefns TCState
stPatternSynImports :: Lens' PatternSynDefns TCState
stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState
stPragmaOptions :: Lens' PragmaOptions TCState
stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState
stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState
stFreshInteractionId :: Lens' InteractionId TCState
stImportedUserWarnings :: Lens' (Map QName String) TCState
stLocalUserWarnings :: Lens' (Map QName String) TCState
getUserWarnings :: MonadTCState m => m (Map QName String)
stBackends :: Lens' [Backend] TCState
stFreshNameId :: Lens' NameId TCState
stSyntaxInfo :: Lens' CompressedFile TCState
stDisambiguatedNames :: Lens' DisambiguatedNames TCState
stMetaStore :: Lens' MetaStore TCState
stInteractionPoints :: Lens' InteractionPoints TCState
stAwakeConstraints :: Lens' Constraints TCState
stSleepingConstraints :: Lens' Constraints TCState
stDirty :: Lens' Bool TCState
stOccursCheckDefs :: Lens' (Set QName) TCState
stSignature :: Lens' Signature TCState
stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState
stImportsDisplayForms :: Lens' DisplayForms TCState
stImportedDisplayForms :: Lens' DisplayForms TCState
stCurrentModule :: Lens' (Maybe ModuleName) TCState
stImportedInstanceDefs :: Lens' InstanceTable TCState
stInstanceDefs :: Lens' TempInstanceTable TCState
stConcreteNames :: Lens' (Map Name [Name]) TCState
stShadowingNames :: Lens' (Map Name [Name]) 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
stConsideringInstance :: Lens' Bool TCState
stBuiltinThings :: TCState -> BuiltinThings PrimFun
class Enum i => HasFresh i
freshLens :: HasFresh i => Lens' i TCState
nextFresh' :: HasFresh i => i -> i
nextFresh :: HasFresh i => TCState -> (i, TCState)
fresh :: (HasFresh i, MonadTCState m) => m i
newtype ProblemId
ProblemId :: Nat -> ProblemId
newtype CheckpointId
CheckpointId :: Int -> CheckpointId
freshName :: MonadTCState m => Range -> String -> m Name
freshNoName :: MonadTCState m => Range -> m Name
freshNoName_ :: MonadTCState m => m Name
freshRecordName :: MonadTCState m => m Name

-- | Create a fresh name from a.
class FreshName a
freshName_ :: (FreshName a, MonadTCState m) => a -> m Name

-- | Maps top-level module names to the corresponding source file names.
type ModuleToSource = Map TopLevelModuleName AbsolutePath

-- | Maps source file names to the corresponding top-level module names.
type SourceToModule = Map AbsolutePath TopLevelModuleName

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

-- | Lookup an AbsolutePath in sourceToModule.
--   
--   O(n).
lookupModuleFromSource :: AbsolutePath -> TCM (Maybe TopLevelModuleName)
data ModuleInfo
ModuleInfo :: Interface -> Bool -> Bool -> ModuleInfo
[miInterface] :: ModuleInfo -> Interface

-- | True if warnings were encountered when the module was type
--   checked.
[miWarnings] :: ModuleInfo -> Bool

-- | True if the module is a primitive module, which should always
--   be importable.
[miPrimitive] :: ModuleInfo -> Bool
type VisitedModules = Map TopLevelModuleName ModuleInfo
type DecodedModules = Map TopLevelModuleName Interface
data ForeignCode
ForeignCode :: Range -> String -> ForeignCode
data Interface
Interface :: Hash -> Text -> FileType -> [(ModuleName, Hash)] -> ModuleName -> Map ModuleName Scope -> ScopeInfo -> Signature -> DisplayForms -> Map QName String -> BuiltinThings (String, QName) -> Map BackendName [ForeignCode] -> HighlightingInfo -> [OptionsPragma] -> PragmaOptions -> PatternSynDefns -> [TCWarning] -> 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 -> [(ModuleName, Hash)]

-- | Module name of this interface.
[iModuleName] :: Interface -> ModuleName

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

-- | Display forms added for imported identifiers.
[iDisplayForms] :: Interface -> DisplayForms

-- | User warnings for imported identifiers
[iUserWarnings] :: Interface -> Map QName String
[iBuiltin] :: Interface -> BuiltinThings (String, QName)
[iForeignCode] :: Interface -> Map BackendName [ForeignCode]
[iHighlighting] :: Interface -> HighlightingInfo

-- | Pragma options set in the file.
[iPragmaOptions] :: 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]

-- | Combines the source hash and the (full) hashes of the imported
--   modules.
iFullHash :: Interface -> Hash
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
buildClosure :: a -> TCM (Closure a)
type Constraints = [ProblemConstraint]
data ProblemConstraint
PConstr :: Set ProblemId -> Closure Constraint -> ProblemConstraint
[constraintProblems] :: ProblemConstraint -> Set ProblemId
[theConstraint] :: ProblemConstraint -> Closure Constraint
data Constraint
ValueCmp :: Comparison -> Type -> Term -> Term -> Constraint
ValueCmpOnFace :: Comparison -> Term -> Type -> Term -> Term -> Constraint
ElimCmp :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> Constraint
TypeCmp :: Comparison -> Type -> Type -> Constraint

-- | the two types are for the error message only
TelCmp :: Type -> Type -> Comparison -> Telescope -> Telescope -> Constraint
SortCmp :: Comparison -> Sort -> Sort -> Constraint
LevelCmp :: Comparison -> Level -> Level -> Constraint
HasBiggerSort :: Sort -> Constraint
HasPTSRule :: Sort -> Abs Sort -> Constraint
UnBlock :: MetaId -> Constraint
Guarded :: Constraint -> ProblemId -> 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, the second one is the
--   meta on which the constraint may be blocked on and the third one is
--   the list of candidates (or Nothing if we haven’t determined the list
--   of candidates yet)
FindInstance :: MetaId -> Maybe MetaId -> Maybe [Candidate] -> Constraint
CheckFunDef :: Delayed -> DefInfo -> QName -> [Clause] -> Constraint

-- | First argument is computation and the others are hole and goal type
UnquoteTactic :: Maybe MetaId -> Term -> Term -> Type -> Constraint
data Comparison
CmpEq :: Comparison
CmpLeq :: Comparison

-- | An extension of Comparison to >=.
data CompareDirection
DirEq :: CompareDirection
DirLeq :: CompareDirection
DirGeq :: CompareDirection

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

-- | A thing tagged with the context it came from.
data Open a
OpenThing :: CheckpointId -> a -> Open a
[openThingCheckpoint] :: Open a -> CheckpointId
[openThing] :: Open a -> a

-- | Parametrized since it is used without MetaId when creating a new meta.
data Judgement a
HasType :: a -> Type -> Judgement a
[jMetaId] :: Judgement a -> a
[jMetaType] :: Judgement a -> Type
IsSort :: a -> Type -> Judgement a
[jMetaId] :: Judgement a -> a
[jMetaType] :: Judgement a -> Type
data DoGeneralize
YesGeneralize :: DoGeneralize
NoGeneralize :: DoGeneralize

-- | 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 MetaVariable
MetaVar :: MetaInfo -> MetaPriority -> Permutation -> Judgement MetaId -> MetaInstantiation -> Set Listener -> Frozen -> 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
data Listener
EtaExpand :: MetaId -> Listener
CheckConstraint :: Nat -> ProblemConstraint -> Listener

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

-- | solved by term (abstracted over some free variables)
InstV :: [Arg String] -> Term -> MetaInstantiation

-- | unsolved
Open :: MetaInstantiation

-- | open, to be instantiated by instance search
OpenInstance :: MetaInstantiation

-- | solution blocked by unsolved constraints
BlockedConst :: Term -> MetaInstantiation
PostponedTypeCheckingProblem :: Closure TypeCheckingProblem -> TCM Bool -> MetaInstantiation

-- | 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
data TypeCheckingProblem
CheckExpr :: Comparison -> Expr -> Type -> TypeCheckingProblem
CheckArgs :: ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> ([Maybe Range] -> Elims -> Type -> CheckedTarget -> TCM Term) -> TypeCheckingProblem
CheckProjAppToKnownPrincipalArg :: Comparison -> Expr -> ProjOrigin -> NonemptyList QName -> Args -> Type -> Int -> Term -> Type -> 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 ([WithHiding Name], Maybe Type) -> Expr -> Type -> TypeCheckingProblem

-- | Quote the given term and check type against Term
DoQuoteTerm :: Comparison -> Term -> Type -> TypeCheckingProblem

-- | 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 RunMetaOccursCheck
RunMetaOccursCheck :: RunMetaOccursCheck
DontRunMetaOccursCheck :: RunMetaOccursCheck

-- | MetaInfo is cloned from one meta to the next during pruning.
data MetaInfo
MetaInfo :: Closure Range -> RunMetaOccursCheck -> MetaNameSuggestion -> Arg DoGeneralize -> MetaInfo
[miClosRange] :: MetaInfo -> Closure Range

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

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

-- | For printing, we couple a meta with its name suggestion.
data NamedMeta
NamedMeta :: MetaNameSuggestion -> MetaId -> NamedMeta
[nmSuggestion] :: NamedMeta -> MetaNameSuggestion
[nmid] :: NamedMeta -> MetaId
type MetaStore = IntMap MetaVariable
normalMetaPriority :: MetaPriority
lowMetaPriority :: MetaPriority
highMetaPriority :: MetaPriority
getMetaInfo :: MetaVariable -> Closure Range
getMetaScope :: MetaVariable -> ScopeInfo
getMetaEnv :: MetaVariable -> TCEnv
getMetaSig :: MetaVariable -> Signature
getMetaRelevance :: MetaVariable -> Relevance
getMetaModality :: MetaVariable -> Modality
metaFrozen :: Lens' Frozen MetaVariable

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

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

-- | Which clause is an interaction point located in?
data IPClause
IPClause :: QName -> Int -> RHS -> IPClause

-- | The name of the function.
[ipcQName] :: IPClause -> QName

-- | The number of the clause of this function.
[ipcClauseNo] :: IPClause -> Int

-- | The original AST clause rhs.
[ipcClause] :: IPClause -> RHS

-- | The interaction point is not in the rhs of a clause.
IPNoClause :: IPClause
data Signature
Sig :: Sections -> Definitions -> RewriteRuleMap -> Signature
[_sigSections] :: Signature -> Sections
[_sigDefinitions] :: Signature -> Definitions

-- | The rewrite rules defined in this file.
[_sigRewriteRules] :: Signature -> RewriteRuleMap
sigSections :: Lens' Sections Signature
sigDefinitions :: Lens' Definitions Signature
sigRewriteRules :: Lens' RewriteRuleMap Signature
type Sections = Map ModuleName Section
type Definitions = HashMap QName Definition
type RewriteRuleMap = HashMap QName RewriteRules
type DisplayForms = HashMap QName [LocalDisplayForm]
newtype Section
Section :: Telescope -> Section
[_secTelescope] :: Section -> Telescope
secTelescope :: Lens' Telescope Section
emptySignature :: Signature

-- | A DisplayForm is in essence a rewrite rule  q ts -->
--   dt  for a defined symbol (could be a constructor as well)
--   q. The right hand side is a DisplayTerm which is used
--   to reify to a more readable Syntax.
--   
--   The patterns ts are just terms, but var 0 is
--   interpreted as a hole. Each occurrence of var 0 is a new hole
--   (pattern var). For each *occurrence* of var0 the rhs
--   dt has a free variable. These are instantiated when matching
--   a display form against a term q vs succeeds.
data DisplayForm
Display :: Nat -> Elims -> DisplayTerm -> DisplayForm

-- | Number n of free variables in dfRHS.
[dfFreeVars] :: DisplayForm -> Nat

-- | Left hand side patterns, where var 0 stands for a pattern
--   variable. There should be n occurrences of var0 in
--   dfPats. The ArgInfo is ignored in these patterns.
[dfPats] :: DisplayForm -> Elims

-- | Right hand side, with n free variables.
[dfRHS] :: DisplayForm -> DisplayTerm
type LocalDisplayForm = Open DisplayForm

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

-- | By default, we have no display form.
defaultDisplayForm :: QName -> [LocalDisplayForm]
defRelevance :: Definition -> Relevance

-- | 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 anything (e.g. irrelevant terms).
PWild :: 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 x es where x is a lambda-bound variable
PBoundVar :: {-# UNPACK #-} !Int -> PElims -> NLPat

-- | Matches the term modulo β (ideally βη).
PTerm :: Term -> NLPat
type PElims = [Elim' NLPat]
data NLPType
NLPType :: NLPat -> NLPat -> NLPType
[nlpTypeLevel] :: NLPType -> NLPat
[nlpTypeUnEl] :: NLPType -> NLPat
type RewriteRules = [RewriteRule]

-- | Rewrite rules can be added independently from function clauses.
data RewriteRule
RewriteRule :: QName -> Telescope -> QName -> PElims -> Term -> Type -> 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
data Definition
Defn :: ArgInfo -> QName -> Type -> [Polarity] -> [Occurrence] -> NumGeneralizableArgs -> [Maybe Name] -> [LocalDisplayForm] -> MutualId -> CompiledRepresentation -> Maybe QName -> Bool -> Bool -> Bool -> Bool -> Defn -> Definition

-- | Hiding should not be used.
[defArgInfo] :: Definition -> ArgInfo
[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

-- | Is the def matched against in a rewrite rule?
[defMatchable] :: Definition -> Bool

-- | 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
[theDef] :: Definition -> Defn
data NumGeneralizableArgs
NoGeneralizableArgs :: NumGeneralizableArgs

-- | When lambda-lifting new args are generalizable if
--   SomeGeneralizableArgs, also when the number is zero.
SomeGeneralizableArgs :: Int -> NumGeneralizableArgs
theDefLens :: Lens' Defn Definition

-- | Create a definition with sensible defaults.
defaultDefn :: ArgInfo -> QName -> Type -> Defn -> Definition

-- | Polarity for equality and subtype checking.
data Polarity

-- | monotone
Covariant :: Polarity

-- | antitone
Contravariant :: Polarity

-- | no information (mixed variance)
Invariant :: Polarity

-- | constant
Nonvariant :: Polarity

-- | Information about whether an argument is forced by the type of a
--   function.
data IsForced
Forced :: IsForced
NotForced :: IsForced

-- | The backends are responsible for parsing their own pragmas.
data CompilerPragma
CompilerPragma :: Range -> String -> CompilerPragma
type BackendName = String
jsBackendName :: BackendName
ghcBackendName :: BackendName
type CompiledRepresentation = Map BackendName [CompilerPragma]
noCompiledRep :: CompiledRepresentation
type Face = [(Term, Bool)]

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

-- | Additional information for extended lambdas.
data ExtLamInfo
ExtLamInfo :: ModuleName -> !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
[extLamSys] :: ExtLamInfo -> !Maybe System
modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo

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

-- | Abstractions to build projection function (dropping parameters).
newtype ProjLams
ProjLams :: [Arg ArgName] -> ProjLams
[getProjLams] :: ProjLams -> [Arg ArgName]

-- | Building the projection function (which drops the parameters).
projDropPars :: Projection -> ProjOrigin -> Term

-- | The info of the principal (record) argument.
projArgInfo :: Projection -> ArgInfo

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

-- | Make sure we do not overwrite a user specification.
setEtaEquality :: EtaEquality -> HasEta -> EtaEquality
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
data CompKit
CompKit :: Maybe QName -> Maybe QName -> CompKit
[nameOfHComp] :: CompKit -> Maybe QName
[nameOfTransp] :: CompKit -> Maybe QName
emptyCompKit :: CompKit
data Defn

-- | Postulate
Axiom :: Defn

-- | Data or record type signature that doesn't yet have a definition
DataOrRecSig :: Int -> Defn
[datarecPars] :: Defn -> Int

-- | Generalizable variable (introduced in generalize block)
GeneralizableVar :: Defn

-- | Returned by getConstInfo if definition is abstract.
AbstractDefn :: Defn -> Defn
Function :: [Clause] -> Maybe CompiledClauses -> Maybe SplitTree -> Maybe Compiled -> [Closure Clause] -> FunctionInverse -> Maybe [QName] -> IsAbstract -> Delayed -> Maybe Projection -> Set FunctionFlag -> Maybe Bool -> Maybe ExtLamInfo -> Maybe QName -> Bool -> Defn
[funClauses] :: Defn -> [Clause]

-- | Nothing while function is still type-checked. Just cc
--   after type and coverage checking and translation to case trees.
[funCompiled] :: Defn -> Maybe CompiledClauses

-- | The split tree constructed by the coverage checker. Needed to
--   re-compile the clauses after forcing translation.
[funSplitTree] :: Defn -> Maybe SplitTree

-- | Intermediate representation for compiler backends.
[funTreeless] :: Defn -> Maybe Compiled

-- | Covering clauses computed by coverage checking. Erased by (IApply)
--   confluence checking(?)
[funCovering] :: Defn -> [Closure Clause]
[funInv] :: Defn -> 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] :: Defn -> Maybe [QName]
[funAbstr] :: Defn -> IsAbstract

-- | Are the clauses of this definition delayed?
[funDelayed] :: Defn -> 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] :: Defn -> Maybe Projection
[funFlags] :: Defn -> Set FunctionFlag

-- | Has this function been termination checked? Did it pass?
[funTerminates] :: Defn -> 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] :: Defn -> Maybe ExtLamInfo

-- | Is this a generated with-function? If yes, then what's the name of the
--   parent function.
[funWith] :: Defn -> Maybe QName

-- | Is this a function defined by copatterns?
[funCopatternLHS] :: Defn -> Bool
Datatype :: Nat -> Nat -> Induction -> Maybe Clause -> [QName] -> Sort -> Maybe [QName] -> IsAbstract -> [QName] -> Defn

-- | Number of parameters.
[dataPars] :: Defn -> Nat

-- | Number of indices.
[dataIxs] :: Defn -> Nat

-- | data or codata (legacy).
[dataInduction] :: Defn -> Induction

-- | This might be in an instantiated module.
[dataClause] :: Defn -> Maybe Clause

-- | Constructor names , ordered according to the order of their
--   definition.
[dataCons] :: Defn -> [QName]
[dataSort] :: Defn -> 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] :: Defn -> Maybe [QName]
[dataAbstr] :: Defn -> IsAbstract

-- | Path constructor names (subset of dataCons)
[dataPathCons] :: Defn -> [QName]
Record :: Nat -> Maybe Clause -> ConHead -> Bool -> [Arg QName] -> Telescope -> Maybe [QName] -> EtaEquality -> Maybe Induction -> IsAbstract -> CompKit -> Defn

-- | Number of parameters.
[recPars] :: Defn -> 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] :: Defn -> Maybe Clause

-- | Constructor name and fields.
[recConHead] :: Defn -> ConHead

-- | Does this record have a constructor?
[recNamedCon] :: Defn -> Bool

-- | The record field names.
[recFields] :: Defn -> [Arg QName]

-- | The record field telescope. (Includes record parameters.) Note:
--   TelV recTel _ == telView' recConType. Thus, recTel
--   is redundant.
[recTel] :: Defn -> Telescope

-- | Mutually recursive functions, datas and records.
--   Does include this record. Empty if not recursive. Nothing if
--   not yet computed (by positivity checker).
[recMutual] :: Defn -> Maybe [QName]

-- | Eta-expand at this record type? False for unguarded recursive
--   records and coinductive records unless the user specifies otherwise.
[recEtaEquality'] :: Defn -> EtaEquality

-- | 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] :: Defn -> Maybe Induction
[recAbstr] :: Defn -> IsAbstract
[recComp] :: Defn -> CompKit
Constructor :: Int -> Int -> ConHead -> QName -> IsAbstract -> Induction -> (CompKit, Maybe [QName]) -> [IsForced] -> [Bool] -> Defn

-- | Number of parameters.
[conPars] :: Defn -> Int

-- | Number of arguments (excluding parameters).
[conArity] :: Defn -> Int

-- | Name of (original) constructor and fields. (This might be in a module
--   instance.)
[conSrcCon] :: Defn -> ConHead

-- | Name of datatype or record type.
[conData] :: Defn -> QName
[conAbstr] :: Defn -> IsAbstract

-- | Inductive or coinductive?
[conInd] :: Defn -> Induction

-- | (cubical composition, projections)
[conComp] :: Defn -> (CompKit, Maybe [QName])

-- | Which arguments are forced (i.e. determined by the type of the
--   constructor)?
[conForced] :: Defn -> [IsForced]

-- | Which arguments are erased at runtime (computed during compilation to
--   treeless)
[conErased] :: Defn -> [Bool]

-- | Primitive or builtin functions.
Primitive :: IsAbstract -> String -> [Clause] -> FunctionInverse -> Maybe CompiledClauses -> Defn
[primAbstr] :: Defn -> IsAbstract
[primName] :: Defn -> String

-- | null for primitive functions, not null for builtin
--   functions.
[primClauses] :: Defn -> [Clause]

-- | Builtin functions can have inverses. For instance, natural number
--   addition.
[primInv] :: Defn -> FunctionInverse

-- | Nothing for primitive functions, Just something
--   for builtin functions.
[primCompiled] :: Defn -> Maybe CompiledClauses

-- | Is the record type recursive?
recRecursive :: Defn -> Bool
recEtaEquality :: Defn -> HasEta

-- | A template for creating Function definitions, with sensible
--   defaults.
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]
newtype Fields
Fields :: [(Name, Type)] -> Fields

-- | 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
data Reduced no yes
NoReduction :: no -> Reduced no yes
YesReduction :: Simplification -> yes -> Reduced no yes

-- | Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not
--   blocked.
data IsReduced
NotReduced :: IsReduced
Reduced :: Blocked () -> IsReduced
data MaybeReduced a
MaybeRed :: IsReduced -> a -> MaybeReduced a
[isReduced] :: MaybeReduced a -> IsReduced
[ignoreReduced] :: MaybeReduced a -> a
type MaybeReducedArgs = [MaybeReduced (Arg Term)]
type MaybeReducedElims = [MaybeReduced Elim]
notReduced :: a -> MaybeReduced a
reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)

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

-- | Functions whose termination has not (yet) been confirmed.
UnconfirmedReductions :: AllowedReduction

-- | Functions that have failed termination checking.
NonTerminatingReductions :: AllowedReduction
type AllowedReductions = [AllowedReduction]

-- | Not quite all reductions (skip non-terminating reductions)
allReductions :: AllowedReductions
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)
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]
type FunctionInverse = FunctionInverse' Clause
type InversionMap c = Map TermHead [c]
data FunctionInverse' c
NotInjective :: FunctionInverse' c
Inverse :: InversionMap c -> FunctionInverse' c
data TermHead
SortHead :: TermHead
PiHead :: TermHead
ConsHead :: QName -> TermHead
VarHead :: Nat -> TermHead
UnknownHead :: TermHead
newtype MutualId
MutId :: Int32 -> MutualId
type Statistics = Map String Integer
data Call
CheckClause :: Type -> SpineClause -> Call
CheckPattern :: Pattern -> Telescope -> Type -> Call
CheckLetBinding :: LetBinding -> Call
InferExpr :: Expr -> Call
CheckExprCall :: Comparison -> Expr -> Type -> Call
CheckDotPattern :: Expr -> Term -> Call
CheckPatternShadowing :: SpineClause -> Call
CheckProjection :: Range -> QName -> Type -> Call
IsTypeCall :: Expr -> Sort -> Call
IsType_ :: Expr -> Call
InferVar :: Name -> Call
InferDef :: QName -> Call
CheckArguments :: Range -> [NamedArg Expr] -> Type -> Maybe Type -> 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
CheckFunDefCall :: Range -> QName -> [Clause] -> Call
CheckPragma :: Range -> Pragma -> Call
CheckPrimitive :: Range -> QName -> Expr -> Call
CheckIsEmpty :: Range -> Type -> Call
CheckWithFunctionType :: Type -> Call
CheckSectionApplication :: Range -> ModuleName -> ModuleApplication -> Call
CheckNamedWhere :: ModuleName -> 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

-- | The instance table is a Map associating to every name of
--   recorddata typepostulate its list of instances
type InstanceTable = Map QName (Set QName)

-- | When typechecking something of the following form:
--   
--   instance x : _ x = y
--   
--   it's not yet known where to add x, so we add it to a list of
--   unresolved instances and we'll deal with it later.
type TempInstanceTable = (InstanceTable, Set QName)
data BuiltinDescriptor
BuiltinData :: TCM Type -> [String] -> BuiltinDescriptor
BuiltinDataCons :: TCM Type -> BuiltinDescriptor
BuiltinPrim :: String -> (Term -> TCM ()) -> 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
data BuiltinInfo
BuiltinInfo :: String -> BuiltinDescriptor -> BuiltinInfo
[builtinName] :: BuiltinInfo -> String
[builtinDesc] :: BuiltinInfo -> BuiltinDescriptor
type BuiltinThings pf = Map String (Builtin pf)
data Builtin pf
Builtin :: Term -> Builtin pf
Prim :: pf -> Builtin pf

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

-- | ifTopLevelAndHighlightingLevelIs l b m runs m when
--   we're type-checking the top-level module and either the highlighting
--   level is at least l or b is True.
ifTopLevelAndHighlightingLevelIsOr :: MonadTCM tcm => HighlightingLevel -> Bool -> tcm () -> tcm ()

-- | ifTopLevelAndHighlightingLevelIs l m runs m when
--   we're type-checking the top-level module and the highlighting level is
--   at least l.
ifTopLevelAndHighlightingLevelIs :: MonadTCM tcm => HighlightingLevel -> tcm () -> tcm ()
data TCEnv
TCEnv :: Context -> LetBindings -> ModuleName -> Maybe AbsolutePath -> [(ModuleName, Nat)] -> [TopLevelModuleName] -> Maybe MutualId -> TerminationCheck () -> Bool -> Bool -> Bool -> Bool -> Set ProblemId -> AbstractMode -> Modality -> Bool -> Range -> Range -> IPClause -> Maybe (Closure Call) -> HighlightingLevel -> HighlightingMethod -> !Int -> ExpandHidden -> Maybe QName -> Simplification -> AllowedReductions -> Int -> Bool -> Bool -> Bool -> Bool -> UnquoteFlags -> !Int -> Bool -> [QName] -> Bool -> CheckpointId -> Map CheckpointId Substitution -> DoGeneralize -> Map QName GeneralizedValue -> Bool -> 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)]

-- | to detect import cycles
[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 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

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

-- | This number indicates how far away from the top-level module Agda has
--   come when chasing modules. The level of a given module is not
--   necessarily the same as the length, in the module dependency graph, of
--   the shortest path from the top-level module; it depends on in which
--   order Agda chooses to chase dependencies.
[envModuleNestingLevel] :: TCEnv -> !Int

-- | 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 debugging of
--   incomplete matches only.)
[envAppDef] :: TCEnv -> Maybe QName

-- | Did we encounter a simplification (proper match) during the current
--   reduction process?
[envSimplification] :: TCEnv -> Simplification
[envAllowedReductions] :: TCEnv -> AllowedReductions

-- | Injectivity can cause non-termination for unsolvable contraints
--   (3067). Keep a limit on the nesting depth of injectivity uses.
[envInjectivityDepth] :: TCEnv -> Int

-- | Can we compare blocked things during conversion? No by default. Yes
--   for rewriting feature.
[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

-- | Do we check that options in imported files are consistent with each
--   other?
[envCheckOptionConsistency] :: TCEnv -> Bool
initEnv :: TCEnv

-- | Project Relevance component of TCEnv.
envRelevance :: TCEnv -> Relevance
data UnquoteFlags
UnquoteFlags :: Bool -> UnquoteFlags
[_unquoteNormalise] :: UnquoteFlags -> Bool
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
eSolvingConstraints :: Lens' Bool TCEnv
eCheckingWhere :: Lens' Bool TCEnv
eWorkingOnTypes :: Lens' Bool TCEnv
eAssignMetas :: Lens' Bool TCEnv
eActiveProblems :: Lens' (Set ProblemId) TCEnv
eAbstractMode :: Lens' AbstractMode TCEnv
eModality :: Lens' Modality TCEnv
eRelevance :: Lens' Relevance TCEnv
eQuantity :: Lens' Quantity TCEnv
eDisplayFormsEnabled :: Lens' Bool TCEnv
eRange :: Lens' Range TCEnv
eHighlightingRange :: Lens' Range TCEnv
eCall :: Lens' (Maybe (Closure Call)) TCEnv
eHighlightingLevel :: Lens' HighlightingLevel TCEnv
eHighlightingMethod :: Lens' HighlightingMethod TCEnv
eModuleNestingLevel :: Lens' Int TCEnv
eExpandLast :: Lens' ExpandHidden TCEnv
eAppDef :: Lens' (Maybe QName) TCEnv
eSimplification :: Lens' Simplification TCEnv
eAllowedReductions :: Lens' AllowedReductions TCEnv
eInjectivityDepth :: Lens' Int TCEnv
eCompareBlocked :: Lens' Bool TCEnv
ePrintDomainFreePi :: Lens' Bool TCEnv
eInsideDotPattern :: Lens' Bool TCEnv
eUnquoteFlags :: Lens' UnquoteFlags TCEnv
eInstanceDepth :: Lens' Int TCEnv
eIsDebugPrinting :: Lens' Bool TCEnv
ePrintingPatternLambdas :: Lens' [QName] TCEnv
eCallByNeed :: Lens' Bool TCEnv
eCurrentCheckpoint :: Lens' CheckpointId TCEnv
eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv
eGeneralizeMetas :: Lens' DoGeneralize TCEnv
eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv

-- | The Context is a stack of ContextEntrys.
type Context = [ContextEntry]
type ContextEntry = Dom (Name, Type)
type LetBindings = Map Name (Open (Term, Dom Type))
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
aDefToMode :: IsAbstract -> AbstractMode
aModeToDef :: AbstractMode -> IsAbstract
data ExpandHidden

-- | Add implicit arguments in the end until type is no longer hidden
--   Pi.
ExpandLast :: ExpandHidden

-- | Do not append implicit arguments.
DontExpandLast :: ExpandHidden

-- | 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 :: Term -> Type -> Bool -> Candidate
[candidateTerm] :: Candidate -> Term
[candidateType] :: Candidate -> Type
[candidateOverlappable] :: Candidate -> Bool

-- | 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 :: QName -> [[NamedArg DeBruijnPattern]] -> 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

-- | 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 the user opens a module public before the module header. (See issue
--   #2377.)
UselessPublic :: 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. Generic warnings for one-off
--   things
InversionDepthReached :: QName -> Warning

-- | Harmless generic warning (not an error)
GenericWarning :: Doc -> Warning

-- | Generic error which doesn't abort proceedings (not a warning) Safe
--   flag errors
GenericNonFatalError :: Doc -> Warning
SafeFlagPostulate :: Name -> Warning
SafeFlagPragma :: [String] -> Warning
SafeFlagNonTerminating :: Warning
SafeFlagTerminating :: Warning
SafeFlagWithoutKFlagPrimEraseEquality :: Warning
WithoutKFlagPrimEraseEquality :: Warning
SafeFlagNoPositivityCheck :: Warning
SafeFlagPolarity :: Warning
SafeFlagNoUniverseCheck :: 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 :: String -> Warning

-- | Some imported names are not actually exported by the source module
ModuleDoesntExport :: QName -> [ImportedName] -> Warning

-- | Importing a file using an infective option into one which doesn't
InfectiveImport :: String -> ModuleName -> Warning

-- | Importing a file not using a coinfective option from one which does
CoInfectiveImport :: String -> ModuleName -> Warning
warningName :: Warning -> WarningName
data TCWarning
TCWarning :: Range -> Warning -> Doc -> Bool -> TCWarning

-- | 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
tcWarningOrigin :: TCWarning -> SrcFile
equalHeadConstructors :: Warning -> Warning -> Bool
getPartialDefs :: ReadTCState tcm => tcm [QName]

-- | Information about a call.
data CallInfo
CallInfo :: QName -> Range -> Closure Term -> CallInfo

-- | Target function name.
[callInfoTarget] :: CallInfo -> QName

-- | Range of the target function.
[callInfoRange] :: CallInfo -> Range

-- | To be formatted representation of the call.
[callInfoCall] :: CallInfo -> Closure Term

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

-- | Error when splitting a pattern variable into possible constructor
--   patterns.
data SplitError

-- | Neither data type nor record.
NotADatatype :: Closure Type -> SplitError

-- | Data type, but in irrelevant position.
IrrelevantDatatype :: Closure Type -> SplitError

-- | Data type, but in erased position.
ErasedDatatype :: Closure Type -> SplitError

-- | Split on codata not allowed. UNUSED, but keep! -- |
--   NoRecordConstructor Type -- ^ record type, but no constructor
CoinductiveDatatype :: Closure Type -> SplitError
UnificationStuck :: QName -> Telescope -> Args -> Args -> [UnificationFailure] -> SplitError

-- | 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
data NegativeUnification
UnifyConflict :: Telescope -> Term -> Term -> NegativeUnification
UnifyCycle :: Telescope -> Int -> Term -> NegativeUnification
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
data UnquoteError
BadVisibility :: String -> Arg Term -> UnquoteError
ConInsteadOfDef :: QName -> String -> String -> UnquoteError
DefInsteadOfCon :: QName -> String -> String -> UnquoteError
NonCanonical :: String -> Term -> UnquoteError
BlockedOnMeta :: TCState -> MetaId -> UnquoteError
UnquotePanic :: String -> UnquoteError
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 -> [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.
WrongNamedArgument :: NamedArg Expr -> TypeError

-- | Wrong user-given relevance annotation in lambda.
WrongIrrelevanceInLambda :: TypeError

-- | Wrong user-given quantity annotation in lambda.
WrongQuantityInLambda :: 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
IlltypedPattern :: Pattern -> Type -> TypeError
IllformedProjectionPattern :: Pattern -> TypeError
CannotEliminateWithPattern :: 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
SplitOnNonVariable :: Term -> Type -> TypeError
DefinitionIsIrrelevant :: QName -> TypeError
VariableIsIrrelevant :: Name -> TypeError
VariableIsErased :: Name -> TypeError
UnequalTerms :: Comparison -> Term -> Term -> Type -> TypeError
UnequalTypes :: Comparison -> Type -> Type -> TypeError

-- | The two function types have different relevance.
UnequalRelevance :: 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, the parameters it can depend on
--   and the paratemeter that it wants to depend on.
MetaCannotDependOn :: MetaId -> [Nat] -> Nat -> TypeError
MetaOccursInItself :: MetaId -> TypeError
MetaIrrelevantSolution :: MetaId -> Term -> TypeError
GenericError :: String -> TypeError
GenericDocError :: 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
ShadowedModule :: Name -> [ModuleName] -> TypeError
BuiltinInParameterisedModule :: String -> TypeError
IllegalLetInTelescope :: TypedBinding -> TypeError
NoRHSRequiresAbsurdPattern :: [NamedArg Pattern] -> TypeError

-- | Record type, fields not supplied by user, non-fields not 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 -> NonemptyList QName -> TypeError
AmbiguousModule :: QName -> NonemptyList ModuleName -> TypeError
ClashingDefinition :: QName -> QName -> 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 :: NonemptyList (QName, PatternSynDefn) -> TypeError
UnusedVariableInPatternSynonym :: TypeError
NoParseForApplication :: [Expr] -> TypeError
AmbiguousParseForApplication :: [Expr] -> [Expr] -> TypeError
NoParseForLHS :: LHSOrPatSyn -> Pattern -> TypeError
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
NonFatalErrors :: [TCWarning] -> TypeError
InstanceSearchDepthExhausted :: Term -> Type -> Int -> TypeError
TriedToCopyConstrainedPrim :: QName -> TypeError

-- | Distinguish error message when parsing lhs or pattern synonym, resp.
data LHSOrPatSyn
IsLHS :: LHSOrPatSyn
IsPatSyn :: LHSOrPatSyn

-- | Type-checking errors.
data TCErr
TypeError :: TCState -> Closure TypeError -> TCErr

-- | 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.
PatternErr :: TCErr
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
sizedTypesOption :: HasOptions m => m Bool
guardednessOption :: HasOptions m => m Bool
withoutKOption :: HasOptions m => m Bool

-- | Environment of the reduce monad.
data ReduceEnv
ReduceEnv :: TCEnv -> TCState -> ReduceEnv

-- | Read only access to environment.
[redEnv] :: ReduceEnv -> TCEnv

-- | Read only access to state (signature, metas...).
[redSt] :: ReduceEnv -> TCState
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
newtype ReduceM a
ReduceM :: (ReduceEnv -> a) -> ReduceM a
[unReduceM] :: ReduceM a -> ReduceEnv -> a
onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b
apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b
bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b
runReduceM :: ReduceM a -> TCM a
runReduceF :: (a -> ReduceM b) -> TCM (a -> b)
useR :: ReadTCState m => Lens' a TCState -> m a
askR :: ReduceM ReduceEnv
localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
class (Applicative m, MonadTCEnv m, ReadTCState m, HasOptions m) => MonadReduce m
liftReduce :: MonadReduce m => ReduceM a -> m a

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

-- | 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 ()
getsTC :: MonadTCState 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 :: MonadTCState 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`

-- | Modify the part of the TCState focused on by the lens.
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 lens-indicated part of the TCState locally.
locallyTCState :: MonadTCState m => Lens' a TCState -> (a -> a) -> m b -> m b

-- | 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
type TCM = TCMT IO
class (Applicative tcm, MonadIO tcm, MonadTCEnv tcm, MonadTCState tcm, HasOptions tcm) => MonadTCM tcm
liftTCM :: MonadTCM tcm => TCM a -> tcm a

-- | Interaction monad.
type IM = TCMT (InputT IO)
runIM :: IM a -> TCM a

-- | 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
mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a
pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a
returnTCMT :: MonadIO m => a -> TCMT m a
bindTCMT :: MonadIO m => TCMT m a -> (a -> TCMT m b) -> TCMT m b
thenTCMT :: MonadIO m => TCMT m a -> TCMT m b -> TCMT m b
fmapTCMT :: MonadIO m => (a -> b) -> TCMT m a -> TCMT m b
apTCMT :: MonadIO m => TCMT m (a -> b) -> TCMT m a -> TCMT m b
patternViolation :: TCM a
internalError :: MonadTCM tcm => String -> tcm a
genericError :: MonadTCM tcm => String -> tcm a
genericDocError :: MonadTCM tcm => Doc -> tcm a
typeError :: MonadTCM tcm => TypeError -> tcm a
typeError_ :: MonadTCM tcm => TypeError -> tcm 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) 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 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
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TypeError
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.UnquoteError
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.LHSOrPatSyn
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.LHSOrPatSyn
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.SplitError
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.UnificationFailure
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NegativeUnification
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Interface
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TCWarning
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Warning
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Warning
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.TerminationError
instance Data.Data.Data Agda.TypeChecking.Monad.Base.TerminationError
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CallInfo
instance Data.Data.Data Agda.TypeChecking.Monad.Base.CallInfo
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ProblemConstraint
instance Data.Data.Data Agda.TypeChecking.Monad.Base.ProblemConstraint
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Constraint
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Constraint
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Candidate
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Candidate
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Defn
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Defn
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Definition
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Definition
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Signature
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Signature
instance Data.Foldable.Foldable Agda.TypeChecking.Monad.Base.Closure
instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.Closure
instance Data.Data.Data a => Data.Data.Data (Agda.TypeChecking.Monad.Base.Closure a)
instance Data.Data.Data Agda.TypeChecking.Monad.Base.TCEnv
instance Data.Data.Data Agda.TypeChecking.Monad.Base.ExpandHidden
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.ExpandHidden
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.AbstractMode
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.AbstractMode
instance Data.Data.Data Agda.TypeChecking.Monad.Base.AbstractMode
instance Data.Data.Data Agda.TypeChecking.Monad.Base.UnquoteFlags
instance Data.Data.Data 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 Data.Data.Data 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 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 Data.Data.Data Agda.TypeChecking.Monad.Base.Call
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 Data.Data.Data Agda.TypeChecking.Monad.Base.MutualId
instance GHC.Base.Functor Agda.TypeChecking.Monad.Base.FunctionInverse'
instance GHC.Show.Show c => GHC.Show.Show (Agda.TypeChecking.Monad.Base.FunctionInverse' c)
instance Data.Data.Data c => Data.Data.Data (Agda.TypeChecking.Monad.Base.FunctionInverse' c)
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 Data.Data.Data Agda.TypeChecking.Monad.Base.TermHead
instance Data.Data.Data 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.Base.Functor Agda.TypeChecking.Monad.Base.MaybeReduced
instance GHC.Base.Functor (Agda.TypeChecking.Monad.Base.Reduced no)
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Simplification
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Simplification
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Simplification
instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.Fields
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 Data.Data.Data Agda.TypeChecking.Monad.Base.CompKit
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 Data.Data.Data Agda.TypeChecking.Monad.Base.FunctionFlag
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.EtaEquality
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.EtaEquality
instance Data.Data.Data Agda.TypeChecking.Monad.Base.EtaEquality
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Projection
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Projection
instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.ProjLams
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ProjLams
instance Data.Data.Data Agda.TypeChecking.Monad.Base.ProjLams
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ExtLamInfo
instance Data.Data.Data Agda.TypeChecking.Monad.Base.ExtLamInfo
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.System
instance Data.Data.Data Agda.TypeChecking.Monad.Base.System
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CompilerPragma
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CompilerPragma
instance Data.Data.Data Agda.TypeChecking.Monad.Base.CompilerPragma
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.IsForced
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.IsForced
instance Data.Data.Data Agda.TypeChecking.Monad.Base.IsForced
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Polarity
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Polarity
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Polarity
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NumGeneralizableArgs
instance Data.Data.Data Agda.TypeChecking.Monad.Base.NumGeneralizableArgs
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.RewriteRule
instance Data.Data.Data Agda.TypeChecking.Monad.Base.RewriteRule
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NLPat
instance Data.Data.Data Agda.TypeChecking.Monad.Base.NLPat
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.NLPType
instance Data.Data.Data Agda.TypeChecking.Monad.Base.NLPType
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DisplayForm
instance Data.Data.Data Agda.TypeChecking.Monad.Base.DisplayForm
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.DisplayTerm
instance Data.Data.Data Agda.TypeChecking.Monad.Base.DisplayTerm
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Section
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Section
instance Data.Data.Data Agda.TypeChecking.Monad.Base.IPClause
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.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.Show.Show Agda.TypeChecking.Monad.Base.Frozen
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Frozen
instance Data.Data.Data Agda.TypeChecking.Monad.Base.GeneralizedValue
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.GeneralizedValue
instance Data.Data.Data 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 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 Data.Data.Data a => Data.Data.Data (Agda.TypeChecking.Monad.Base.Open a)
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CompareDirection
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.CompareDirection
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.Comparison
instance Data.Data.Data Agda.TypeChecking.Monad.Base.Comparison
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Comparison
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ForeignCode
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 Data.Data.Data Agda.TypeChecking.Monad.Base.CheckpointId
instance GHC.Num.Num Agda.TypeChecking.Monad.Base.ProblemId
instance GHC.Real.Integral Agda.TypeChecking.Monad.Base.ProblemId
instance GHC.Real.Real Agda.TypeChecking.Monad.Base.ProblemId
instance GHC.Enum.Enum Agda.TypeChecking.Monad.Base.ProblemId
instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.ProblemId
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.ProblemId
instance Data.Data.Data Agda.TypeChecking.Monad.Base.ProblemId
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.MutualBlock
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.MutualBlock
instance Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr Agda.TypeChecking.Monad.Base.IM
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 (Control.Monad.Trans.Maybe.MaybeT 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.Except.ExceptT err 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.MonadTCM tcm => Agda.TypeChecking.Monad.Base.MonadTCM (Control.Monad.Trans.State.Lazy.StateT s 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.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 (Agda.Utils.ListT.ListT 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.Reader.ReaderT r 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.MonadReduce m => Agda.TypeChecking.Monad.Base.MonadReduce (Control.Monad.Trans.State.Lazy.StateT w m)
instance Agda.TypeChecking.Monad.Base.MonadReduce Agda.TypeChecking.Monad.Base.ReduceM
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 (Agda.Utils.ListT.ListT 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.Reader.ReaderT r 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 m => Agda.TypeChecking.Monad.Base.ReadTCState (Control.Monad.Trans.State.Lazy.StateT s m)
instance Agda.TypeChecking.Monad.Base.ReadTCState Agda.TypeChecking.Monad.Base.ReduceM
instance Agda.TypeChecking.Monad.Base.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 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.TypeChecking.Monad.Base.ProblemId
instance Agda.TypeChecking.Monad.Base.HasFresh Agda.TypeChecking.Monad.Base.CheckpointId
instance Agda.Utils.Except.Error Agda.TypeChecking.Monad.Base.TCErr
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 Control.Monad.Error.Class.MonadError Agda.TypeChecking.Monad.Base.TCErr (Agda.TypeChecking.Monad.Base.TCMT GHC.Types.IO)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Agda.TypeChecking.Monad.Base.TCMT 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 Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.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 (GHC.Base.Monoid w, Agda.TypeChecking.Monad.Base.MonadTCState m) => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance Agda.TypeChecking.Monad.Base.MonadTCState m => Agda.TypeChecking.Monad.Base.MonadTCState (Control.Monad.Trans.State.Lazy.StateT s 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 GHC.Show.Show 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 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 Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Base.MonadTCEnv (Agda.TypeChecking.Monad.Base.TCMT m)
instance (Data.String.IsString a, Control.Monad.IO.Class.MonadIO m) => Data.String.IsString (Agda.TypeChecking.Monad.Base.TCMT m a)
instance Control.Monad.Trans.Class.MonadTrans Agda.TypeChecking.Monad.Base.TCMT
instance Control.Monad.IO.Class.MonadIO 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 => GHC.Base.Functor (Agda.TypeChecking.Monad.Base.TCMT m)
instance Control.Monad.IO.Class.MonadIO m => GHC.Base.Applicative (Agda.TypeChecking.Monad.Base.TCMT m)
instance Agda.Utils.Benchmark.MonadBench Agda.Benchmarking.Phase Agda.TypeChecking.Monad.Base.TCM
instance Agda.Utils.Null.Null (Agda.TypeChecking.Monad.Base.TCM Text.PrettyPrint.HughesPJ.Doc)
instance GHC.Base.Semigroup (Agda.TypeChecking.Monad.Base.TCM Data.Semigroup.Internal.Any)
instance GHC.Base.Monoid (Agda.TypeChecking.Monad.Base.TCM Data.Semigroup.Internal.Any)
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 (Agda.Utils.ListT.ListT 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.Reader.ReaderT r 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 (Control.Monad.Trans.State.Lazy.StateT s m)
instance Agda.TypeChecking.Monad.Base.HasOptions m => Agda.TypeChecking.Monad.Base.HasOptions (Control.Monad.Trans.Except.ExceptT e m)
instance Agda.TypeChecking.Monad.Base.HasOptions m => Agda.TypeChecking.Monad.Base.HasOptions (Agda.Utils.ListT.ListT m)
instance Agda.TypeChecking.Monad.Base.HasOptions m => Agda.TypeChecking.Monad.Base.HasOptions (Control.Monad.Trans.Maybe.MaybeT m)
instance Agda.TypeChecking.Monad.Base.HasOptions m => Agda.TypeChecking.Monad.Base.HasOptions (Control.Monad.Trans.Reader.ReaderT r m)
instance Agda.TypeChecking.Monad.Base.HasOptions m => Agda.TypeChecking.Monad.Base.HasOptions (Control.Monad.Trans.State.Lazy.StateT s m)
instance (Agda.TypeChecking.Monad.Base.HasOptions m, GHC.Base.Monoid w) => Agda.TypeChecking.Monad.Base.HasOptions (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Interface
instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.TCWarning
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.TCWarning
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CallInfo
instance Agda.Syntax.Abstract.AllNames Agda.TypeChecking.Monad.Base.CallInfo
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Listener
instance GHC.Classes.Ord Agda.TypeChecking.Monad.Base.Listener
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.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.Candidate
instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.MetaInfo
instance Agda.Syntax.Position.SetRange Agda.TypeChecking.Monad.Base.MetaInfo
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.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Definition
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Defn
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Signature
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Definitions
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Definition
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Defn
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.TypeChecking.Monad.Base.Closure a)
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Call
instance Agda.Syntax.Position.HasRange Agda.TypeChecking.Monad.Base.Call
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.MutualId
instance Agda.Syntax.Position.KillRange c => Agda.Syntax.Position.KillRange (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 Agda.Syntax.Internal.IsProjElim e => Agda.Syntax.Internal.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 Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.CompKit
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.FunctionFlag
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.EtaEquality
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.Projection
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.ProjLams
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.ExtLamInfo
instance Agda.Syntax.Position.KillRange 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 Agda.Syntax.Position.KillRange 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 Agda.Syntax.Position.KillRange 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 Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.NLPat
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.NLPType
instance Agda.TypeChecking.Free.Lazy.Free Agda.TypeChecking.Monad.Base.DisplayForm
instance Agda.Syntax.Position.KillRange 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 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 GHC.Classes.Eq Agda.TypeChecking.Monad.Base.InteractionPoint
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.IPClause
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.NamedMeta
instance Agda.Syntax.Position.KillRange Agda.TypeChecking.Monad.Base.DoGeneralize
instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Monad.Base.Judgement a)
instance Agda.Utils.Functor.Decoration Agda.TypeChecking.Monad.Base.Open
instance Agda.Syntax.Position.KillRange a => Agda.Syntax.Position.KillRange (Agda.TypeChecking.Monad.Base.Open a)
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CompareDirection
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.Comparison
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.CheckpointId
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.CheckpointId
instance GHC.Show.Show Agda.TypeChecking.Monad.Base.ProblemId
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.Base.ProblemId
instance Agda.Utils.Null.Null Agda.TypeChecking.Monad.Base.MutualBlock

module Agda.TypeChecking.Serialise.Base

-- | Constructor tag (maybe omitted) and argument indices.
type Node = [Int32]

-- | The type of hashtables used in this module.
--   
--   A very limited amount of testing indicates that CuckooHashTable
--   is somewhat slower than BasicHashTable, and that
--   LinearHashTable and the hashtables from Data.Hashtable
--   are much slower.
type HashTable k v = BasicHashTable k v

-- | Structure providing fresh identifiers for hash map and counting hash
--   map hits (i.e. when no fresh identifier required).
data FreshAndReuse
FreshAndReuse :: !Int32 -> !Int32 -> FreshAndReuse

-- | Number of hash map misses.
[farFresh] :: FreshAndReuse -> !Int32

-- | Number of hash map hits.
[farReuse] :: FreshAndReuse -> !Int32
farEmpty :: FreshAndReuse
lensFresh :: Lens' Int32 FreshAndReuse
lensReuse :: 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 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 -> !HashTable String Int -> Bool -> !HashTable AbsolutePath Int32 -> Dict

-- | Written to interface file.
[nodeD] :: Dict -> !HashTable Node Int32

-- | Written to interface file.
[stringD] :: Dict -> !HashTable String Int32

-- | Written to interface file.
[textD] :: 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
[textC] :: 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

-- | Not written to interface file.
[absPathD] :: Dict -> !HashTable AbsolutePath Int32

-- | 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 = HashTable (Int32, TypeRep) U

-- | State of the decoder.
data St
St :: !Array Int32 Node -> !Array Int32 String -> !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.
[textE] :: 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 Data.Type.Equality.~ '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

module Agda.TypeChecking.Monad.Imports
addImport :: ModuleName -> TCM ()
addImportCycleCheck :: TopLevelModuleName -> TCM a -> TCM a
getImports :: TCM (Set ModuleName)
isImported :: ModuleName -> TCM Bool
getImportPath :: TCM [TopLevelModuleName]
visitModule :: ModuleInfo -> TCM ()
setVisitedModules :: VisitedModules -> TCM ()
getVisitedModules :: TCM VisitedModules
isVisited :: TopLevelModuleName -> TCM Bool
getVisitedModule :: TopLevelModuleName -> TCM (Maybe ModuleInfo)
mapVisitedModule :: TopLevelModuleName -> (ModuleInfo -> ModuleInfo) -> TCM ()
getDecodedModules :: TCM DecodedModules
setDecodedModules :: DecodedModules -> TCM ()
getDecodedModule :: TopLevelModuleName -> TCM (Maybe Interface)
storeDecodedModule :: Interface -> TCM ()
dropDecodedModule :: TopLevelModuleName -> TCM ()
withImportPath :: [TopLevelModuleName] -> TCM a -> TCM a

-- | Assumes that the first module in the import path is the module we are
--   worried about.
checkForImportCycle :: TCM ()

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 :: ModuleName -> TCM a -> TCM 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 :: TCEnv -> TCM a -> TCM a

-- | Get the current environment
getEnv :: TCM TCEnv

-- | Increases the module nesting level by one in the given computation.
withIncreasedModuleNestingLevel :: TCM a -> TCM a

-- | Set highlighting level
withHighlightingLevel :: HighlightingLevel -> TCM a -> TCM a
withoutOptionsChecking :: TCM a -> TCM a

-- | Restore setting for ExpandLast to default.
doExpandLast :: TCM a -> TCM a
dontExpandLast :: 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 :: (AllowedReductions -> AllowedReductions) -> TCM a -> TCM a
putAllowedReductions :: AllowedReductions -> TCM a -> TCM a

-- | Reduce Def f vs only if f is a projection.
onlyReduceProjections :: TCM a -> TCM a

-- | Allow all reductions except for non-terminating functions (default).
allowAllReductions :: TCM a -> TCM a

-- | Allow all reductions including non-terminating functions.
allowNonTerminatingReductions :: TCM a -> TCM 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

module Agda.TypeChecking.Monad.Debug
class (Functor m, Applicative m, Monad m) => MonadDebug m
displayDebugMessage :: MonadDebug m => Int -> String -> m ()
traceDebugMessage :: MonadDebug m => Int -> String -> m a -> m a
formatDebugMessage :: MonadDebug m => VerboseKey -> Int -> TCM Doc -> m String

-- | Conditionally print debug string.
reportS :: (HasOptions m, MonadDebug m, MonadTCEnv m) => VerboseKey -> Int -> String -> m ()

-- | Conditionally println debug string.
reportSLn :: (HasOptions m, MonadDebug m, MonadTCEnv m) => VerboseKey -> Int -> String -> m ()

-- | Conditionally render debug Doc and print it.
reportSDoc :: (HasOptions m, MonadDebug m, MonadTCEnv m) => VerboseKey -> Int -> TCM Doc -> m ()
unlessDebugPrinting :: MonadTCM m => m () -> m ()
traceSLn :: (HasOptions m, MonadDebug m) => VerboseKey -> Int -> String -> m a -> m a

-- | Conditionally render debug Doc, print it, and then continue.
traceSDoc :: (HasOptions m, MonadDebug m) => VerboseKey -> Int -> TCM Doc -> m a -> m a

-- | Print brackets around debug messages issued by a computation.
verboseBracket :: (HasOptions m, MonadDebug m, MonadError err m) => VerboseKey -> Int -> String -> m a -> m a
instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Debug.MonadDebug (Agda.TypeChecking.Monad.Base.TCMT 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 (Agda.Utils.ListT.ListT 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)

module Agda.TypeChecking.Monad.Caching

-- | Writes a TypeCheckAction to the current log, using the current
--   PostScopeState
writeToCurrentLog :: TypeCheckAction -> TCM ()

-- | Reads the next entry in the cached type check log, if present.
readFromCachedLog :: TCM (Maybe (TypeCheckAction, PostScopeState))

-- | Empties the "to read" CachedState. To be used when it gets invalid.
cleanCachedLog :: TCM ()

-- | Caches the current type check log. Discardes the old cache. Does
--   nothing if caching is inactive.
cacheCurrentLog :: TCM ()

-- | 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 :: TCM ()

-- | To be called before any write or restore calls.
cachingStarts :: TCM ()
areWeCaching :: TCM Bool

-- | Runs the action without cache and restores the current cache at the
--   end of it.
withoutCache :: TCM a -> TCM a
restorePostScopeState :: PostScopeState -> TCM ()

module Agda.TypeChecking.Warnings
genericWarning :: MonadTCM tcm => Doc -> tcm ()
genericNonFatalError :: MonadTCM tcm => Doc -> tcm ()
warning_ :: MonadTCM tcm => Warning -> tcm TCWarning

-- | applyWarningMode filters out the warnings the user has not
--   requested Users are not allowed to ignore non-fatal errors.
applyWarningMode :: WarningMode -> Warning -> Maybe Warning
warnings :: MonadTCM tcm => [Warning] -> tcm ()
warning :: MonadTCM tcm => Warning -> tcm ()

-- | 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
isUnsolvedWarning :: Warning -> Bool
classifyWarning :: Warning -> WhichWarnings

-- | Should we only emit a single warning with this constructor.
onlyOnce :: Warning -> Bool
onlyShowIfUnsolved :: Warning -> Bool
classifyWarnings :: [TCWarning] -> ([TCWarning], [TCWarning])

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

-- | 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)
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 :: TCM ScopeInfo

-- | Set the current scope.
setScope :: ScopeInfo -> TCM ()

-- | Modify the current scope without updating the inverse maps.
modifyScope_ :: (ScopeInfo -> ScopeInfo) -> TCM ()

-- | Modify the current scope.
modifyScope :: (ScopeInfo -> ScopeInfo) -> TCM ()

-- | Run a computation in a local scope.
withScope :: ScopeInfo -> TCM a -> TCM (a, ScopeInfo)

-- | Same as withScope, but discard the scope from the computation.
withScope_ :: ScopeInfo -> TCM a -> TCM a

-- | Discard any changes to the scope by a computation.
localScope :: TCM a -> TCM a

-- | Scope error.
notInScope :: QName -> TCM a

-- | Debug print the scope.
printScope :: String -> Int -> String -> TCM ()
modifySignature :: (Signature -> Signature) -> TCM ()
modifyImportedSignature :: (Signature -> Signature) -> TCM ()
getSignature :: TCM 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 :: QName -> (Definition -> Definition) -> TCM ()
setSignature :: Signature -> TCM ()

-- | Run some computation in a different signature, restore original
--   signature.
withSignature :: Signature -> TCM a -> TCM a
addRewriteRulesFor :: QName -> RewriteRules -> [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 :: ([Closure Clause] -> [Closure Clause]) -> Defn -> Defn
updateCompiledClauses :: (Maybe CompiledClauses -> Maybe CompiledClauses) -> Defn -> Defn
updateFunCopatternLHS :: (Bool -> Bool) -> Defn -> Defn

-- | Set the top-level module. This affects the global module id of freshly
--   generated names.
setTopLevelModule :: QName -> TCM ()

-- | Use a different top-level module for a computation. Used when
--   generating names for imported modules.
withTopLevelModule :: QName -> TCM a -> TCM a
addForeignCode :: BackendName -> String -> TCM ()
getInteractionOutputCallback :: TCM InteractionOutputCallback
appInteractionOutputCallback :: Response -> TCM ()
setInteractionOutputCallback :: InteractionOutputCallback -> TCM ()
getPatternSyns :: TCM PatternSynDefns
setPatternSyns :: PatternSynDefns -> TCM ()

-- | Lens for stPatternSyns.
modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM ()
getPatternSynImports :: TCM PatternSynDefns

-- | Get both local and imported pattern synonyms
getAllPatternSyns :: TCM 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.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 :: MutualId -> TCM MutualBlock

-- | Reverse lookup of a mutual block id for a names.
mutualBlockOf :: QName -> TCM MutualId

-- | Measure CPU time for individual phases of the Agda pipeline.
module Agda.TypeChecking.Monad.Benchmark

-- | Monad with access to benchmarking data.
class (Ord a, Functor m, MonadIO m) => MonadBench a m | m -> a
getBenchmark :: MonadBench a m => m (Benchmark a)

-- | When verbosity is set or changes, 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 a m => Account a -> m c -> m c

-- | Bill a pure computation to a specific account.
billPureTo :: MonadBench a m => Account a -> c -> m c

-- | Bill a CPS function to an account. Can't handle exceptions.
billToCPS :: MonadBench a m => Account a -> ((b -> m c) -> m c) -> (b -> m c) -> m c

-- | Resets the account and the timing information.
reset :: MonadBench a m => m ()

-- | Prints the accumulated benchmark results. Does nothing if profiling is
--   not activated at level 7.
print :: MonadTCM tcm => tcm ()

-- | Extract all names from things.
module Agda.Syntax.Internal.Names
class NamesIn a
namesIn :: NamesIn a => a -> Set QName
namesIn :: (NamesIn a, Foldable f, NamesIn b, f b ~ a) => a -> Set QName
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 [a]
instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.Utils.NonemptyList.NonemptyList 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.Dom 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.Syntax.Internal.Tele 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 (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 Agda.TypeChecking.Monad.Base.CompKit
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.Internal.LevelAtom
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' a)
instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Abstract.Name.QName
instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Internal.ConHead
instance Agda.Syntax.Internal.Names.NamesIn a => Agda.Syntax.Internal.Names.NamesIn (Agda.TypeChecking.Monad.Base.Open 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 (Agda.Syntax.Abstract.Pattern' a)
instance Agda.Syntax.Internal.Names.NamesIn Agda.Syntax.Abstract.Name.AmbiguousQName

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

-- | 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 :: (PragmaOptions -> PragmaOptions) -> TCM ()
class LensVerbosity a
getVerbosity :: LensVerbosity a => a -> Verbosity
setVerbosity :: LensVerbosity a => Verbosity -> a -> a
mapVerbosity :: LensVerbosity a => (Verbosity -> Verbosity) -> a -> a
modifyVerbosity :: (Verbosity -> Verbosity) -> TCM ()
putVerbosity :: Verbosity -> TCM ()
class LensCommandLineOptions a
getCommandLineOptions :: LensCommandLineOptions a => a -> CommandLineOptions
setCommandLineOptions :: LensCommandLineOptions a => CommandLineOptions -> a -> a
mapCommandLineOptions :: LensCommandLineOptions a => (CommandLineOptions -> CommandLineOptions) -> a -> a
modifyCommandLineOptions :: (CommandLineOptions -> CommandLineOptions) -> TCM ()
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 :: (SafeMode -> SafeMode) -> TCM ()
putSafeMode :: SafeMode -> TCM ()

-- | 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
isBuiltinModule :: FilePath -> TCM Bool
isBuiltinModuleWithSafePostulates :: FilePath -> TCM 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 :: ([FilePath] -> [FilePath]) -> TCM ()
putIncludePaths :: [FilePath] -> TCM ()
modifyAbsoluteIncludePaths :: ([AbsolutePath] -> [AbsolutePath]) -> TCM ()
putAbsoluteIncludePaths :: [AbsolutePath] -> TCM ()
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 :: (PersistentVerbosity -> PersistentVerbosity) -> TCM ()
putPersistentVerbosity :: PersistentVerbosity -> TCM ()
instance Agda.Interaction.Options.Lenses.LensPersistentVerbosity Agda.Interaction.Options.PragmaOptions
instance Agda.Interaction.Options.Lenses.LensPersistentVerbosity Agda.Interaction.Options.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.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.PragmaOptions
instance Agda.Interaction.Options.Lenses.LensSafeMode Agda.Interaction.Options.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.PragmaOptions
instance Agda.Interaction.Options.Lenses.LensVerbosity Agda.TypeChecking.Monad.Base.TCState
instance Agda.Interaction.Options.Lenses.LensPragmaOptions Agda.Interaction.Options.CommandLineOptions
instance Agda.Interaction.Options.Lenses.LensPragmaOptions Agda.TypeChecking.Monad.Base.TCState

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
--   (thus, they are Left now, and were previously Right
--   something), then the state is reset (completely, see
--   setIncludeDirs) .
--   
--   An empty list of relative include directories (Left
--   []) is interpreted as ["."].
setCommandLineOptions :: CommandLineOptions -> TCM ()
setCommandLineOptions' :: AbsolutePath -> CommandLineOptions -> TCM ()
libToTCM :: LibM a -> TCM a
setLibraryPaths :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions
setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions
addDefaultLibraries :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions
setOptionsFromPragma :: OptionsPragma -> TCM ()

-- | Disable display forms.
enableDisplayForms :: TCM a -> TCM a

-- | Disable display forms.
disableDisplayForms :: TCM a -> TCM a

-- | Check if display forms are enabled.
displayFormsEnabled :: TCM Bool

-- | Gets the include directories.
--   
--   Precondition: optAbsoluteIncludePaths must be nonempty (i.e.
--   setCommandLineOptions must have run).
getIncludeDirs :: TCM [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
--   stInteractionOutputCallback).
--   
--   An empty list is interpreted as ["."].
setIncludeDirs :: [FilePath] -> AbsolutePath -> TCM ()
setInputFile :: FilePath -> TCM ()

-- | Should only be run if hasInputFile.
getInputFile :: TCM AbsolutePath

-- | Return the optInputFile as AbsolutePath, if any.
getInputFile' :: TCM (Maybe AbsolutePath)
hasInputFile :: TCM Bool
isPropEnabled :: HasOptions m => m Bool
hasUniversePolymorphism :: HasOptions m => m Bool
enableCaching :: TCM Bool
showImplicitArguments :: TCM Bool
showIrrelevantArguments :: TCM 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 :: TCM a -> TCM a
withShowAllArguments' :: Bool -> TCM a -> TCM a

-- | Change PragmaOptions for a computation and restore afterwards.
withPragmaOptions :: (PragmaOptions -> PragmaOptions) -> TCM a -> TCM a
ignoreInterfaces :: TCM Bool
ignoreAllInterfaces :: TCM Bool
positivityCheckEnabled :: TCM Bool
typeInType :: HasOptions m => m Bool
etaEnabled :: TCM Bool
maxInstanceSearchDepth :: TCM Int
maxInversionDepth :: TCM Int

-- | Retrieve the current verbosity level.
getVerbosity :: HasOptions m => m (Trie String Int)
type VerboseKey = String
parseVerboseKey :: VerboseKey -> [String]

-- | Check whether a certain verbosity level is activated.
--   
--   Precondition: The level must be non-negative.
hasVerbosity :: HasOptions m => VerboseKey -> Int -> m Bool

-- | Check whether a certain verbosity level is activated (exact match).
hasExactVerbosity :: HasOptions m => VerboseKey -> Int -> m Bool

-- | Run a computation if a certain verbosity level is activated (exact
--   match).
whenExactVerbosity :: MonadTCM tcm => VerboseKey -> Int -> tcm () -> tcm ()

-- | Run a computation if a certain verbosity level is activated.
--   
--   Precondition: The level must be non-negative.
verboseS :: (MonadTCEnv m, HasOptions m) => VerboseKey -> Int -> m () -> m ()

-- | Verbosity lens.
verbosity :: VerboseKey -> Lens' Int TCState

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

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

-- | If $v$ is a record value, canProject f v returns its field
--   f.
canProject :: QName -> Term -> Maybe (Arg Term)

-- | Eliminate a constructed term.
conApp :: 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 => Empty -> 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 t a => Empty -> Permutation -> a -> a
applyNLPatSubst :: Subst Term a => Substitution' NLPat -> a -> a
fromPatternSubstitution :: PatternSubstitution -> Substitution
applyPatSubst :: Subst Term a => PatternSubstitution -> a -> a
usePatOrigin :: PatOrigin -> 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 -> 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

-- | Turn a typed binding (x1 .. xn : A) into a telescope.
bindsToTel' :: (Name -> a) -> [Name] -> Dom Type -> ListTel' a
bindsToTel :: [Name] -> Dom Type -> ListTel

-- | Turn a typed binding (x1 .. xn : A) into a telescope.
namedBindsToTel :: [NamedArg Name] -> Type -> Telescope
domFromNamedArgName :: NamedArg Name -> Dom ()

-- | 
--   mkPi dom t = telePi (telFromList [dom]) t
--   
mkPi :: Dom (ArgName, Type) -> Type -> Type
mkLam :: 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

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

-- | Get the next higher sort.
univSort' :: Maybe Sort -> Sort -> Maybe Sort
univSort :: Maybe Sort -> Sort -> Sort
univInf :: HasOptions m => m (Maybe Sort)

-- | Compute the sort of a function type from the sorts of its domain and
--   codomain.
funSort' :: Sort -> Sort -> Maybe Sort
funSort :: Sort -> Sort -> Sort

-- | Compute the sort of a pi type from the sorts of its domain and
--   codomain.
piSort' :: Sort -> Abs Sort -> Maybe Sort
piSort :: Sort -> Abs Sort -> Sort
levelMax :: [PlusLevel] -> Level
levelTm :: Level -> Term
unLevelAtom :: LevelAtom -> Term
levelSucView :: Level -> Maybe Level

-- | Substitutions.
data Substitution' a

-- | Identity substitution. Γ ⊢ IdS : Γ
IdS :: Substitution' a

-- | Empty substitution, lifts from the empty context. First argument is
--   (throwImpossible (Impossible
--   "srcfullAgdaSyntaxInternal.hs" 614)). Apply this to
--   closed terms you want to use in a non-empty context. Γ ⊢ EmptyS :
--   ()
EmptyS :: Empty -> Substitution' a

-- | Substitution extension, `cons'.  Γ ⊢ u : Aρ Γ ⊢ ρ : Δ
--   ---------------------- Γ ⊢ u :# ρ : Δ, A 
(:#) :: a -> Substitution' a -> Substitution' a

-- | Strengthening substitution. First argument is (throwImpossible
--   (Impossible "srcfullAgdaSyntaxInternal.hs" 627)).
--   Apply this to a term which does not contain variable 0 to lower all de
--   Bruijn indices by one.  Γ ⊢ ρ : Δ --------------------------- Γ ⊢
--   Strengthen ρ : Δ, A 
Strengthen :: Empty -> Substitution' a -> Substitution' a

-- | Weakning 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.Subst t a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.TypeChecking.Substitute.TelV a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.TypeChecking.Substitute.TelV a)
instance GHC.Classes.Eq (Agda.Syntax.Internal.Substitution' Agda.Syntax.Internal.Term)
instance GHC.Classes.Ord (Agda.Syntax.Internal.Substitution' Agda.Syntax.Internal.Term)
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.Candidate
instance (Agda.TypeChecking.Substitute.Class.Subst t a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Internal.Tele a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Internal.Tele a)
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Constraint
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Base.Section
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.Sort
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term 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 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.Base.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.Base.HashMap k v)
instance Agda.TypeChecking.Substitute.Class.Subst a a => Agda.TypeChecking.Substitute.Class.Subst a (Agda.Syntax.Internal.Substitution' a)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term a => Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term (Agda.Syntax.Internal.Type' a)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.Sort
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.Level
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.LevelAtom
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Abstract.Name.Name
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term GHC.Base.String
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.ConPatternInfo
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.Pattern
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Abstract.ProblemEq
instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.TypeChecking.Monad.Base.NLPat
instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.NLPat Agda.TypeChecking.Monad.Base.NLPat
instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.NLPat Agda.TypeChecking.Monad.Base.NLPType
instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Monad.Base.NLPat Agda.TypeChecking.Monad.Base.RewriteRule
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Internal.Blocked a)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Monad.Base.DisplayForm
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Monad.Base.DisplayTerm
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Internal.Tele a)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Monad.Base.Constraint
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Internal.Elim' a)
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Internal.Abs a)
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Common.Arg a)
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Common.Named name a)
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (Agda.Syntax.Common.Dom a)
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t (GHC.Maybe.Maybe a)
instance Agda.TypeChecking.Substitute.Class.Subst t a => Agda.TypeChecking.Substitute.Class.Subst t [a]
instance (GHC.Classes.Ord k, Agda.TypeChecking.Substitute.Class.Subst t a) => Agda.TypeChecking.Substitute.Class.Subst t (Data.Map.Internal.Map k a)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term ()
instance (Agda.TypeChecking.Substitute.Class.Subst t a, Agda.TypeChecking.Substitute.Class.Subst t b) => Agda.TypeChecking.Substitute.Class.Subst t (a, b)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, Agda.TypeChecking.Substitute.Class.Subst t b, Agda.TypeChecking.Substitute.Class.Subst t c) => Agda.TypeChecking.Substitute.Class.Subst t (a, b, c)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, Agda.TypeChecking.Substitute.Class.Subst t b, Agda.TypeChecking.Substitute.Class.Subst t c, Agda.TypeChecking.Substitute.Class.Subst t d) => Agda.TypeChecking.Substitute.Class.Subst t (a, b, c, d)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Monad.Base.Candidate
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Internal.EqualityView
instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.Syntax.Internal.DeBruijnPattern
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.DeBruijnPattern Agda.Syntax.Internal.DeBruijnPattern
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.Syntax.Position.Range
instance GHC.Classes.Ord Agda.Syntax.Internal.PlusLevel
instance GHC.Classes.Eq Agda.Syntax.Internal.LevelAtom
instance GHC.Classes.Ord Agda.Syntax.Internal.LevelAtom
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 t a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Internal.Abs a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Internal.Abs a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, GHC.Classes.Eq a) => GHC.Classes.Eq (Agda.Syntax.Internal.Elim' a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, GHC.Classes.Ord a) => GHC.Classes.Ord (Agda.Syntax.Internal.Elim' a)

module Agda.TypeChecking.Monad.Open

-- | Create an open term in the current context.
makeOpen :: a -> TCM (Open a)

-- | Extract the value from an open term. The checkpoint at which it was
--   created must be in scope.
getOpen :: (Subst Term a, MonadTCEnv m) => Open a -> m a

-- | Extract the value from an open term. Returns Nothing if the
--   checkpoint at which it was created is not in scope.
tryGetOpen :: (Subst Term a, MonadTCEnv m) => Open a -> m (Maybe a)

-- | An Open is closed if it has checkpoint 0.
isClosed :: Open a -> Bool

module Agda.TypeChecking.Monad.Builtin

-- | The coinductive primitives.
data CoinductionKit
CoinductionKit :: QName -> QName -> QName -> CoinductionKit
[nameOfInf] :: CoinductionKit -> QName
[nameOfSharp] :: CoinductionKit -> QName
[nameOfFlat] :: CoinductionKit -> QName
class (Functor m, Applicative m, MonadFail m) => HasBuiltins m
getBuiltinThing :: HasBuiltins m => String -> m (Maybe (Builtin PrimFun))
litType :: Literal -> TCM Type
setBuiltinThings :: BuiltinThings PrimFun -> TCM ()
bindBuiltinName :: String -> Term -> TCM ()
bindPrimitive :: String -> PrimFun -> TCM ()
getBuiltin :: String -> TCM Term
getBuiltin' :: HasBuiltins m => String -> m (Maybe Term)
getPrimitive' :: HasBuiltins m => String -> m (Maybe PrimFun)
getPrimitive :: String -> TCM PrimFun
getPrimitiveTerm :: String -> TCM 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 :: Term -> TCM Term
constructorForm' :: Applicative m => m Term -> m Term -> Term -> m Term
primInteger :: TCM Term
primIntegerPos :: TCM Term
primIntegerNegSuc :: TCM Term
primFloat :: TCM Term
primChar :: TCM Term
primString :: TCM Term
primBool :: TCM Term
primSigma :: TCM Term
primUnit :: TCM Term
primUnitUnit :: TCM Term
primTrue :: TCM Term
primFalse :: TCM Term
primList :: TCM Term
primNil :: TCM Term
primCons :: TCM Term
primIO :: TCM Term
primId :: TCM Term
primConId :: TCM Term
primIdElim :: TCM Term
primPath :: TCM Term
primPathP :: TCM Term
primInterval :: TCM Term
primIZero :: TCM Term
primIOne :: TCM Term
primIMin :: TCM Term
primIMax :: TCM Term
primINeg :: TCM Term
primPartial :: TCM Term
primPartialP :: TCM Term
primIsOne :: TCM Term
primItIsOne :: TCM Term
primTrans :: TCM Term
primHComp :: TCM Term
primEquiv :: TCM Term
primEquivFun :: TCM Term
primEquivProof :: TCM Term
primPathToEquiv :: TCM Term
primGlue :: TCM Term
prim_glue :: TCM Term
prim_unglue :: TCM Term
primFaceForall :: TCM Term
primIsOne1 :: TCM Term
primIsOne2 :: TCM Term
primIsOneEmpty :: TCM Term
primSub :: TCM Term
primSubIn :: TCM Term
primSubOut :: TCM Term
primNat :: TCM Term
primSuc :: TCM Term
primZero :: TCM Term
primNatPlus :: TCM Term
primNatMinus :: TCM Term
primNatTimes :: TCM Term
primNatDivSucAux :: TCM Term
primNatModSucAux :: TCM Term
primNatEquality :: TCM Term
primNatLess :: TCM Term
primWord64 :: TCM Term
primSizeUniv :: TCM Term
primSize :: TCM Term
primSizeLt :: TCM Term
primSizeSuc :: TCM Term
primSizeInf :: TCM Term
primSizeMax :: TCM Term
primInf :: TCM Term
primSharp :: TCM Term
primFlat :: TCM Term
primEquality :: TCM Term
primRefl :: TCM Term
primRewrite :: TCM Term
primLevel :: TCM Term
primLevelZero :: TCM Term
primLevelSuc :: TCM Term
primLevelMax :: TCM Term
primSetOmega :: TCM Term
primFromNat :: TCM Term
primFromNeg :: TCM Term
primFromString :: TCM Term
primQName :: TCM Term
primArg :: TCM Term
primArgArg :: TCM Term
primAbs :: TCM Term
primAbsAbs :: TCM Term
primAgdaSort :: TCM Term
primHiding :: TCM Term
primHidden :: TCM Term
primInstance :: TCM Term
primVisible :: TCM Term
primRelevance :: TCM Term
primRelevant :: TCM Term
primIrrelevant :: TCM Term
primAssoc :: TCM Term
primAssocLeft :: TCM Term
primAssocRight :: TCM Term
primAssocNon :: TCM Term
primPrecedence :: TCM Term
primPrecRelated :: TCM Term
primPrecUnrelated :: TCM Term
primFixity :: TCM Term
primFixityFixity :: TCM Term
primArgInfo :: TCM Term
primArgArgInfo :: TCM Term
primAgdaSortSet :: TCM Term
primAgdaSortLit :: TCM Term
primAgdaSortUnsupported :: TCM Term
primAgdaTerm :: TCM Term
primAgdaTermVar :: TCM Term
primAgdaTermLam :: TCM Term
primAgdaTermExtLam :: TCM Term
primAgdaTermDef :: TCM Term
primAgdaTermCon :: TCM Term
primAgdaTermPi :: TCM Term
primAgdaTermSort :: TCM Term
primAgdaTermLit :: TCM Term
primAgdaTermUnsupported :: TCM Term
primAgdaTermMeta :: TCM Term
primAgdaErrorPart :: TCM Term
primAgdaErrorPartString :: TCM Term
primAgdaErrorPartTerm :: TCM Term
primAgdaErrorPartName :: TCM Term
primAgdaLiteral :: TCM Term
primAgdaLitNat :: TCM Term
primAgdaLitWord64 :: TCM Term
primAgdaLitFloat :: TCM Term
primAgdaLitChar :: TCM Term
primAgdaLitString :: TCM Term
primAgdaLitQName :: TCM Term
primAgdaLitMeta :: TCM Term
primAgdaPattern :: TCM Term
primAgdaPatCon :: TCM Term
primAgdaPatVar :: TCM Term
primAgdaPatDot :: TCM Term
primAgdaPatLit :: TCM Term
primAgdaPatProj :: TCM Term
primAgdaPatAbsurd :: TCM Term
primAgdaClause :: TCM Term
primAgdaClauseClause :: TCM Term
primAgdaClauseAbsurd :: TCM Term
primAgdaDefinitionFunDef :: TCM Term
primAgdaDefinitionDataDef :: TCM Term
primAgdaDefinitionRecordDef :: TCM Term
primAgdaDefinitionDataConstructor :: TCM Term
primAgdaDefinitionPostulate :: TCM Term
primAgdaDefinitionPrimitive :: TCM Term
primAgdaDefinition :: TCM Term
primAgdaMeta :: TCM Term
primAgdaTCM :: TCM Term
primAgdaTCMReturn :: TCM Term
primAgdaTCMBind :: TCM Term
primAgdaTCMUnify :: TCM Term
primAgdaTCMTypeError :: TCM Term
primAgdaTCMInferType :: TCM Term
primAgdaTCMCheckType :: TCM Term
primAgdaTCMNormalise :: TCM Term
primAgdaTCMReduce :: TCM Term
primAgdaTCMCatchError :: TCM Term
primAgdaTCMGetContext :: TCM Term
primAgdaTCMExtendContext :: TCM Term
primAgdaTCMInContext :: TCM Term
primAgdaTCMFreshName :: TCM Term
primAgdaTCMDeclareDef :: TCM Term
primAgdaTCMDeclarePostulate :: TCM Term
primAgdaTCMDefineFun :: TCM Term
primAgdaTCMGetType :: TCM Term
primAgdaTCMGetDefinition :: TCM Term
primAgdaTCMQuoteTerm :: TCM Term
primAgdaTCMUnquoteTerm :: TCM Term
primAgdaTCMBlockOnMeta :: TCM Term
primAgdaTCMCommit :: TCM Term
primAgdaTCMIsMacro :: TCM Term
primAgdaTCMWithNormalisation :: TCM Term
primAgdaTCMDebugPrint :: TCM Term
primAgdaTCMNoConstraints :: TCM Term
primAgdaTCMRunSpeculative :: TCM Term

-- | Tries to build a CoinductionKit.
coinductionKit' :: TCM CoinductionKit
coinductionKit :: TCM (Maybe CoinductionKit)
getPrimName :: Term -> QName
getBuiltinName' :: HasBuiltins m => String -> m (Maybe QName)
getPrimitiveName' :: HasBuiltins m => String -> m (Maybe QName)
isPrimitive :: HasBuiltins m => String -> QName -> m Bool
intervalView' :: HasBuiltins m => m (Term -> IntervalView)
intervalView :: HasBuiltins m => Term -> m IntervalView
intervalUnview :: HasBuiltins m => IntervalView -> m Term
intervalUnview' :: HasBuiltins m => m (IntervalView -> Term)

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

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

-- | Revert the EqualityView.
--   
--   Postcondition: type is reduced.
equalityUnview :: EqualityView -> Type

-- | 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 (Control.Monad.Trans.Maybe.MaybeT m)
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.State.Lazy.StateT s m)
instance Control.Monad.IO.Class.MonadIO m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.TypeChecking.Monad.Base.TCMT m)

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 doesn'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] -> [Constraint]
instance GHC.Classes.Eq Agda.TypeChecking.LevelConstraints.Leq
instance GHC.Show.Show Agda.TypeChecking.LevelConstraints.Leq

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

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 t a) => Int -> a -> Maybe a
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 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.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 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 Agda.Syntax.Treeless.TTerm
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Treeless.TTerm Agda.Syntax.Treeless.TAlt

module Agda.Compiler.Treeless.Pretty
instance Agda.Utils.Pretty.Pretty Agda.Syntax.Treeless.TTerm

-- | 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.Compare
equalTerms :: TTerm -> TTerm -> Bool

module Agda.Compiler.Treeless.Uncase
caseToSeq :: Monad m => TTerm -> m 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.TypeChecking.Monad.Trace
interestingCall :: Closure Call -> Bool
traceCallM :: (MonadTCM tcm, MonadDebug tcm) => tcm Call -> tcm a -> tcm a

-- | Record a function call in the trace.
traceCall :: (MonadTCM tcm, MonadDebug tcm) => Call -> tcm a -> tcm a
getCurrentRange :: (MonadTCM tcm, MonadDebug tcm) => tcm 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 :: (MonadTCM tcm, MonadDebug tcm, HasRange x) => x -> tcm a -> tcm a

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

-- | Converts an Agda file name to the corresponding interface file name.
toIFile :: AbsolutePath -> AbsolutePath

-- | 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 :: [AbsolutePath] -> FindError

-- | Several matching files were found.
--   
--   Invariant: The list of matching files has at least two elements.
Ambiguous :: [AbsolutePath] -> 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 AbsolutePath

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

-- | A variant of findFile' which does not require TCMT.
findFile'' :: [AbsolutePath] -> TopLevelModuleName -> ModuleToSource -> IO (Either FindError AbsolutePath, ModuleToSource)

-- | Finds the interface file corresponding to a given top-level module
--   name. 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 AbsolutePath)

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

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 GHC.Integer.Type.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 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.DataOrRecord
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Utils.FileName.AbsolutePath
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.Concrete.Name.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.NonemptyList.NonemptyList a)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b, Agda.TypeChecking.Serialise.Base.EmbPrj a, Agda.TypeChecking.Serialise.Base.EmbPrj b) => Agda.TypeChecking.Serialise.Base.EmbPrj (Agda.Utils.BiMap.BiMap a b)
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.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.Fixity.Associativity
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Fixity.PrecedenceLevel
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Fixity.Fixity
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Fixity.Fixity'
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Notation.GenPart
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.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.Base.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.Dom a)
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Common.HasEta
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.Quantity
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.Origin
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 Agda.Utils.Impossible.Impossible
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Utils.Empty.Empty

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 Agda.Interaction.Highlighting.Precise.CompressedFile
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Highlighting.Precise.TokenBased

-- | Collect statistics.
module Agda.TypeChecking.Monad.Statistics

-- | Increase specified counter by 1.
tick :: String -> TCM ()

-- | Increase specified counter by n.
tickN :: String -> Integer -> TCM ()

-- | Set the specified counter to the maximum of its current value and
--   n.
tickMax :: String -> Integer -> TCM ()

-- | Get the statistics.
getStatistics :: TCM Statistics

-- | Modify the statistics via given function.
modifyStatistics :: (Statistics -> Statistics) -> TCM ()

-- | Print the given statistics if verbosity "profile.ticks" is given.
printStatistics :: Int -> Maybe TopLevelModuleName -> Statistics -> 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 => a -> TCM (Maybe BoundedSize)
isSizeTypeTest :: TCM (Term -> Maybe BoundedSize)
getBuiltinDefName :: String -> TCM (Maybe QName)
getBuiltinSize :: TCM (Maybe QName, Maybe QName)
isSizeNameTest :: TCM (QName -> Bool)
isSizeNameTestRaw :: TCM (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 :: TCM Type

-- | The name of SIZESUC.
sizeSucName :: TCM (Maybe QName)
sizeSuc :: Nat -> Term -> TCM Term
sizeSuc_ :: QName -> Term -> Term

-- | Transform list of terms into a term build from binary maximum.
sizeMax :: NonemptyList Term -> TCM Term

-- | A useful view on sizes.
data SizeView
SizeInf :: SizeView
SizeSuc :: Term -> SizeView
OtherSize :: Term -> SizeView

-- | Expects argument to be reduced.
sizeView :: Term -> TCM SizeView
type Offset = Nat

-- | A deep view on sizes.
data DeepSizeView
DSizeInf :: DeepSizeView
DSizeVar :: Nat -> 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 :: DeepSizeView -> TCM Term
type SizeMaxView = NonemptyList 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 :: SizeMaxView -> TCM Term
instance GHC.Base.Functor Agda.TypeChecking.Monad.SizedTypes.SizeViewComparable
instance GHC.Show.Show Agda.TypeChecking.Monad.SizedTypes.DeepSizeView
instance GHC.Show.Show Agda.TypeChecking.Monad.SizedTypes.BoundedSize
instance GHC.Classes.Eq Agda.TypeChecking.Monad.SizedTypes.BoundedSize
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Monad.SizedTypes.DeepSizeView
instance Agda.TypeChecking.Monad.SizedTypes.IsSizeType a => Agda.TypeChecking.Monad.SizedTypes.IsSizeType (Agda.Syntax.Common.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

-- | 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
isDatatypeModule :: ModuleName -> ScopeM (Maybe DataOrRecord)
printLocals :: Int -> String -> ScopeM ()
getCurrentModule :: ScopeM ModuleName
setCurrentModule :: ModuleName -> ScopeM ()
withCurrentModule :: ModuleName -> ScopeM a -> ScopeM 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. (Just if it is a
--   datatype or record module.)
createModule :: Maybe DataOrRecord -> 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 ()
pushContextPrecedence :: Precedence -> ScopeM PrecedenceStack
setContextPrecedence :: PrecedenceStack -> ScopeM ()
withContextPrecedence :: Precedence -> ScopeM a -> ScopeM a
getLocalVars :: ScopeM LocalVars
modifyLocalVars :: (LocalVars -> LocalVars) -> ScopeM ()
setLocalVars :: LocalVars -> ScopeM ()

-- | Run a computation without changing the local variables.
withLocalVars :: ScopeM a -> ScopeM a
getVarsToBind :: ScopeM LocalVars
addVarToBind :: Name -> LocalVar -> ScopeM ()

-- | After collecting some variable names in the scopeVarsToBind, bind them
--   all simultaneously.
bindVarsToBind :: ScopeM ()

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

-- | 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' :: [KindOfName] -> Maybe (Set Name) -> QName -> ScopeM ResolvedName

-- | 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 :: Binder -> 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 ()

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

-- | Apply an import directive and check that all the names mentioned
--   actually exist.
applyImportDirectiveM :: QName -> ImportDirective -> Scope -> ScopeM (ImportDirective, Scope)

-- | A finite map for ImportedNames.
lookupImportedName :: (Eq a, Eq b) => ImportedName' a b -> [ImportedName' (a, c) (b, d)] -> ImportedName' c d

-- | Translation of ImportDirective.
mapImportDir :: (Eq n1, Eq m1) => [ImportedName' (n1, n2) (m1, m2)] -> [ImportedName' (n1, n2) (m1, m2)] -> ImportDirective' n1 m1 -> ImportDirective' n2 m2

-- | Translation of Using or Hiding.
mapUsing :: (Eq n1, Eq m1) => [ImportedName' (n1, n2) (m1, m2)] -> Using' n1 m1 -> Using' n2 m2

-- | Translation of Renaming.
mapRenaming :: (Eq n1, Eq m1) => [ImportedName' (n1, n2) (m1, m2)] -> [ImportedName' (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
instance Agda.Syntax.Concrete.Fixity.MonadFixityError Agda.Syntax.Scope.Monad.ScopeM

module Agda.TypeChecking.Monad.Context

-- | Modify a Context in a computation.
modifyContext :: MonadTCM tcm => (Context -> Context) -> tcm a -> tcm a

-- | Change to top (=empty) context. Resets the checkpoints.
safeInTopContext :: MonadTCM tcm => tcm a -> tcm a

-- | Change to top (=empty) context, but don't update the checkpoints.
--   Totally not safe!
inTopContext :: MonadTCM tcm => tcm a -> tcm a

-- | Delete the last n bindings from the context.
--   
--   Doesn't update checkpoints! Use `updateContext rho (drop n)` instead,
--   for an appropriate substitution rho.
escapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a

-- | Add a new checkpoint. Do not use directly!
checkpoint :: (MonadDebug tcm, MonadTCM tcm) => Substitution -> tcm a -> tcm a

-- | Update the context. Requires a substitution from the old context to
--   the new.
updateContext :: (MonadDebug tcm, MonadTCM tcm) => Substitution -> (Context -> Context) -> 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.
--   
--   In case the we don't have a checkpoint for m we return the
--   identity substitution. This is ok for instance if we are outside
--   module m (in which case we have to supply all module
--   parameters to any symbol defined within m we want to refer).
getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m Substitution

-- | addCtx x arg cont add a variable to the context.
--   
--   Chooses an unused Name.
--   
--   Warning: Does not update module parameter substitution!
addCtx :: (MonadDebug tcm, MonadTCM tcm) => Name -> Dom Type -> tcm a -> tcm a
addRecordNameContext :: (MonadDebug m, MonadTCM m) => Dom Type -> m b -> m b

-- | Various specializations of addCtx.
class AddContext b
addContext :: (AddContext b, MonadTCM tcm, MonadDebug tcm) => b -> tcm a -> tcm a
contextSize :: AddContext b => b -> Nat

-- | Wrapper to tell addContext not to mark names as
--   NotInScope. 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 t a, MonadTCM tcm, MonadDebug tcm) => Dom Type -> Abs a -> (a -> tcm b) -> tcm b
underAbstraction' :: (Subst t a, MonadTCM tcm, MonadDebug tcm, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> tcm b) -> tcm b

-- | Go under an abstraction, treating NoAbs as Abs.
underAbstractionAbs :: (Subst t a, MonadTCM tcm, MonadDebug tcm) => Dom Type -> Abs a -> (a -> tcm b) -> tcm b
underAbstractionAbs' :: (Subst t a, MonadTCM tcm, MonadDebug tcm, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> tcm b) -> tcm b

-- | Go under an abstract without worrying about the type to add to the
--   context.
underAbstraction_ :: (Subst t a, MonadTCM tcm, MonadDebug tcm) => Abs a -> (a -> tcm b) -> tcm b
getLetBindings :: MonadTCM tcm => tcm [(Name, (Term, Dom Type))]

-- | Add a let bound variable
addLetBinding' :: MonadTCM tcm => Name -> Term -> Dom Type -> tcm a -> tcm a

-- | Add a let bound variable
addLetBinding :: MonadTCM tcm => ArgInfo -> Name -> Term -> Type -> tcm a -> tcm a

-- | Get the current context.
getContext :: MonadTCEnv m => m [Dom (Name, Type)]

-- | 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 (Dom (Name, Type))
typeOfBV' :: (Applicative m, MonadTCEnv m) => Nat -> m (Dom Type)
typeOfBV :: (Applicative m, MonadTCEnv m) => Nat -> m Type
nameOfBV :: (Applicative 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 :: MonadTCEnv m => Name -> m (Term, Dom Type)
instance Agda.TypeChecking.Monad.Context.AddContext (Agda.TypeChecking.Monad.Context.KeepNames GHC.Base.String, Agda.Syntax.Common.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.Common.Dom Agda.Syntax.Internal.Type)
instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Common.Dom (Agda.Syntax.Abstract.Name.Name, Agda.Syntax.Internal.Type))
instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Common.Dom (GHC.Base.String, Agda.Syntax.Internal.Type))
instance Agda.TypeChecking.Monad.Context.AddContext ([Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Common.Dom Agda.Syntax.Internal.Type)
instance Agda.TypeChecking.Monad.Context.AddContext ([Agda.Syntax.Common.WithHiding Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Common.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.Syntax.Common.NamedArg Agda.Syntax.Abstract.Name.Name], Agda.Syntax.Internal.Type)
instance Agda.TypeChecking.Monad.Context.AddContext (GHC.Base.String, Agda.Syntax.Common.Dom Agda.Syntax.Internal.Type)
instance Agda.TypeChecking.Monad.Context.AddContext (Agda.Syntax.Common.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

module Agda.TypeChecking.Monad.Signature

-- | Add a constant to the signature. Lifts the definition to top level.
addConstant :: QName -> Definition -> TCM ()

-- | Set termination info of a defined function symbol.
setTerminates :: QName -> Bool -> TCM ()

-- | 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 :: QName -> [Clause] -> TCM ()
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
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 :: QName -> TCM Bool
getDisplayForms :: QName -> TCM [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 :: QName -> TCM QName
sameDef :: QName -> QName -> TCM (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
defaultGetRewriteRulesFor :: Monad m => m TCState -> 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 :: QName -> TCM [Polarity]

-- | Look up polarity of a definition and compose with polarity represented
--   by Comparison.
getPolarity' :: Comparison -> QName -> TCM [Polarity]

-- | Set the polarity of a definition.
setPolarity :: QName -> [Polarity] -> TCM ()

-- | Look up the forced arguments of a definition.
getForcedArgs :: QName -> TCM [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 :: QName -> [Occurrence] -> TCM ()
modifyArgOccurrences :: QName -> ([Occurrence] -> [Occurrence]) -> TCM ()
setTreeless :: QName -> TTerm -> TCM ()
setCompiledArgUse :: QName -> [Bool] -> TCM ()
getCompiled :: QName -> TCM (Maybe Compiled)
getErasedConArgs :: QName -> TCM [Bool]
setErasedConArgs :: QName -> [Bool] -> TCM ()
getTreeless :: QName -> TCM (Maybe TTerm)
getCompiledArgUse :: QName -> TCM [Bool]

-- | 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 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 :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => QName -> m Type

-- | Get relevance of a constant.
relOfConst :: QName -> TCM Relevance

-- | Get modality of a constant.
modalityOfConst :: QName -> TCM 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 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 :: Defn -> Int

-- | Check whether a definition uses copatterns.
usesCopatterns :: QName -> TCM Bool

-- | Apply a function f to its first argument, producing the
--   proper postfix projection if f is a projection.
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 (Control.Monad.Trans.Maybe.MaybeT 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.Reader.ReaderT r 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 (Control.Monad.Trans.State.Lazy.StateT s m)

module Agda.TypeChecking.Monad.Closure
enterClosure :: Closure a -> (a -> TCM b) -> TCM b
withClosure :: Closure a -> (a -> TCM b) -> TCM (Closure b)
mapClosure :: (a -> TCM b) -> Closure a -> TCM (Closure b)

module Agda.TypeChecking.Monad.MetaVars

-- | Switch off assignment of metas.
dontAssignMetas :: TCM a -> TCM a

-- | Get the meta store.
getMetaStore :: TCM MetaStore
modifyMetaStore :: (MetaStore -> MetaStore) -> TCM ()

-- | Run a computation and record which new metas it created.
metasCreatedBy :: TCM a -> TCM (a, IntSet)

-- | Lookup a meta variable.
lookupMeta' :: MetaId -> TCM (Maybe MetaVariable)
lookupMeta :: MetaId -> TCM MetaVariable

-- | Update the information associated with a meta variable.
updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> TCM ()

-- | Insert a new meta variable with associated information into the meta
--   store.
insertMetaVar :: MetaId -> MetaVariable -> TCM ()
getMetaPriority :: MetaId -> TCM MetaPriority
isSortMeta :: MetaId -> TCM Bool
isSortMeta_ :: MetaVariable -> Bool
getMetaType :: MetaId -> TCM Type

-- | Compute the context variables that a meta should be applied to,
--   accounting for pruning.
getMetaContextArgs :: MetaVariable -> TCM Args

-- | Given a meta, return the type applied to the current context.
getMetaTypeInContext :: MetaId -> TCM Type

-- | 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 => a -> TCM Bool
isInstantiatedMeta' :: MetaId -> TCM (Maybe Term)

-- | Returns every meta-variable occurrence in the given type, except for
--   those in Terms.
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 :: TermLike a => a -> [MetaId]

-- | True if thing contains no metas. noMetas = null .
--   allMetasList.
noMetas :: TermLike a => a -> Bool

-- | Returns the first meta it find in the thing, if any. firstMeta ==
--   headMaybe . allMetasList.
firstMeta :: TermLike a => a -> Maybe MetaId

-- | Returns all metavariables in a constraint. Slightly complicated by the
--   fact that blocked terms are represented by two meta variables. To find
--   the second one we need to look up the meta listeners for the one in
--   the UnBlock constraint.
constraintMetas :: Constraint -> TCM (Set MetaId)

-- | Create MetaInfo in the current environment.
createMetaInfo :: TCM MetaInfo
createMetaInfo' :: RunMetaOccursCheck -> TCM MetaInfo
setValueMetaName :: Term -> MetaNameSuggestion -> TCM ()
getMetaNameSuggestion :: MetaId -> TCM MetaNameSuggestion
setMetaNameSuggestion :: MetaId -> MetaNameSuggestion -> TCM ()
setMetaArgInfo :: MetaId -> ArgInfo -> TCM ()
updateMetaVarRange :: MetaId -> Range -> TCM ()
setMetaOccursCheck :: MetaId -> RunMetaOccursCheck -> TCM ()
modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> TCM ()

-- | Register an interaction point during scope checking. If there is no
--   interaction id yet, create one.
registerInteractionPoint :: Bool -> Range -> Maybe Nat -> TCM InteractionId

-- | Find an interaction point by Range' by searching the whole map.
--   
--   O(n): linear in the number of registered interaction points.
findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId

-- | Hook up meta variable to interaction point.
connectInteractionPoint :: InteractionId -> MetaId -> TCM ()

-- | Mark an interaction point as solved.
removeInteractionPoint :: InteractionId -> TCM ()

-- | Get a list of interaction ids.
getInteractionPoints :: MonadTCM tcm => tcm [InteractionId]

-- | Get all metas that correspond to unsolved interaction ids.
getInteractionMetas :: TCM [MetaId]

-- | Get all metas that correspond to unsolved interaction ids.
getInteractionIdsAndMetas :: TCM [(InteractionId, MetaId)]

-- | Does the meta variable correspond to an interaction point?
--   
--   Time: O(n) where n is the number of interaction
--   metas.
isInteractionMeta :: MetaId -> TCM (Maybe InteractionId)

-- | Get the information associated to an interaction point.
lookupInteractionPoint :: MonadTCM tcm => InteractionId -> tcm InteractionPoint

-- | Get MetaId for an interaction point. Precondition: interaction
--   point is connected.
lookupInteractionId :: InteractionId -> TCM MetaId

-- | Check whether an interaction id is already associated with a meta
--   variable.
lookupInteractionMeta :: InteractionId -> TCM (Maybe MetaId)
lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId

-- | Generate new meta variable.
newMeta :: Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId

-- | Generate a new meta variable with some instantiation given. For
--   instance, the instantiation could be a
--   PostponedTypeCheckingProblem.
newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId

-- | Get the Range' for an interaction point.
getInteractionRange :: MonadTCM tcm => InteractionId -> tcm Range

-- | Get the Range' for a meta variable.
getMetaRange :: MetaId -> TCM Range
getInteractionScope :: InteractionId -> TCM ScopeInfo
withMetaInfo' :: MetaVariable -> TCM a -> TCM a
withMetaInfo :: Closure Range -> TCM a -> TCM a
getMetaVariableSet :: TCM IntSet
getMetaVariables :: (MetaVariable -> Bool) -> TCM [MetaId]
getInstantiatedMetas :: TCM [MetaId]
getOpenMetas :: TCM [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 :: Listener -> MetaId -> TCM ()

-- | Unregister a listener.
unlistenToMeta :: Listener -> MetaId -> TCM ()

-- | Get the listeners to a meta.
getMetaListeners :: MetaId -> TCM [Listener]
clearMetaListeners :: MetaId -> TCM ()

-- | Freeze all so far unfrozen metas for the duration of the given
--   computation.
withFreezeMetas :: TCM a -> TCM a

-- | Freeze all meta variables and return the list of metas that got
--   frozen.
freezeMetas :: TCM [MetaId]

-- | Freeze some meta variables and return the list of metas that got
--   frozen.
freezeMetas' :: (MetaId -> Bool) -> TCM [MetaId]

-- | Thaw all meta variables.
unfreezeMetas :: TCM ()

-- | Thaw some metas, as indicated by the passed condition.
unfreezeMetas' :: (MetaId -> Bool) -> TCM ()
isFrozen :: MetaId -> TCM Bool

-- | Unfreeze meta and its type if this is a meta again. Does not unfreeze
--   deep occurrences of metas.
class UnFreezeMeta a
unfreezeMeta :: UnFreezeMeta a => a -> TCM ()
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 Agda.Syntax.Internal.LevelAtom
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.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 Agda.Syntax.Internal.LevelAtom
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)

module Agda.TypeChecking.Monad.Constraints

-- | Add all constraints belonging to the given problem to the current
--   problem(s).
stealConstraints :: ProblemId -> TCM ()
solvingProblem :: ProblemId -> TCM a -> TCM a
solvingProblems :: Set ProblemId -> TCM a -> TCM a
isProblemSolved :: ProblemId -> TCM Bool
getConstraintsForProblem :: ProblemId -> TCM Constraints

-- | Get the awake constraints
getAwakeConstraints :: TCM Constraints
wakeConstraints :: (ProblemConstraint -> TCM Bool) -> TCM ()
dropConstraints :: (ProblemConstraint -> Bool) -> TCM ()
putConstraintsToSleep :: (ProblemConstraint -> Bool) -> TCM ()
putAllConstraintsToSleep :: TCM ()
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 :: TCM (Maybe ProblemConstraint)
takeAwakeConstraint' :: (ProblemConstraint -> Bool) -> TCM (Maybe ProblemConstraint)
getAllConstraints :: TCM Constraints
withConstraint :: (Constraint -> TCM a) -> ProblemConstraint -> TCM a
buildProblemConstraint :: Set ProblemId -> Constraint -> TCM ProblemConstraint
buildProblemConstraint_ :: Constraint -> TCM ProblemConstraint
buildConstraint :: Constraint -> TCM ProblemConstraint

-- | Add new a constraint
addConstraint' :: Constraint -> TCM ()
addAwakeConstraint' :: Constraint -> TCM ()
addConstraintTo :: Lens' Constraints TCState -> Constraint -> TCM ()

-- | Add already awake constraints
addAwakeConstraints :: Constraints -> TCM ()

-- | Start solving constraints
nowSolvingConstraints :: TCM a -> TCM a
isSolvingConstraints :: TCM Bool
mapAwakeConstraints :: (Constraints -> Constraints) -> TCState -> TCState
mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState
modifyAwakeConstraints :: (Constraints -> Constraints) -> TCM ()
modifySleepingConstraints :: (Constraints -> Constraints) -> TCM ()
instance GHC.Show.Show Agda.TypeChecking.Monad.Constraints.ConstraintStatus
instance GHC.Classes.Eq Agda.TypeChecking.Monad.Constraints.ConstraintStatus

module Agda.TypeChecking.Monad

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.Internal
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' a)
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.LevelAtom
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.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.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.Defn
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.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)

module Agda.TypeChecking.Serialise.Instances.Abstract
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.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.Scope.Base.AbstractModule
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.KindOfName
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Syntax.Scope.Base.Binder
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

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.Concrete.Definitions.DeclarationWarning
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.LibWarning
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.Parse.LibWarning'
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Library.LibPositionInfo
instance Agda.TypeChecking.Serialise.Base.EmbPrj Text.PrettyPrint.HughesPJ.Doc
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.Interaction.Options.PragmaOptions
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
instance Agda.TypeChecking.Serialise.Base.EmbPrj Agda.TypeChecking.Monad.Base.Interface

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

-- | Encodes something. To ensure relocatability file paths in positions
--   are replaced with module names.
encodeFile :: FilePath -> Interface -> TCM ()
encodeInterface :: Interface -> TCM ByteString

-- | Decodes something. The result depends on the include path.
--   
--   Returns Nothing if the input does not start with the right
--   magic number or some other decoding error is encountered.
decode :: EmbPrj a => ByteString -> TCM (Maybe a)
decodeFile :: FilePath -> TCM (Maybe Interface)

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

module Agda.TypeChecking.Reduce.Monad
constructorForm :: HasBuiltins m => Term -> m Term
enterClosure :: Closure a -> (a -> ReduceM b) -> ReduceM b
underAbstraction :: (MonadReduce m, Subst t a) => Dom Type -> Abs a -> (a -> m b) -> m b
underAbstraction_ :: (MonadReduce m, Subst t a) => Abs a -> (a -> m b) -> m b
addCtxTel :: MonadReduce m => Telescope -> m a -> m a

-- | 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
isInstantiatedMeta :: MetaId -> ReduceM Bool
lookupMeta :: MetaId -> ReduceM MetaVariable
askR :: ReduceM ReduceEnv

-- | Apply a function if a certain verbosity level is activated.
--   
--   Precondition: The level must be non-negative.
applyWhenVerboseS :: HasOptions m => VerboseKey -> Int -> (m a -> m a) -> m a -> m a
instance Agda.TypeChecking.Monad.Builtin.HasBuiltins 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

-- | 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 :: Pattern -> TCM 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)

module Agda.TypeChecking.MetaVars.Mention
class MentionsMeta t
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.LevelAtom
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.Common.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

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

module Agda.TypeChecking.Reduce
instantiate :: (Instantiate a, MonadReduce m) => a -> m a
instantiateFull :: (InstantiateFull a, MonadReduce m) => a -> m a
reduce :: (Reduce a, MonadReduce m) => a -> m a
reduceB :: (Reduce a, MonadReduce m) => a -> m (Blocked a)
normalise :: (Normalise a, MonadReduce m) => a -> m a

-- | Normalise the given term but also preserve blocking tags TODO:
--   implement a more efficient version of this.
normaliseB :: (MonadReduce m, Reduce t, Normalise t) => t -> m (Blocked t)
simplify :: (Simplify a, MonadReduce m) => a -> m a

-- | Meaning no metas left in the instantiation.
isFullyInstantiatedMeta :: MetaId -> TCM Bool

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

-- | 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 :: MonadReduce m => Term -> (MetaId -> Term -> m a) -> (NotBlocked -> Term -> m a) -> m a
isBlocked :: MonadReduce m => Term -> m (Maybe MetaId)

-- | Case on whether a type is blocked on a meta (or is a meta).
ifBlockedType :: MonadReduce m => Type -> (MetaId -> Type -> m a) -> (NotBlocked -> Type -> m a) -> m a
isBlockedType :: MonadReduce m => Type -> m (Maybe MetaId)
class Reduce t
reduce' :: Reduce t => t -> ReduceM t
reduceB' :: Reduce t => t -> ReduceM (Blocked t)
reduceIApply :: ReduceM (Blocked Term) -> [Elim] -> ReduceM (Blocked Term)
blockedOrMeta :: Blocked Term -> Blocked ()
reduceIApply' :: (Term -> ReduceM (Blocked Term)) -> ReduceM (Blocked Term) -> [Elim] -> ReduceM (Blocked Term)
shouldTryFastReduce :: ReduceM Bool
maybeFastReduceTerm :: Term -> ReduceM (Blocked Term)
slowReduceTerm :: Term -> ReduceM (Blocked Term)
unfoldCorecursionE :: Elim -> ReduceM (Blocked Elim)
unfoldCorecursion :: Term -> ReduceM (Blocked Term)

-- | If the first argument is True, then a single delayed clause may
--   be unfolded.
unfoldDefinition :: Bool -> (Term -> ReduceM (Blocked Term)) -> Term -> QName -> Args -> ReduceM (Blocked Term)
unfoldDefinitionE :: Bool -> (Term -> ReduceM (Blocked Term)) -> Term -> QName -> Elims -> ReduceM (Blocked Term)
unfoldDefinition' :: Bool -> (Simplification -> Term -> ReduceM (Simplification, Blocked Term)) -> Term -> QName -> Elims -> ReduceM (Simplification, Blocked Term)
unfoldDefinitionStep :: Bool -> Term -> QName -> Elims -> ReduceM (Reduced (Blocked Term) Term)

-- | Reduce a non-primitive definition if it is a copy linking to another
--   def.
reduceDefCopy :: QName -> Elims -> TCM (Reduced () Term)

-- | Reduce simple (single clause) definitions.
reduceHead :: (HasBuiltins m, HasConstInfo m, MonadReduce m, MonadDebug m) => Term -> m (Blocked Term)

-- | Unfold a single inlined function.
unfoldInlined :: (HasConstInfo m, MonadReduce m) => Term -> m Term

-- | Apply a definition using the compiled clauses, or fall back to
--   ordinary clauses if no compiled clauses exist.
appDef_ :: QName -> Term -> [Clause] -> Maybe CompiledClauses -> RewriteRules -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Term) Term)
appDefE_ :: QName -> Term -> [Clause] -> Maybe CompiledClauses -> RewriteRules -> MaybeReducedElims -> ReduceM (Reduced (Blocked Term) Term)

-- | Apply a defined function to it's arguments, using the compiled
--   clauses. The original term is the first argument applied to the third.
appDef :: Term -> CompiledClauses -> RewriteRules -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Term) Term)
appDefE :: Term -> CompiledClauses -> RewriteRules -> MaybeReducedElims -> ReduceM (Reduced (Blocked Term) Term)

-- | Apply a defined function to it's arguments, using the original
--   clauses.
appDef' :: Term -> [Clause] -> RewriteRules -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Term) Term)
appDefE' :: Term -> [Clause] -> RewriteRules -> MaybeReducedElims -> ReduceM (Reduced (Blocked Term) Term)

-- | Only unfold definitions if this leads to simplification which means
--   that a constructor/literal pattern is matched.
class Simplify t
simplify' :: Simplify t => t -> ReduceM t
simplifyBlocked' :: Simplify t => Blocked t -> ReduceM t
class Normalise t
normalise' :: Normalise t => t -> ReduceM t
slowNormaliseArgs :: Term -> ReduceM Term

-- | instantiateFull' instantiates metas everywhere (and
--   recursively) but does not reduce.
class InstantiateFull t
instantiateFull' :: InstantiateFull t => t -> ReduceM t
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Abstract.Name.Name
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Sort
instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Type' a)
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.LevelAtom
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.Substitution
instance Agda.TypeChecking.Reduce.InstantiateFull GHC.Types.Bool
instance Agda.TypeChecking.Reduce.InstantiateFull GHC.Types.Int
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.ConPatternInfo
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.DBPatVar
instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Pattern' a)
instance (Agda.TypeChecking.Substitute.Class.Subst t 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 (Agda.Syntax.Common.Arg 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.Syntax.Common.Dom t)
instance Agda.TypeChecking.Reduce.InstantiateFull t => Agda.TypeChecking.Reduce.InstantiateFull [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 (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 a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Elim' a)
instance Agda.TypeChecking.Reduce.InstantiateFull e => Agda.TypeChecking.Reduce.InstantiateFull (Data.Map.Internal.Map k e)
instance Agda.TypeChecking.Reduce.InstantiateFull e => Agda.TypeChecking.Reduce.InstantiateFull (Data.HashMap.Base.HashMap k e)
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Abstract.Name.ModuleName
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Scope.Base.Scope
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 t a, Agda.TypeChecking.Reduce.InstantiateFull a) => Agda.TypeChecking.Reduce.InstantiateFull (Agda.Syntax.Internal.Tele a)
instance Agda.TypeChecking.Reduce.InstantiateFull GHC.Types.Char
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.RewriteRule
instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.Open a)
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.WithArity a)
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.Interface
instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (Agda.TypeChecking.Monad.Base.Builtin a)
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Abstract.Name.QName
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.Syntax.Internal.ConHead
instance Agda.TypeChecking.Reduce.InstantiateFull a => Agda.TypeChecking.Reduce.InstantiateFull (GHC.Maybe.Maybe 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 Agda.Syntax.Internal.Sort
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Elim
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.Level
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.LevelAtom
instance (Agda.TypeChecking.Substitute.Class.Subst t 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.Common.Named name t)
instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise (Agda.Syntax.Common.Dom t)
instance Agda.TypeChecking.Reduce.Normalise t => Agda.TypeChecking.Reduce.Normalise [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 a => Agda.TypeChecking.Reduce.Normalise (Agda.TypeChecking.Monad.Base.Closure a)
instance (Agda.TypeChecking.Substitute.Class.Subst t 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 GHC.Types.Bool
instance Agda.TypeChecking.Reduce.Normalise GHC.Types.Int
instance Agda.TypeChecking.Reduce.Normalise GHC.Types.Char
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.ConPatternInfo
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.DBPatVar
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 e => Agda.TypeChecking.Reduce.Normalise (Data.Map.Internal.Map k e)
instance Agda.TypeChecking.Reduce.Normalise a => Agda.TypeChecking.Reduce.Normalise (GHC.Maybe.Maybe a)
instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Monad.Base.Candidate
instance Agda.TypeChecking.Reduce.Normalise Agda.Syntax.Internal.EqualityView
instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Reduce.Simplify Agda.Syntax.Internal.Elim
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.Reduce.Simplify Agda.Syntax.Internal.LevelAtom
instance (Agda.TypeChecking.Substitute.Class.Subst t 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.Common.Arg 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.Syntax.Common.Dom t)
instance Agda.TypeChecking.Reduce.Simplify t => Agda.TypeChecking.Reduce.Simplify [t]
instance Agda.TypeChecking.Reduce.Simplify e => Agda.TypeChecking.Reduce.Simplify (Data.Map.Internal.Map k e)
instance Agda.TypeChecking.Reduce.Simplify a => Agda.TypeChecking.Reduce.Simplify (GHC.Maybe.Maybe a)
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 a => Agda.TypeChecking.Reduce.Simplify (Agda.TypeChecking.Monad.Base.Closure a)
instance (Agda.TypeChecking.Substitute.Class.Subst t 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 GHC.Types.Bool
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.Reduce.Reduce Agda.Syntax.Internal.LevelAtom
instance (Agda.TypeChecking.Substitute.Class.Subst t 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 (Agda.Syntax.Common.Arg t)
instance Agda.TypeChecking.Reduce.Reduce t => Agda.TypeChecking.Reduce.Reduce (Agda.Syntax.Common.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.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 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.Instantiate Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Level
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.LevelAtom
instance Agda.TypeChecking.Reduce.Instantiate a => Agda.TypeChecking.Reduce.Instantiate (Agda.Syntax.Internal.Blocked a)
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Sort
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Elim
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.Common.Dom 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 [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 a => Agda.TypeChecking.Reduce.Instantiate (Agda.TypeChecking.Monad.Base.Closure a)
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.Telescope
instance Agda.TypeChecking.Reduce.Instantiate Agda.TypeChecking.Monad.Base.Constraint
instance Agda.TypeChecking.Reduce.Instantiate e => Agda.TypeChecking.Reduce.Instantiate (Data.Map.Internal.Map k e)
instance Agda.TypeChecking.Reduce.Instantiate Agda.TypeChecking.Monad.Base.Candidate
instance Agda.TypeChecking.Reduce.Instantiate Agda.Syntax.Internal.EqualityView

module Agda.TypeChecking.Telescope

-- | Flatten telescope: (Γ : Tel) -> [Type Γ]
flattenTel :: Subst t 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

-- | Get the suggested names from a telescope
teleNames :: Telescope -> [ArgName]
teleArgNames :: Telescope -> [Arg ArgName]
teleArgs :: DeBruijn a => Tele (Dom t) -> [Arg a]
withNamedArgsFromTel :: [a] -> Telescope -> [NamedArg a]
teleNamedArgs :: DeBruijn a => Telescope -> [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

-- | 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
instantiateTelescopeN :: Telescope -> [(Int, Term)] -> Maybe (Telescope, Substitution)

-- | 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 -> Term -> 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 :: Type -> TCM TelView

-- | telViewUpTo n t takes off the first n function types
--   of t. Takes off all if n < 0.
telViewUpTo :: Int -> Type -> TCM 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' :: Int -> (Dom Type -> Bool) -> Type -> TCM TelView
telViewPath :: Type -> TCM TelView

-- | telViewUpToPath n t takes off $t$ the first n (or
--   arbitrary many if n < 0) function domains or Path types.
telViewUpToPath :: Int -> Type -> TCM TelView

-- | 
--   
- [ (i,(x,y))  ] = [(i=0) -> x, (i=1) -> y]
--   
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' :: Int -> Type -> TCM (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 :: Int -> Type -> TCM (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 :: Int -> Type -> TCM (TelView, Boundary)
telViewPathBoundaryP :: Type -> TCM (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]
pathViewAsPi :: Type -> TCM (Either (Dom Type, Abs Type) Type)
pathViewAsPi' :: Type -> TCM (Either ((Dom Type, Abs Type), (Term, Term)) Type)
pathViewAsPi'whnf :: TCM (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 :: Type -> TCM (Either (Dom Type, Abs Type) Type)
telView'UpToPath :: Int -> Type -> TCM TelView
telView'Path :: Type -> TCM TelView
isPath :: Type -> TCM (Maybe (Dom Type, Abs Type))
telePatterns :: (DeBruijn a, DeBruijn (Pattern' a)) => Telescope -> Boundary -> [NamedArg (Pattern' a)]
telePatterns' :: (DeBruijn a, DeBruijn (Pattern' 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, MonadTCM 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) => Type -> a -> m Type

-- | Compute type arity
typeArity :: Type -> TCM Nat
data OutputTypeName
OutputTypeName :: QName -> OutputTypeName
OutputTypeVar :: OutputTypeName
OutputTypeVisiblePi :: OutputTypeName
OutputTypeNameNotYetKnown :: 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]

-- | 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.  checkSyntacticEquality v v' =
--   do (v,v') <- instantiateFull (v,v') return ((v,v'), v==v') 
--   only that v,v' are only fully instantiated to the depth where
--   they are equal.
checkSyntacticEquality :: (SynEq a, MonadReduce m) => a -> a -> m ((a, a), 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.LevelAtom
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 (Agda.Syntax.Internal.Elim' a)
instance (Agda.TypeChecking.Substitute.Class.Subst t 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.Common.Dom a)
instance Agda.TypeChecking.SyntacticEquality.SynEq Agda.Syntax.Common.ArgInfo

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

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.
levelType :: TCM Type
levelSucFunction :: TCM (Term -> Term)
builtinLevelKit :: HasBuiltins m => m LevelKit

-- | Raises an error if no level kit is available.
requireLevels :: TCM LevelKit

-- | Checks whether level kit is fully available.
haveLevels :: TCM Bool
unLevel :: HasBuiltins m => Term -> m Term
reallyUnLevelView :: HasBuiltins m => Level -> m Term
unlevelWithKit :: LevelKit -> Level -> Term
unPlusV :: Term -> (Term -> Term) -> PlusLevel -> Term
maybePrimCon :: TCM Term -> TCM (Maybe ConHead)
maybePrimDef :: TCM Term -> TCM (Maybe QName)
levelView :: (HasBuiltins m, MonadReduce m, MonadDebug m) => Term -> m Level
levelView' :: (HasBuiltins m, MonadReduce m, MonadDebug m) => Term -> m Level
levelLub :: Level -> Level -> Level
subLevel :: Integer -> Level -> Maybe Level

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

-- | 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.Free.Reduce.ForceNotFree (Agda.Syntax.Common.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' 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.LevelAtom
instance Agda.TypeChecking.Free.Reduce.ForceNotFree Agda.Syntax.Internal.Sort

-- | Tools for DisplayTerm and DisplayForm.
module Agda.TypeChecking.DisplayForm

-- | Convert a DisplayTerm into a Term.
dtermToTerm :: DisplayTerm -> Term

-- | Get the arities of all display forms for a name.
displayFormArities :: QName -> TCM [Int]

-- | 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 :: QName -> Elims -> TCM (Maybe DisplayTerm)

-- | Match a DisplayForm q ps = v against q es.
--   Return the DisplayTerm v[us] if the match was
--   successful, i.e., es / ps = Just us.
matchDisplayForm :: DisplayForm -> Elims -> MaybeT TCM (DisplayForm, DisplayTerm)

-- | Class Match for matching a term p in the role of a
--   pattern against a term v.
--   
--   The 0th variable in p plays the role of a place holder
--   (pattern variable). Each occurrence of var 0 in p
--   stands for a different pattern variable.
--   
--   The result of matching, if successful, is a list of solutions for the
--   pattern variables, in left-to-right order.
--   
--   The 0th variable is in scope in the input v, but should not
--   actually occur! In the output solution, the 0th variable is
--   no longer in scope. (It has been substituted by (throwImpossible
--   (Impossible "srcfullAgdaTypeCheckingDisplayForm.hs"
--   126)) which corresponds to a raise by -1).
class Match a
match :: Match a => a -> a -> MaybeT TCM [WithOrigin Term]

-- | Substitute terms with origin into display terms, replacing variables
--   along with their origins.
--   
--   The purpose is to replace the pattern variables in a with-display
--   form, and only on the top level of the lhs. Thus, we are happy to fall
--   back to ordinary substitution where it does not matter. This fixes
--   issue #2590.
class SubstWithOrigin a
substWithOrigin :: SubstWithOrigin a => Substitution -> [WithOrigin Term] -> a -> a
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' 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' 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

module Agda.Termination.RecCheck
recursive :: [QName] -> TCM Bool

-- | anysDef names a returns all definitions from names
--   that are used in a.
anyDefs :: GetDefs a => [QName] -> a -> TCM [QName]

-- | 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.
type IM = TCMT (InputT IO)
runIM :: IM a -> TCM a

-- | Line reader. The line reader history is not stored between sessions.
readline :: String -> IM (Maybe String)

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.Compiler.Treeless.Unused
usedArguments :: QName -> TTerm -> TCM [Bool]
stripUnusedArguments :: [Bool] -> TTerm -> TTerm

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

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

-- | Insert unsafeCoerce (in the form of TCoerce) everywhere it's
--   needed in the right-hand side of a definition.
addCoercions :: TTerm -> TCM TTerm

-- | A command which calls a compiler
module Agda.Compiler.CallCompiler

-- | Calls a compiler:
--   
--   
--   
- Checks the exit code to see if the compiler exits successfully. If
--   not, then an exception is raised, containing the text the compiler
--   printed to stderr (if any).
--   
- Uses the debug printout machinery to relay any progress
--   information the compiler prints to stdout.
--   
callCompiler :: Bool -> FilePath -> [String] -> TCM ()

-- | Generalisation of callCompiler where the raised exception is
--   returned.
callCompiler' :: FilePath -> [String] -> TCM (Maybe String)

module Agda.TypeChecking.DeadCode

-- | Run before serialisation to remove any definitions that are not
--   reachable from the public interface to the module.
eliminateDeadCode :: DisplayForms -> Signature -> TCM (DisplayForms, Signature)

module Agda.Syntax.Translation.ReflectedToAbstract
type Names = [Name]
type WithNames a = ReaderT Names TCM a

-- | Adds a new unique name to the current context.
withName :: String -> (Name -> WithNames a) -> WithNames a

-- | Returns the name of the variable with the given de Bruijn index.
askName :: Int -> WithNames (Maybe Name)
class ToAbstract r a | r -> a
toAbstract :: ToAbstract r a => r -> WithNames a

-- | Translate reflected syntax to abstract, using the names from the
--   current typechecking context.
toAbstract_ :: ToAbstract r a => r -> TCM a

-- | Drop implicit arguments unless --show-implicit is on.
toAbstractWithoutImplicit :: ToAbstract r a => r -> TCM a
mkDef :: QName -> TCM Expr
mkSet :: Expr -> Expr
toAbstractPats :: [Arg Pattern] -> WithNames (Names, [NamedArg Pattern])
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r a => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Common.Named name r) (Agda.Syntax.Common.Named name a)
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r a => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Common.Arg r) (Agda.Syntax.Common.NamedArg a)
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract [Agda.Syntax.Common.Arg Agda.Syntax.Reflected.Term] [Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Expr]
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r Agda.Syntax.Abstract.Expr => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Common.Dom r, Agda.Syntax.Abstract.Name.Name) Agda.Syntax.Abstract.TypedBinding
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Abstract.Expr, Agda.Syntax.Reflected.Elim) Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Abstract.Expr, Agda.Syntax.Reflected.Elims) Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract r a => Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Reflected.Abs r) (a, Agda.Syntax.Abstract.Name.Name)
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Literal.Literal Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Reflected.Term Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Reflected.Sort Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract Agda.Syntax.Reflected.Pattern (Agda.Syntax.Translation.ReflectedToAbstract.Names, Agda.Syntax.Abstract.Pattern)
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract (Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Reflected.Clause) Agda.Syntax.Abstract.Clause
instance Agda.Syntax.Translation.ReflectedToAbstract.ToAbstract [Agda.Syntax.Abstract.Name.QNamed Agda.Syntax.Reflected.Clause] [Agda.Syntax.Abstract.Clause]

-- | 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 c | a -> c
toConcrete :: ToConcrete a c => a -> AbsToCon c
bindToConcrete :: ToConcrete a c => a -> (c -> AbsToCon b) -> AbsToCon b

-- | Translate something in a context of the given precedence.
toConcreteCtx :: ToConcrete a c => Precedence -> a -> AbsToCon c
abstractToConcrete_ :: ToConcrete a c => a -> TCM c
abstractToConcreteScope :: ToConcrete a c => ScopeInfo -> a -> TCM c
abstractToConcreteHiding :: (LensHiding i, ToConcrete a c) => i -> a -> TCM c
runAbsToCon :: AbsToCon c -> TCM c
data RangeAndPragma
RangeAndPragma :: Range -> Pragma -> RangeAndPragma
abstractToConcreteCtx :: ToConcrete a c => Precedence -> a -> TCM c
withScope :: ScopeInfo -> AbsToCon a -> AbsToCon a
preserveInteractionIds :: AbsToCon a -> AbsToCon a

-- | We put the translation into TCM in order to print debug messages.
type AbsToCon = ReaderT Env TCM
data Env
noTakenNames :: AbsToCon a -> AbsToCon a
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 Agda.Syntax.Concrete.Expr
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Translation.AbstractToConcrete.FreshenName Agda.Syntax.Abstract.Name.Name
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Translation.AbstractToConcrete.BindingPattern Agda.Syntax.Abstract.Pattern
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.SplitPattern Agda.Syntax.Abstract.Pattern) Agda.Syntax.Abstract.Pattern
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.SplitPattern (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)) (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Pattern Agda.Syntax.Concrete.Pattern
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.UserPattern Agda.Syntax.Abstract.Pattern) Agda.Syntax.Abstract.Pattern
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Translation.AbstractToConcrete.UserPattern (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)) (Agda.Syntax.Common.NamedArg Agda.Syntax.Abstract.Pattern)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Declaration [Agda.Syntax.Concrete.Declaration]
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Translation.AbstractToConcrete.RangeAndPragma Agda.Syntax.Concrete.Pragma
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete [a] [c]
instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a1 c1, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a2 c2) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Data.Either.Either a1 a2) (Data.Either.Either c1 c2)
instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a1 c1, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a2 c2) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (a1, a2) (c1, c2)
instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a1 c1, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a2 c2, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a3 c3) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (a1, a2, a3) (c1, c2, c3)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg c)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.WithHiding a) (Agda.Syntax.Common.WithHiding c)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.Named name a) (Agda.Syntax.Common.Named name c)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Name.Name Agda.Syntax.Concrete.Name.Name
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.BindName Agda.Syntax.Concrete.BoundName
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Name.QName Agda.Syntax.Concrete.Name.QName
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.Name.ModuleName Agda.Syntax.Concrete.Name.QName
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Scope.Base.AbstractName Agda.Syntax.Concrete.Name.QName
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Scope.Base.ResolvedName Agda.Syntax.Concrete.Name.QName
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Concrete.FieldAssignment' a) (Agda.Syntax.Concrete.FieldAssignment' c)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LamBinding Agda.Syntax.Concrete.LamBinding
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.TypedBinding Agda.Syntax.Concrete.TypedBinding
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LetBinding [Agda.Syntax.Concrete.Declaration]
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.WhereDeclarations Agda.Syntax.Concrete.WhereClause
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.RHS (Agda.Syntax.Concrete.RHS, [Agda.Syntax.Concrete.Expr], [Agda.Syntax.Concrete.Expr], [Agda.Syntax.Concrete.Declaration])
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (GHC.Maybe.Maybe Agda.Syntax.Abstract.Name.QName) (GHC.Maybe.Maybe Agda.Syntax.Concrete.Name.Name)
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Common.Constr Agda.Syntax.Abstract.Constructor) Agda.Syntax.Concrete.Declaration
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a Agda.Syntax.Concrete.LHS => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Syntax.Abstract.Clause' a) [Agda.Syntax.Concrete.Declaration]
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.ModuleApplication Agda.Syntax.Concrete.ModuleApplication
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.SpineLHS Agda.Syntax.Concrete.LHS
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LHS Agda.Syntax.Concrete.LHS
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Abstract.LHSCore Agda.Syntax.Concrete.Pattern
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.Syntax.Common.InteractionId Agda.Syntax.Concrete.Expr
instance Agda.Syntax.Translation.AbstractToConcrete.ToConcrete Agda.TypeChecking.Monad.Base.NamedMeta Agda.Syntax.Concrete.Expr

module Agda.Syntax.Abstract.Pretty
showA :: (Show c, ToConcrete a c) => a -> TCM String
prettyA :: (Pretty c, ToConcrete a c) => a -> TCM Doc
prettyAs :: (Pretty c, ToConcrete a [c]) => a -> TCM Doc

-- | Variant of showA which does not insert outermost parentheses.
showATop :: (Show c, ToConcrete a c) => a -> TCM String

-- | Variant of prettyA which does not insert outermost parentheses.
prettyATop :: (Pretty c, ToConcrete a c) => a -> TCM Doc

-- | Translating from internal syntax to abstract syntax. Enables nice
--   pretty printing of internal syntax.
--   
--   TODO
--   
--   
--   
- numbers on metas
--   
- fake dependent functions to independent functions
--   
- meta parameters
--   
- shadowing
--   
module Agda.Syntax.Translation.InternalToAbstract
class Reify i a | i -> a
reify :: Reify i a => i -> TCM a
reifyWhen :: Reify i a => Bool -> i -> TCM a
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 :: MonadTCM tcm => [NamedArg DeBruijnPattern] -> tcm [NamedArg Pattern]
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 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 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.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) Agda.Syntax.Abstract.Clause
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Translation.InternalToAbstract.NamedClause Agda.Syntax.Abstract.Clause
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Abstract.Name.Name Agda.Syntax.Abstract.Name.Name
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Abstract.Expr Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Common.MetaId Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.TypeChecking.Monad.Base.DisplayTerm Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Literal.Literal Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Term Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify i a => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Common.Named n i) (Agda.Syntax.Common.Named n a)
instance Agda.Syntax.Translation.InternalToAbstract.Reify i a => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Common.Arg i) (Agda.Syntax.Common.Arg a)
instance Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Abstract.Name.QNamed Agda.TypeChecking.Monad.Base.System) [Agda.Syntax.Abstract.Clause]
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Type Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Sort Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Level Agda.Syntax.Abstract.Expr
instance (Agda.TypeChecking.Free.Lazy.Free i, Agda.Syntax.Translation.InternalToAbstract.Reify i a) => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Internal.Abs i) (Agda.Syntax.Abstract.Name.Name, a)
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.Syntax.Internal.Telescope Agda.Syntax.Abstract.Telescope
instance Agda.Syntax.Translation.InternalToAbstract.Reify i a => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Common.Dom i) (Agda.Syntax.Common.Arg a)
instance Agda.Syntax.Translation.InternalToAbstract.Reify i a => Agda.Syntax.Translation.InternalToAbstract.Reify (Agda.Syntax.Internal.Elim' i) (Agda.Syntax.Internal.Elim' a)
instance Agda.Syntax.Translation.InternalToAbstract.Reify i a => Agda.Syntax.Translation.InternalToAbstract.Reify [i] [a]
instance (Agda.Syntax.Translation.InternalToAbstract.Reify i1 a1, Agda.Syntax.Translation.InternalToAbstract.Reify i2 a2) => Agda.Syntax.Translation.InternalToAbstract.Reify (i1, i2) (a1, a2)
instance (Agda.Syntax.Translation.InternalToAbstract.Reify i1 a1, Agda.Syntax.Translation.InternalToAbstract.Reify i2 a2, Agda.Syntax.Translation.InternalToAbstract.Reify i3 a3) => Agda.Syntax.Translation.InternalToAbstract.Reify (i1, i2, i3) (a1, a2, a3)
instance (Agda.Syntax.Translation.InternalToAbstract.Reify i1 a1, Agda.Syntax.Translation.InternalToAbstract.Reify i2 a2, Agda.Syntax.Translation.InternalToAbstract.Reify i3 a3, Agda.Syntax.Translation.InternalToAbstract.Reify i4 a4) => Agda.Syntax.Translation.InternalToAbstract.Reify (i1, i2, i3, i4) (a1, a2, a3, a4)

module Agda.TypeChecking.Pretty
type Doc = Doc
comma :: TCM Doc
colon :: TCM Doc
equals :: TCM Doc
pretty :: Pretty a => a -> TCM Doc
prettyA :: (Pretty c, ToConcrete a c) => a -> TCM Doc
prettyAs :: (Pretty c, ToConcrete a [c]) => a -> TCM Doc
text :: String -> TCM Doc
multiLineText :: String -> TCM Doc
pwords :: String -> [TCM Doc]
fwords :: String -> TCM Doc
sep :: [TCM Doc] -> TCM Doc
fsep :: [TCM Doc] -> TCM Doc
hsep :: [TCM Doc] -> TCM Doc
hcat :: [TCM Doc] -> TCM Doc
vcat :: [TCM Doc] -> TCM Doc
hang :: TCM Doc -> Int -> TCM Doc -> TCM Doc
($$) :: TCM Doc -> TCM Doc -> TCM Doc
infixl 5 $$
($+$) :: TCM Doc -> TCM Doc -> TCM Doc
infixl 5 $+$
(<>) :: TCM Doc -> TCM Doc -> TCM Doc
infixl 6 <>
(<+>) :: TCM Doc -> TCM Doc -> TCM Doc
infixl 6 <+>
(<?>) :: TCM Doc -> TCM Doc -> TCM Doc
infixl 6 <?>
nest :: Int -> TCM Doc -> TCM Doc
braces :: TCM Doc -> TCM Doc
dbraces :: TCM Doc -> TCM Doc
brackets :: TCM Doc -> TCM Doc
parens :: TCM Doc -> TCM Doc
pshow :: Show a => a -> TCM Doc

-- | Comma-separated list in brackets.
prettyList :: [TCM Doc] -> TCM Doc

-- | prettyList without the brackets.
prettyList_ :: [TCM Doc] -> TCM Doc
punctuate :: TCM Doc -> [TCM Doc] -> [TCM Doc]
class PrettyTCM a
prettyTCM :: PrettyTCM a => a -> TCM Doc

-- | Pretty print with a given context precedence
prettyTCMCtx :: PrettyTCM a => Precedence -> a -> TCM Doc
newtype PrettyContext
PrettyContext :: Context -> PrettyContext

-- | Proper pretty printing of patterns:
prettyTCMPatterns :: [NamedArg DeBruijnPattern] -> TCM [Doc]
prettyTCMPatternList :: [NamedArg DeBruijnPattern] -> TCM Doc

-- | Pairing something with a node (for printing only).
data WithNode n a
WithNode :: n -> a -> WithNode n a
instance Agda.TypeChecking.Pretty.PrettyTCM n => Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Pretty.WithNode n Agda.TypeChecking.Positivity.Occurrence.Occurrence)
instance (Agda.TypeChecking.Pretty.PrettyTCM n, Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Pretty.WithNode n 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.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.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.TypeChecking.Monad.Base.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 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.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.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Reflected.Term
instance (Agda.Utils.Pretty.Pretty a, Agda.TypeChecking.Pretty.PrettyTCM a, Agda.TypeChecking.Substitute.Class.Subst a 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 a => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Internal.Blocked a)
instance (Agda.Syntax.Translation.InternalToAbstract.Reify a e, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete e c, Agda.Utils.Pretty.Pretty c) => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Named_ a)
instance (Agda.Syntax.Translation.InternalToAbstract.Reify a e, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete e c, Agda.Utils.Pretty.Pretty c) => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Arg a)
instance (Agda.Syntax.Translation.InternalToAbstract.Reify a e, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete e c, Agda.Utils.Pretty.Pretty c) => Agda.TypeChecking.Pretty.PrettyTCM (Agda.Syntax.Common.Dom 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.ArgName
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.Common.Relevance
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.ProblemConstraint
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Constraint
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.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' 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.Syntax.Internal.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

module Agda.TypeChecking.Telescope.Path

-- | In an ambient context Γ, telePiPath f Δ 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 | u_i .b :
--   (telePiPath f Δ1 t bs)(i = b) Γ ⊢ telePiPath f Δ t bs
telePiPath :: (Abs Type -> Abs Type) -> Telescope -> Type -> Boundary -> TCM Type
iApplyVars :: DeBruijn a => [NamedArg (Pattern' a)] -> [Int]

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 :: MonadTCM tcm => Nat -> tcm BoundedSize

-- | Whenever we create a bounded size meta, add a constraint expressing
--   the bound. In boundedSizeMetaHook v tel a, tel
--   includes the current context.
boundedSizeMetaHook :: Term -> Telescope -> Type -> TCM ()

-- | 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 :: Comparison -> Type -> Term -> Term -> QName -> Elims -> QName -> Elims -> TCM ()

-- | Compute the deep size view of a term. Precondition: sized types are
--   enabled.
deepSizeView :: Term -> TCM DeepSizeView
sizeMaxView :: Term -> TCM SizeMaxView

-- | Compare two sizes.
compareSizes :: Comparison -> Term -> Term -> TCM ()

-- | Compare two sizes in max view.
compareMaxViews :: Comparison -> SizeMaxView -> SizeMaxView -> TCM ()

-- | compareBelowMax u vs checks u <= max vs.
--   Precondition: size vs >= 2
compareBelowMax :: DeepSizeView -> SizeMaxView -> TCM ()
compareSizeViews :: Comparison -> DeepSizeView -> DeepSizeView -> TCM ()

-- | If envAssignMetas then postpone as constraint, otherwise, fail
--   hard. Failing is required if we speculatively test several
--   alternatives.
giveUp :: Comparison -> Type -> Term -> Term -> TCM ()

-- | Checked whether a size constraint is trivial (like X <=
--   X+1).
trivial :: Term -> Term -> TCM Bool

-- | Test whether a problem consists only of size constraints.
isSizeProblem :: ProblemId -> TCM Bool

-- | Test is a constraint speaks about sizes.
isSizeConstraint :: Closure Constraint -> TCM Bool

-- | Take out all size constraints (DANGER!).
takeSizeConstraints :: TCM [Closure Constraint]

-- | Find the size constraints.
getSizeConstraints :: TCM [Closure Constraint]

-- | 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 :: [Closure Constraint] -> 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 :: Term -> TCM (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

-- | Main function. Uses the old solver for size constraints using
--   Agda.Utils.Warshall. This solver does not smartly use size
--   hypotheses j : Size< i. It only checks that its computed
--   solution is compatible
oldSolveSizeConstraints :: TCM ()

-- | Old solver for size constraints using Agda.Utils.Warshall. This
--   solver does not smartly use size hypotheses j : Size< i.
oldSolver :: [(MetaId, Int)] -> [OldSizeConstraint] -> TCM Bool
instance GHC.Show.Show Agda.TypeChecking.SizedTypes.OldSizeConstraint
instance GHC.Show.Show Agda.TypeChecking.SizedTypes.OldSizeExpr
instance GHC.Classes.Eq Agda.TypeChecking.SizedTypes.OldSizeExpr
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.OldSizeConstraint
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.SizedTypes.OldSizeExpr

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 :: Hiding -> Origin -> FlexibleVarKind -> Maybe Int -> a -> FlexibleVar a
[flexHiding] :: FlexibleVar a -> Hiding
[flexOrigin] :: FlexibleVar a -> Origin
[flexKind] :: FlexibleVar a -> FlexibleVarKind
[flexPos] :: FlexibleVar a -> Maybe Int
[flexVar] :: FlexibleVar a -> a
allFlexVars :: 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.
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.
[_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]
[_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 -> AsBinding
data DotPattern
Dot :: Expr -> Term -> Dom Type -> DotPattern
data AbsurdPattern
Absurd :: Range -> Type -> AbsurdPattern

-- | 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] -> 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]
lhsTel :: Lens' Telescope (LHSState a)
lhsOutPat :: Lens' [NamedArg DeBruijnPattern] (LHSState a)
lhsProblem :: Lens' (Problem a) (LHSState a)
lhsTarget :: Lens' (Arg Type) (LHSState a)
instance GHC.Show.Show (Agda.TypeChecking.Rules.LHS.Problem.Problem a)
instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Problem.FlexChoice
instance GHC.Classes.Eq Agda.TypeChecking.Rules.LHS.Problem.FlexChoice
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.FlexibleVarKind
instance GHC.Classes.Eq Agda.TypeChecking.Rules.LHS.Problem.FlexibleVarKind
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term (Agda.TypeChecking.Rules.LHS.Problem.Problem a)
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Rules.LHS.Problem.AbsurdPattern
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.AbsurdPattern
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Rules.LHS.Problem.DotPattern
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Problem.DotPattern
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term 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.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.LensHiding (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a)
instance Agda.Syntax.Common.LensOrigin (Agda.TypeChecking.Rules.LHS.Problem.FlexibleVar a)
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.Syntax.Abstract.ProblemEq

module Agda.TypeChecking.Rules.Display
checkDisplayPragma :: QName -> [NamedArg Pattern] -> Expr -> TCM ()

module Agda.TypeChecking.Quote
data QuotingKit
QuotingKit :: (Term -> ReduceM Term) -> (Type -> ReduceM Term) -> (Clause -> 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
[quoteClauseWithKit] :: QuotingKit -> Clause -> 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 :: AbsolutePath -> MetaId -> Term
quoteTerm :: Term -> TCM Term
quoteType :: Type -> TCM Term
quoteDom :: Dom Type -> TCM Term
quoteDefn :: Definition -> TCM Term
quoteList :: [Term] -> TCM Term

-- | 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 :: Dom a -> Dom 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 :: TCM a -> TCM a

-- | Internal workhorse, expects value of --experimental-irrelevance flag
--   as argument.
workOnTypes' :: Bool -> 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.
--   
--   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

-- | (Conditionally) wake up erased variables and make them unrestricted.
--   For instance, in an erased function argument otherwise erased
--   variables may be used, so they are awoken before type checking the
--   argument.
--   
--   Also allow the use of erased definitions.
applyQuantityToContext :: (MonadTCEnv tcm, LensQuantity q) => q -> tcm a -> tcm a

-- | (Conditionally) wake up erased variables and make them unrestricted.
--   For instance, in an erased function argument otherwise erased
--   variables may be used, so they are awoken before type checking the
--   argument.
--   
--   Precondition: Quantity /= Quantity1
applyQuantityToContextOnly :: MonadTCEnv tcm => Quantity -> 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

-- | (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.
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.
--   
--   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 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).
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 => Relevance -> a -> TCM 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 => Modality -> a -> TCM Bool

-- | Is a type a proposition? (Needs reduction.)
isPropM :: (LensSort a, MonadReduce m) => a -> m Bool
isIrrelevantOrPropM :: (LensRelevance a, LensSort a, MonadReduce 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' 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.Common.Dom a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, Agda.TypeChecking.Irrelevance.UsableModality a) => Agda.TypeChecking.Irrelevance.UsableModality (Agda.Syntax.Internal.Abs 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 Agda.Syntax.Internal.LevelAtom
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 (Agda.Syntax.Internal.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.Common.Dom a)
instance (Agda.TypeChecking.Substitute.Class.Subst t a, Agda.TypeChecking.Irrelevance.UsableRelevance a) => Agda.TypeChecking.Irrelevance.UsableRelevance (Agda.Syntax.Internal.Abs a)

-- | 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 :: Sort -> TCM Sort
sortFitsIn :: Sort -> Sort -> TCM ()
hasBiggerSort :: Sort -> TCM ()

-- | Infer the sort of a pi type. If we can compute the sort straight away,
--   return that. Otherwise, return PiSort s1 s2 and add a
--   constraint to ensure we can compute the sort eventually.
inferPiSort :: Sort -> Abs Sort -> TCM Sort

-- | As inferPiSort, but for a nondependent function type.
inferFunSort :: Sort -> Sort -> TCM Sort
ptsRule :: Sort -> Abs Sort -> Sort -> TCM ()

-- | Non-dependent version of ptsRule
ptsRule' :: Sort -> Sort -> Sort -> TCM ()
hasPTSRule :: Sort -> Abs Sort -> TCM ()

-- | Recursively check that an iterated function type constructed by
--   telePi is well-sorted.
checkTelePiSort :: Type -> TCM ()

module Agda.TypeChecking.Records
mkCon :: ConHead -> ConInfo -> Args -> Term

-- | Order the fields of a record construction.
orderFields :: forall 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. QName -> (Name -> a) -> [FieldAssignment' a] -> [Arg Name] -> TCM [NamedArg a]

-- | The name of the module corresponding to a record.
recordModule :: QName -> ModuleName

-- | Get the definition for a record. Throws an exception if the name does
--   not refer to a record or the record is abstract.
getRecordDef :: (MonadTCM m, HasConstInfo 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 :: QName -> TCM [Arg Name]
recordFieldNames :: Defn -> [Arg 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 [Arg QName]

-- | Returns the given record type's constructor name (with an empty
--   range).
getRecordConstructor :: QName -> TCM 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 :: (MonadReduce m, HasConstInfo 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 :: (MonadReduce m, HasConstInfo 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 :: (HasConstInfo m, MonadReduce m, MonadDebug 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 :: Term -> Type -> ProjOrigin -> QName -> TCM (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.
isEtaRecord :: HasConstInfo m => QName -> m Bool
isEtaCon :: 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 :: QName -> TCM Bool

-- | Turn off eta for unguarded recursive records. Projections do not
--   preserve guardedness.
unguardedRecord :: 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 :: Int -> Telescope -> TCM (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 :: (MonadTCM m, HasConstInfo m, MonadDebug m) => QName -> Args -> Term -> m (Telescope, Args)

-- | Eta expand a record regardless of whether it's an eta-record or not.
forceEtaExpandRecord :: (MonadTCM m, HasConstInfo m, MonadDebug m) => QName -> Args -> Term -> m (Telescope, Args)
etaExpandRecord' :: (MonadTCM m, HasConstInfo m, MonadDebug m) => Bool -> QName -> Args -> Term -> m (Telescope, Args)
etaExpandRecord_ :: (MonadTCEnv m, HasOptions m, MonadDebug m) => QName -> Args -> Defn -> Term -> m (Telescope, ConHead, ConInfo, Args)
etaExpandRecord'_ :: (MonadTCEnv m, HasOptions m, MonadDebug 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.
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 :: QName -> Args -> TCM (Either MetaId Bool)
isSingletonRecordModuloRelevance :: QName -> Args -> TCM (Either MetaId Bool)

-- | Return the unique (closed) inhabitant if exists. In case of counting
--   irrelevance in, the returned inhabitant contains dummy terms.
isSingletonRecord' :: Bool -> QName -> Args -> TCM (Either MetaId (Maybe Term))

-- | Check whether a type has a unique inhabitant and return it. Can be
--   blocked by a metavar.
isSingletonType :: Type -> TCM (Either MetaId (Maybe Term))

-- | Check whether a type has a unique inhabitant (irrelevant parts
--   ignored). Can be blocked by a metavar.
isSingletonTypeModuloRelevance :: MonadTCM tcm => Type -> tcm (Either MetaId Bool)
isSingletonType' :: Bool -> Type -> TCM (Either MetaId (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 :: Term -> Type -> TCM (Maybe Int)

-- | Auxiliary function.
emap :: (a -> b) -> Either c (Maybe a) -> Either c (Maybe b)

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

-- | Functions for inserting implicit arguments at the right places.
module Agda.TypeChecking.Implicit

-- | implicitArgs n expand t generates up to n implicit
--   arguments metas (unbounded if n<0), as long as t
--   is a function type and expand holds on the hiding info of its
--   domain.
implicitArgs :: Int -> (Hiding -> Bool) -> Type -> TCM (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 :: Int -> (Hiding -> ArgName -> Bool) -> Type -> TCM (NamedArgs, Type)

-- | Create a metavariable according to the Hiding info.
newMetaArg :: ArgInfo -> ArgName -> Type -> TCM (MetaId, Term)

-- | Create a questionmark according to the Hiding info.
newInteractionMetaArg :: ArgInfo -> ArgName -> Type -> TCM (MetaId, Term)

-- | Possible results of insertImplicit.
data ImplicitInsertion

-- | Success: this many implicits have to be inserted (list can be empty).
ImpInsert :: [Hiding] -> 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 -> [Arg ArgName] -> ImplicitInsertion
instance GHC.Show.Show Agda.TypeChecking.Implicit.ImplicitInsertion

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 :: ExpandHidden -> [NamedArg Pattern] -> Telescope -> TCM [NamedArg Pattern]

-- | Insert trailing SizeLt patterns, if any.
insertImplicitSizeLtPatterns :: Type -> TCM [NamedArg Pattern]

-- | Insert implicit patterns in a list of patterns. Even if
--   DontExpandLast, trailing SIZELT patterns are inserted.
insertImplicitPatternsT :: ExpandHidden -> [NamedArg Pattern] -> Type -> TCM [NamedArg Pattern]

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
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 ["_", "just a"] [] [] [] 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 :: LHSState a -> TCM (LHSState a)

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)

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

-- | Compute the pattern variables of a term or term-like thing.
class ForcedVariables a
forcedVariables :: ForcedVariables a => a -> [(Modality, Nat)]
forcedVariables :: (ForcedVariables a, ForcedVariables b, Foldable t, a ~ t b) => a -> [(Modality, Nat)]
isForced :: IsForced -> Bool
nextIsForced :: [IsForced] -> (IsForced, [IsForced])

-- | Move bindings for forced variables to unforced positions.
forcingTranslation :: [NamedArg DeBruijnPattern] -> TCM [NamedArg DeBruijnPattern]

-- | Applies the forcing translation in order to update modalities of
--   forced arguments in the telescope. This is used before checking a
--   right-hand side in order to make sure all uses of forced arguments
--   agree with the relevance of the position where the variable will
--   ultimately be bound. Precondition: the telescope types the bound
--   variables of the patterns.
forceTranslateTelescope :: Telescope -> [NamedArg DeBruijnPattern] -> TCM Telescope

-- | Rebind a forced pattern in a non-forced position. The forced pattern
--   has already been dotted by dotForcedPatterns, so the remaining
--   task is to find a dot pattern in an unforced position that can be
--   turned into a proper match of the forced pattern.
--   
--   For instance (with patterns prettified to ease readability):
--   
--   rebindForcedPattern [.(suc n), cons .n x xs] n = [suc n, cons .n x xs]
rebindForcedPattern :: [NamedArg DeBruijnPattern] -> DeBruijnPattern -> TCM [NamedArg DeBruijnPattern]

-- | Check if the first pattern rebinds the second pattern. Almost
--   equality, but allows the first pattern to have a variable where the
--   second pattern has a dot pattern. Used to fix #3544.
rebinds :: DeBruijnPattern -> DeBruijnPattern -> Bool

-- | Dot all forced patterns and return a list of patterns that need to be
--   undotted elsewhere. Patterns that need to be undotted are those that
--   bind variables or does some actual (non-eta) matching.
dotForcedPatterns :: [NamedArg DeBruijnPattern] -> TCM ([NamedArg DeBruijnPattern], Maybe [DeBruijnPattern])
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' 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.Datatypes

-- | Get true constructor with record fields.
getConHead :: HasConstInfo m => QName -> m (Either SigError ConHead)

-- | 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 :: QName -> TCM 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 :: ConHead -> Type -> TCM (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 :: (HasConstInfo m, MonadReduce m, MonadDebug m) => ConHead -> Type -> m (Maybe ((QName, Type, Args), Type))
data ConstructorInfo

-- | Arity.
DataCon :: Nat -> ConstructorInfo

-- | List of field names.
RecordCon :: HasEta -> [Arg 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 :: QName -> TCM 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 :: QName -> TCM (Maybe Nat)

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

-- | Precondition: Name is a data or record type.
getConHeads :: QName -> TCM [ConHead]

-- | Nothing if not data or record type name.
getConHeads' :: QName -> TCM (Maybe [ConHead])

-- | Nothing if not data or record definition.
getConHeads_ :: Defn -> Maybe [ConHead]

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

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

-- | Monad for non-linear matching.
type NLM = ExceptT Blocked_ (StateT NLMState ReduceM)
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 to result of matching.
tellSub :: Relevance -> Int -> Term -> NLM ()
tellEq :: Telescope -> Telescope -> 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 -> Term -> Term -> PostponedEquation

-- | Telescope of free variables in the equation
[eqFreeVars] :: PostponedEquation -> Telescope

-- | 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 ()
reallyFree :: (MonadReduce m, Reduce a, ForceNotFree a) => IntSet -> a -> m (Either Blocked_ (Maybe a))
makeSubstitution :: Telescope -> Sub -> Substitution
checkPostponedEquations :: (MonadReduce m, HasConstInfo m, MonadDebug m) => Substitution -> PostponedEquations -> m (Maybe Blocked_)
nonLinMatch :: (MonadReduce m, HasConstInfo m, MonadDebug m, Match t a b) => Telescope -> t -> a -> b -> m (Either Blocked_ Substitution)

-- | Untyped βη-equality, does not handle things like 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 :: (MonadReduce m, HasConstInfo m) => Term -> Term -> m (Maybe Blocked_)
instance Agda.TypeChecking.Rewriting.NonLinMatch.Match t a b => Agda.TypeChecking.Rewriting.NonLinMatch.Match (Agda.Syntax.Common.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.Term) [Agda.Syntax.Internal.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.Common.Dom a) (Agda.Syntax.Common.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.NLPat 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.Utils.Null.Null Agda.TypeChecking.Rewriting.NonLinMatch.NLMState
instance Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom t a b => Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom (Agda.Syntax.Common.Dom t) (Agda.Syntax.Common.Arg a) (Agda.Syntax.Common.Arg b)
instance Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom (Agda.Syntax.Internal.Type, Agda.Syntax.Internal.Term) Agda.Syntax.Internal.Elims [Agda.Syntax.Internal.Elim' Agda.TypeChecking.Monad.Base.NLPat]
instance Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom t a b => Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom t (Agda.Syntax.Common.Dom a) (Agda.Syntax.Common.Dom b)
instance Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom () Agda.Syntax.Internal.Type Agda.TypeChecking.Monad.Base.NLPType
instance Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom () Agda.Syntax.Internal.Sort Agda.TypeChecking.Monad.Base.NLPat
instance Agda.TypeChecking.Rewriting.NonLinMatch.PatternFrom Agda.Syntax.Internal.Type Agda.Syntax.Internal.Term Agda.TypeChecking.Monad.Base.NLPat

-- | 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 :: CompiledClauses -> TCM CompiledClauses

-- | 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 GHC.Classes.Eq Agda.TypeChecking.RecordPatterns.Kind
instance Agda.TypeChecking.Monad.Base.MonadTCState Agda.TypeChecking.RecordPatterns.RecPatM
instance Agda.TypeChecking.Monad.Base.MonadTCEnv Agda.TypeChecking.RecordPatterns.RecPatM
instance Agda.TypeChecking.Monad.Debug.MonadDebug Agda.TypeChecking.RecordPatterns.RecPatM
instance Agda.TypeChecking.Monad.Base.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 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]

-- | 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'
emptyOB :: OccurrencesBuilder
(>+<) :: OccurrencesBuilder -> OccurrencesBuilder -> 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

-- | 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:
--   
--   
--   
- OccursWhere _ empty (fromList
--   [InDefOf F, InClause 0]),
--   
- OccursWhere _ empty (fromList
--   [InDefOf F, InClause 0,
--   LeftOfArrow]),
--   
- OccursWhere _ empty (fromList
--   [InDefOf F, InClause 0, LeftOfArrow,
--   LeftOfArrow]),
--   
- OccursWhere _ empty (fromList
--   [InDefOf F, InClause 0, LeftOfArrow,
--   LeftOfArrow, LeftOfArrow]),
--   
- and so on.
--   
computeEdges :: Set QName -> QName -> OccurrencesBuilder -> TCM [Edge Node (Edge OccursWhere)]
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 GHC.Classes.Ord Agda.TypeChecking.Positivity.Node
instance GHC.Classes.Eq Agda.TypeChecking.Positivity.Node
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 Agda.Utils.SemiRing.SemiRing (Agda.TypeChecking.Positivity.Edge (Data.Sequence.Internal.Seq Agda.TypeChecking.Positivity.Occurrence.OccursWhere))
instance Agda.TypeChecking.Pretty.PrettyTCM n => Agda.TypeChecking.Pretty.PrettyTCM (Agda.TypeChecking.Pretty.WithNode n (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.LevelAtom
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' 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.Common.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 Agda.Syntax.Position.HasRange Agda.TypeChecking.Positivity.Item
instance Agda.TypeChecking.Pretty.PrettyTCM (Data.Sequence.Internal.Seq Agda.TypeChecking.Positivity.Occurrence.OccursWhere)

-- | 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:
--   
--   
--   
- The type of f is of the form f : Γ → D Γ → ...
--   for some type constructor D which can never reduce.
--   
- For every reduced welltyped application f pars u ..., the
--   type of u is inferable.
--   
--   
--   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:
--   
--   
--   
- 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.
--   
- A more general analysis of which arguments are reconstructible can
--   be found inJason C. Reed, Redundancy elimination for LF LFTMP
--   2004.
--   
module Agda.TypeChecking.ProjectionLike

-- | View for a Def f (Apply a : es) where isProjection
--   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 :: Term -> TCM Term

-- | 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 :: Bool -> Term -> TCM 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:
--   
--   
--   
- The type of f must be of the shape Γ → D Γ → C
--   for D a name (Def) which is
--   eligibleForProjectionLike: data  record
--    postulate.
--   
- The application of f should only get stuck if the principal
--   argument is inferable (neutral). Thus:
--   
--   
--   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 paramters.
--   
--   For internal reasons:
--   
--   
--   
- f cannot be constructor headed
--   
- 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.
--   
--   
--   Examples for these reasons: see
--   testSucceedNotProjectionLike.agda
makeProjection :: QName -> TCM ()

module Agda.TypeChecking.Polarity

-- | Infimum on the information lattice. Invariant is bottom
--   (dominant for inf), Nonvariant is top (neutral for inf).
(/\) :: Polarity -> Polarity -> Polarity

-- | Polarity negation, swapping monotone and antitone.
neg :: Polarity -> Polarity

-- | What is the polarity of a function composition?
composePol :: Polarity -> Polarity -> Polarity
polFromOcc :: Occurrence -> 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]

-- | A quick transliterations of occurrences to polarities.
polarityFromPositivity :: QName -> TCM ()

-- | Main function of this module.
computePolarity :: [QName] -> TCM ()

-- | Data and record parameters are used as phantom arguments all over the
--   test suite (and possibly in user developments).
--   enablePhantomTypes turns Nonvariant parameters to
--   Covariant to enable phantoms.
enablePhantomTypes :: Defn -> [Polarity] -> [Polarity]

-- | Make arguments Invariant if the type of a not-Nonvariant
--   later argument depends on it. Also, enable phantom types by turning
--   Nonvariant into something else if it is a data/record parameter
--   but not a size argument. [See issue 1596]
--   
--   Precondition: the "phantom" polarity list has the same length as the
--   polarity list.
dependentPolarity :: Type -> [Polarity] -> [Polarity] -> TCM [Polarity]

-- | Check whether a variable is relevant in a type expression, ignoring
--   domains of non-variant arguments.
relevantInIgnoringNonvariant :: Nat -> Type -> [Polarity] -> TCM Bool

-- | Hack for polarity of size indices. As a side effect, this sets the
--   positivity of the size index. See
--   testsucceedPolaritySizeSucData.agda for a case where this is
--   needed.
sizePolarity :: QName -> [Polarity] -> TCM [Polarity]

-- | checkSizeIndex d i a checks that constructor target type
--   a has form d ps (↑ⁿ i) idxs where |ps| =
--   np(d).
--   
--   Precondition: a is reduced and of form d ps idxs0.
checkSizeIndex :: QName -> Nat -> Type -> TCM Bool

-- | polarities i a computes the list of polarities of de Bruijn
--   index i in syntactic entity a.
class HasPolarity a
polarities :: HasPolarity a => Nat -> a -> TCM [Polarity]

-- | polarity i a computes the polarity of de Bruijn index
--   i in syntactic entity a by taking the infimum of all
--   polarities.
polarity :: HasPolarity a => Nat -> a -> TCM Polarity
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.Common.Dom a)
instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Abs a)
instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity [a]
instance (Agda.TypeChecking.Polarity.HasPolarity a, Agda.TypeChecking.Polarity.HasPolarity b) => Agda.TypeChecking.Polarity.HasPolarity (a, b)
instance Agda.TypeChecking.Polarity.HasPolarity Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Polarity.HasPolarity a => Agda.TypeChecking.Polarity.HasPolarity (Agda.Syntax.Internal.Elim' a)
instance Agda.TypeChecking.Polarity.HasPolarity Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Polarity.HasPolarity Agda.Syntax.Internal.Level
instance Agda.TypeChecking.Polarity.HasPolarity Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.Polarity.HasPolarity Agda.Syntax.Internal.LevelAtom

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

-- | Builds a proper substitution from an IntMap produced by
--   match(Co)patterns
buildSubstitution :: DeBruijn a => Empty -> Int -> IntMap (Arg a) -> Substitution' a

-- | Instead of zipWithM, we need to use this lazy version of
--   combining pattern matching computations.
foldMatch :: forall p v. IsProjP p => (p -> v -> ReduceM (Match Term, v)) -> [p] -> [v] -> ReduceM (Match Term, [v])
mergeElim :: Elim -> Arg Term -> Elim
mergeElims :: [Elim] -> [Arg Term] -> [Elim]

-- | 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 :: [NamedArg DeBruijnPattern] -> [Elim] -> ReduceM (Match Term, [Elim])

-- | Match a single copattern.
matchCopattern :: DeBruijnPattern -> Elim -> ReduceM (Match Term, Elim)
matchPatterns :: [NamedArg DeBruijnPattern] -> [Arg Term] -> ReduceM (Match Term, [Arg Term])

-- | Match a single pattern.
matchPattern :: DeBruijnPattern -> Arg Term -> ReduceM (Match Term, Arg Term)
yesSimplification :: (Match a, b) -> (Match a, b)
instance GHC.Base.Functor Agda.TypeChecking.Patterns.Match.Match
instance Agda.Utils.Null.Null (Agda.TypeChecking.Patterns.Match.Match a)

-- | The occurs check for unification. Does pruning on the fly.
--   
--   When hitting a meta variable:
--   
--   
--   
- Compute flex/rigid for its arguments.
--   
- Compare to allowed variables.
--   
- Mark arguments with rigid occurrences of disallowed variables for
--   deletion.
--   
- Attempt to delete marked arguments.
--   
- We don't need to check for success, we can just continue occurs
--   checking.
--   
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 ()
data OccursCtx

-- | We are in arguments of a meta.
Flex :: OccursCtx

-- | We are not in arguments of a meta but a bound var.
Rigid :: OccursCtx

-- | We are at the start or in the arguments of a constructor.
StronglyRigid :: OccursCtx

-- | We are in an irrelevant argument.
Irrel :: OccursCtx
data UnfoldStrategy
YesUnfold :: UnfoldStrategy
NoUnfold :: UnfoldStrategy
defArgs :: UnfoldStrategy -> OccursCtx -> OccursCtx
unfold :: UnfoldStrategy -> Term -> TCM (Blocked Term)

-- | Leave the strongly rigid position.
weakly :: OccursCtx -> OccursCtx
strongly :: OccursCtx -> OccursCtx
patternViolation' :: Int -> String -> TCM a
abort :: OccursCtx -> TypeError -> TCM a

-- | Distinguish relevant, irrelevant and nonstrict variables in occurs
--   check.
type Vars = ([Nat], [Nat], [Nat])
goIrrelevant :: Vars -> Vars
goNonStrict :: Vars -> Vars
allowedVar :: Nat -> Vars -> Bool
takeRelevant :: Vars -> [Nat]
takeAll :: Vars -> [Nat]
liftUnderAbs :: Vars -> Vars

-- | Extended occurs check.
class Occurs t
occurs :: Occurs t => UnfoldStrategy -> OccursCtx -> MetaId -> Vars -> t -> TCM t
metaOccurs :: Occurs 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 -> Vars -> 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 :: MetaId -> Args -> [Nat] -> TCM 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 :: [Nat] -> Term -> ExceptT () TCM Bool

-- | Check whether a term Def f es is finally stuck. Currently, we
--   give only a crude approximation.
isNeutral :: MonadTCM tcm => Blocked t -> QName -> Elims -> tcm 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 :: (MonadTCM tcm, FoldRigid a) => a -> [Nat] -> tcm Bool

-- | Collect the *definitely* rigid variables in a monoid. We need to
--   successively reduce the expression to do this.
class FoldRigid a
foldRigid :: (FoldRigid a, Monoid (TCM m)) => (Nat -> TCM m) -> a -> TCM m
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 :: [Bool] -> MetaId -> TCM 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 :: [(Dom (ArgName, Type), Bool)] -> Type -> TCM ([Arg Bool], Type)
reallyNotFreeIn :: IntSet -> Type -> TCM (IntSet, Type)

-- | Instantiate a meta variable with a new one that only takes the
--   arguments which are not pruneable.
performKill :: [Arg Bool] -> MetaId -> Type -> TCM ()
instance GHC.Show.Show Agda.TypeChecking.MetaVars.Occurs.PruneResult
instance GHC.Classes.Eq Agda.TypeChecking.MetaVars.Occurs.PruneResult
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.OccursCtx
instance GHC.Classes.Eq Agda.TypeChecking.MetaVars.Occurs.OccursCtx
instance Agda.TypeChecking.MetaVars.Occurs.Occurs Agda.Syntax.Internal.Term
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid Agda.Syntax.Internal.Term
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid Agda.Syntax.Internal.Type
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid Agda.Syntax.Internal.Sort
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid Agda.Syntax.Internal.Level
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid Agda.Syntax.Internal.PlusLevel
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid Agda.Syntax.Internal.LevelAtom
instance (Agda.TypeChecking.Substitute.Class.Subst t a, Agda.TypeChecking.MetaVars.Occurs.FoldRigid a) => Agda.TypeChecking.MetaVars.Occurs.FoldRigid (Agda.Syntax.Internal.Abs a)
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid a => Agda.TypeChecking.MetaVars.Occurs.FoldRigid (Agda.Syntax.Common.Arg a)
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid a => Agda.TypeChecking.MetaVars.Occurs.FoldRigid (Agda.Syntax.Common.Dom a)
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid a => Agda.TypeChecking.MetaVars.Occurs.FoldRigid (Agda.Syntax.Internal.Elim' a)
instance Agda.TypeChecking.MetaVars.Occurs.FoldRigid a => Agda.TypeChecking.MetaVars.Occurs.FoldRigid [a]
instance (Agda.TypeChecking.MetaVars.Occurs.FoldRigid a, Agda.TypeChecking.MetaVars.Occurs.FoldRigid b) => Agda.TypeChecking.MetaVars.Occurs.FoldRigid (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.LevelAtom
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' a)
instance (Agda.TypeChecking.MetaVars.Occurs.Occurs a, Agda.TypeChecking.Substitute.Class.Subst t 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.Common.Dom 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 [a]
instance Agda.TypeChecking.MetaVars.Occurs.Occurs a => Agda.TypeChecking.MetaVars.Occurs.Occurs (GHC.Maybe.Maybe a)

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
match :: (MonadReduce m, HasConstInfo m, HasBuiltins m) => [Clause] -> [NamedArg SplitPattern] -> m (Match (Nat, [SplitAssignment]))
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]
fromSplitPatterns :: [NamedArg SplitPattern] -> [NamedArg DeBruijnPattern]
toSplitPatterns :: [NamedArg DeBruijnPattern] -> [NamedArg SplitPattern]
toSplitPSubst :: PatternSubstitution -> SplitPSubstitution
applySplitPSubst :: Subst Term 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 -> 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
type BlockingVars = [BlockingVar]
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

-- | True if the unintroduced argument was an IApply pattern
[blockedOnResultIApply] :: BlockedOnResult -> ApplyOrIApply
NotBlockedOnResult :: BlockedOnResult
setBlockingVarOverlap :: BlockingVar -> BlockingVar
data ApplyOrIApply
IsApply :: ApplyOrIApply
IsIApply :: ApplyOrIApply
instance GHC.Base.Functor Agda.TypeChecking.Coverage.Match.Match
instance GHC.Show.Show Agda.TypeChecking.Coverage.Match.BlockingVar
instance GHC.Show.Show Agda.TypeChecking.Coverage.Match.SplitPatVar
instance Agda.Utils.Pretty.Pretty Agda.TypeChecking.Coverage.Match.BlockingVar
instance Agda.TypeChecking.Substitute.DeBruijn.DeBruijn Agda.TypeChecking.Coverage.Match.SplitPattern
instance Agda.TypeChecking.Substitute.Class.Subst Agda.TypeChecking.Coverage.Match.SplitPattern 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

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)

-- | 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 mutual block we are checking.
--   
--   The functions are numbered according to their order of appearance in
--   this list.
type MutualNames = [QName]

-- | The target of the function we are checking.
type Target = QName

-- | The current guardedness level.
type Guarded = Order

-- | The termination environment.
data TerEnv
TerEnv :: Bool -> Bool -> Maybe QName -> Maybe QName -> CutOff -> QName -> MutualNames -> [QName] -> Bool -> Maybe 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

-- | Do we inline with functions to enhance termination checking of with?
[terInlineWithFunctions] :: 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 -> [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 -> Maybe 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
terGetInlineWithFunctions :: TerM Bool
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 [QName]
terGetTarget :: TerM (Maybe Target)
terSetTarget :: Maybe 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

-- | The call information is stored as free monoid over CallInfo. As
--   long as we never look at it, only accumulate it, it does not matter
--   whether we use Set, (nub) list, or Tree. Internally,
--   due to lazyness, it is anyway a binary tree of mappend nodes
--   and singleton leafs. Since we define no order on CallInfo
--   (expensive), we cannot use a Set or nub list.
--   Performance-wise, I could not see a difference between Set and list.
newtype CallPath
CallPath :: [CallInfo] -> CallPath
[callInfos] :: CallPath -> [CallInfo]

-- | A very crude way of estimating the SIZELT chains i > j
--   > k in context. Returns 3 in this case. Overapproximates.
terSetSizeDepth :: Telescope -> TerM a -> TerM a
instance Agda.Syntax.Abstract.AllNames Agda.Termination.Monad.CallPath
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.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.Base.HasOptions Agda.Termination.Monad.TerM
instance Agda.Utils.Benchmark.MonadBench Agda.Benchmarking.Phase 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 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.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 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)

-- | This module defines an inlining transformation on clauses that's run
--   before termination checking. The purpose is to improve termination
--   checking of with clauses (issue 59). The transformation inlines
--   generated with-functions expanding the clauses of the parent function
--   in such a way that termination checking the expanded clauses
--   guarantees termination of the original function, while allowing more
--   terminating functions to be accepted. It does in no way pretend to
--   preserve the semantics of the original function.
--   
--   Roughly, the source program
--   
--   
--   f ps with as
--   {f ps₁i qsi = bi}
--   
--   
--   is represented internally as
--   
--   
--   f ps = f-aux xs as      where xs   = vars(ps)
--   {f-aux ps₂i qsi = bi}   where ps₁i = ps[ps₂i/xs]
--   
--   
--   The inlining transformation turns this into
--   
--   
--   {f ps = aj} for aj ∈ as
--   {f ps₁i qsi = bi}
--   
--   
--   The first set of clauses, called withExprClauses, ensure that
--   we don't forget any recursive calls in as. The second set of
--   clauses, henceforth called inlinedClauses, are the
--   surface-level clauses the user sees (and probably reasons about).
--   
--   The reason this works is that there is a single call site for each
--   with-function.
--   
--   Note that the lhss of the inlined clauses are not type-correct,
--   neither with the type of f (since there are additional
--   patterns qsi) nor with the type of f-aux (since
--   there are the surface-level patterns ps₁i instead of the
--   actual patterns ps₂i).
module Agda.Termination.Inlining

-- | Returns Nothing if no inlining happened, otherwise, the new
--   clauses.
inlineWithClauses :: QName -> Clause -> TCM (Maybe [Clause])
isWithFunction :: MonadTCM tcm => QName -> tcm (Maybe QName)
expandWithFunctionCall :: QName -> Elims -> TCM Term

module Agda.TypeChecking.Errors
prettyError :: MonadTCM tcm => TCErr -> tcm String
prettyWarning :: MonadTCM tcm => Warning -> tcm Doc
tcErrString :: TCErr -> String
prettyTCWarnings' :: [TCWarning] -> TCM [String]
prettyTCWarnings :: [TCWarning] -> TCM String

-- | Turns all warnings into errors.
tcWarningsToError :: [TCWarning] -> TCM a

-- | Depending which flags are set, one may happily ignore some warnings.
applyFlagsToTCWarnings' :: MainInterface -> [TCWarning] -> TCM [TCWarning]
applyFlagsToTCWarnings :: [TCWarning] -> TCM [TCWarning]

-- | Drops the filename component of the qualified name.
dropTopLevelModule :: QName -> TCM QName
stringTCErr :: String -> TCErr
sayWhen :: Range -> Maybe (Closure Call) -> TCM Doc -> TCM Doc
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.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.PrettyUnequal Agda.Syntax.Internal.Term
instance Agda.TypeChecking.Errors.PrettyUnequal Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.TCWarning
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Warning
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.TCErr
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.CallInfo
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.SplitError
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.NegativeUnification
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.UnificationFailure
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Monad.Base.Call

-- | EDSL to construct terms without touching De Bruijn indices.
--   
--   e.g. if 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
--   
--   
--   
- t,u <- mapM open [t,u]
--   
--   
--   
--   
- - lam gives the illusion of HOAS by providing f as a
--   computation
--   
- - It also extends the internal context with the name "f", so
--   that
--   
- - t and u will get weakened in the body.
--   
- - Then we finish the job using the (@) combinator from
--   Agda.TypeChecking.Primitive
--   
--   
--   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
type Names = [String]
runNamesT :: Names -> NamesT m a -> m a
runNames :: Names -> NamesT Identity a -> a
currentCxt :: Monad m => NamesT m Names
cxtSubst :: Monad m => Names -> NamesT m (Substitution' a)
inCxt :: (Monad m, Subst t a) => Names -> a -> NamesT m a
cl' :: Applicative m => a -> NamesT m a
cl :: Monad m => m a -> NamesT m a
open :: (Monad m, Subst t a) => a -> NamesT m (NamesT m a)
bind' :: (Monad m, Subst t' b, DeBruijn b, Subst t a, Free a) => ArgName -> (NamesT m b -> NamesT m a) -> NamesT m a
bind :: (Monad m, Subst t' b, DeBruijn b, Subst t a, Free a) => ArgName -> (NamesT m b -> NamesT m a) -> NamesT m (Abs a)
glam :: Monad m => ArgInfo -> ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
glamN :: (Functor m, Monad m) => [Arg ArgName] -> (NamesT m Args -> NamesT m Term) -> NamesT m Term
lam :: Monad m => ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
ilam :: Monad m => ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
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.TypeChecking.Monad.Base.HasOptions m => Agda.TypeChecking.Monad.Base.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 Agda.TypeChecking.Monad.Builtin.HasBuiltins m => Agda.TypeChecking.Monad.Builtin.HasBuiltins (Agda.TypeChecking.Names.NamesT m)

-- | Primitive functions, such as addition on builtin integers.
module Agda.TypeChecking.Primitive
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)
data PrimitiveImpl
PrimImpl :: Type -> PrimFun -> PrimitiveImpl
newtype Nat
Nat :: Integer -> Nat
[unNat] :: Nat -> Integer
newtype Lvl
Lvl :: Integer -> Lvl
[unLvl] :: Lvl -> Integer
class PrimType a
primType :: PrimType a => a -> TCM Type
class PrimTerm a
primTerm :: PrimTerm a => a -> TCM Term
class ToTerm a
toTerm :: ToTerm a => TCM (a -> Term)
toTermR :: ToTerm a => TCM (a -> ReduceM Term)

-- | buildList A ts builds a list of type List A. Assumes
--   that the terms ts all have type A.
buildList :: TCM ([Term] -> Term)
type FromTermFunction a = Arg Term -> ReduceM (Reduced (MaybeReduced (Arg Term)) a)
class FromTerm a
fromTerm :: FromTerm a => TCM (FromTermFunction 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')
redReturn :: a -> ReduceM (Reduced a' a)
fromReducedTerm :: (Term -> Maybe a) -> TCM (FromTermFunction a)
fromLiteral :: (Literal -> Maybe a) -> TCM (FromTermFunction a)
requireCubical :: TCM ()
primINeg' :: TCM PrimitiveImpl
primDepIMin' :: TCM PrimitiveImpl
primIBin :: IntervalView -> IntervalView -> TCM PrimitiveImpl
primIMin' :: TCM PrimitiveImpl
primIMax' :: TCM PrimitiveImpl
imax :: HasBuiltins m => m Term -> m Term -> m Term
imin :: HasBuiltins m => m Term -> m Term -> m Term
primIdJ :: TCM PrimitiveImpl
primIdElim' :: TCM PrimitiveImpl
primPOr :: TCM PrimitiveImpl
primPartial' :: TCM PrimitiveImpl
primPartialP' :: TCM PrimitiveImpl
primSubOut' :: TCM PrimitiveImpl
primIdFace' :: TCM PrimitiveImpl
primIdPath' :: TCM PrimitiveImpl
primTrans' :: TCM PrimitiveImpl
primHComp' :: TCM PrimitiveImpl
data TranspOrHComp
DoTransp :: TranspOrHComp
DoHComp :: TranspOrHComp
cmdToName :: TranspOrHComp -> String
data FamilyOrNot a
IsFam :: a -> FamilyOrNot a
[famThing] :: FamilyOrNot a -> a
IsNot :: a -> FamilyOrNot a
[famThing] :: FamilyOrNot a -> a
primTransHComp :: TranspOrHComp -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)
primComp :: TCM PrimitiveImpl
listS :: [(Int, Term)] -> Substitution
primGlue' :: TCM PrimitiveImpl
prim_glue' :: TCM PrimitiveImpl
prim_unglue' :: TCM PrimitiveImpl
primFaceForall' :: TCM PrimitiveImpl
decomposeInterval :: HasBuiltins m => Term -> m [(Map Int Bool, [Term])]
decomposeInterval' :: HasBuiltins m => Term -> m [(Map Int (Set Bool), [Term])]

-- | 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
primCharToNatInjective :: TCM PrimitiveImpl
primStringToListInjective :: TCM PrimitiveImpl
primWord64ToNatInjective :: 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 :: TCM PrimitiveImpl
mkPrimFun1TCM :: (FromTerm a, ToTerm b, TermLike 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
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
(-->) :: Monad tcm => tcm Type -> tcm Type -> tcm Type
infixr 4 -->
(.-->) :: Monad tcm => tcm Type -> tcm Type -> tcm Type
infixr 4 .-->
(..-->) :: Monad tcm => tcm Type -> tcm Type -> tcm Type
infixr 4 ..-->
garr :: Monad tcm => (Relevance -> Relevance) -> tcm Type -> tcm Type -> tcm Type
gpi :: (MonadTCM tcm, MonadDebug tcm) => ArgInfo -> String -> tcm Type -> tcm Type -> tcm Type
hPi :: (MonadTCM tcm, MonadDebug tcm) => String -> tcm Type -> tcm Type -> tcm Type
nPi :: (MonadTCM tcm, MonadDebug tcm) => String -> tcm Type -> tcm Type -> tcm Type
hPi' :: (MonadTCM tcm, MonadDebug tcm) => String -> NamesT tcm Type -> (NamesT tcm Term -> NamesT tcm Type) -> NamesT tcm Type
nPi' :: (MonadTCM tcm, MonadDebug tcm) => String -> NamesT tcm Type -> (NamesT tcm Term -> NamesT tcm Type) -> NamesT tcm Type
pPi' :: (MonadTCM tcm, MonadDebug tcm) => String -> NamesT tcm Term -> (NamesT tcm Term -> NamesT tcm Type) -> NamesT tcm Type
el' :: Monad m => m Term -> m Term -> m Type
elInf :: Functor m => m Term -> m Type
nolam :: Term -> Term
varM :: Monad tcm => Int -> tcm Term
gApply :: Monad tcm => Hiding -> tcm Term -> tcm Term -> tcm Term
gApply' :: Monad tcm => ArgInfo -> tcm Term -> tcm Term -> tcm Term
(<@>) :: Monad tcm => tcm Term -> tcm Term -> tcm Term
infixl 9 <@>
(<#>) :: Monad tcm => tcm Term -> tcm Term -> tcm Term
infixl 9 <#>
(<..>) :: Monad tcm => tcm Term -> tcm Term -> tcm Term
(<@@>) :: Monad tcm => tcm Term -> (tcm Term, tcm Term, tcm Term) -> tcm Term
list :: TCM Term -> TCM Term
io :: TCM Term -> TCM Term
path :: TCM Term -> TCM Term
el :: Functor tcm => tcm Term -> tcm Type
tset :: Monad tcm => tcm Type
sSizeUniv :: Sort
tSizeUniv :: Monad tcm => tcm 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
type Op a = a -> a -> a
type Fun a = a -> a
type Rel a = a -> a -> Bool
type Pred a = a -> Bool
primitiveFunctions :: Map String (TCM PrimitiveImpl)
lookupPrimitiveFunction :: String -> TCM PrimitiveImpl
lookupPrimitiveFunctionQ :: QName -> TCM (String, PrimitiveImpl)
getBuiltinName :: String -> TCM (Maybe QName)
isBuiltin :: QName -> String -> TCM Bool
instance Data.Traversable.Traversable Agda.TypeChecking.Primitive.FamilyOrNot
instance Data.Foldable.Foldable Agda.TypeChecking.Primitive.FamilyOrNot
instance GHC.Base.Functor Agda.TypeChecking.Primitive.FamilyOrNot
instance GHC.Show.Show a => GHC.Show.Show (Agda.TypeChecking.Primitive.FamilyOrNot a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Agda.TypeChecking.Primitive.FamilyOrNot a)
instance GHC.Show.Show Agda.TypeChecking.Primitive.TranspOrHComp
instance GHC.Classes.Eq Agda.TypeChecking.Primitive.TranspOrHComp
instance GHC.Classes.Ord Agda.TypeChecking.Primitive.Lvl
instance GHC.Classes.Eq Agda.TypeChecking.Primitive.Lvl
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.Show.Show Agda.TypeChecking.Primitive.SigmaKit
instance GHC.Classes.Eq Agda.TypeChecking.Primitive.SigmaKit
instance Agda.TypeChecking.Reduce.Reduce a => Agda.TypeChecking.Reduce.Reduce (Agda.TypeChecking.Primitive.FamilyOrNot a)
instance Agda.TypeChecking.Primitive.FromTerm GHC.Integer.Type.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 Agda.Utils.String.Str
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.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 Agda.Utils.String.Str
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.Integer.Type.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.Type
instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Common.ArgInfo
instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Fixity.Fixity'
instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Fixity.Fixity
instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Fixity.Associativity
instance Agda.TypeChecking.Primitive.ToTerm Agda.Syntax.Fixity.PrecedenceLevel
instance Agda.TypeChecking.Primitive.ToTerm a => Agda.TypeChecking.Primitive.ToTerm [a]
instance (Agda.TypeChecking.Primitive.PrimType a, Agda.TypeChecking.Primitive.PrimType b) => Agda.TypeChecking.Primitive.PrimTerm (a -> b)
instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimType a
instance Agda.TypeChecking.Primitive.PrimTerm GHC.Integer.Type.Integer
instance Agda.TypeChecking.Primitive.PrimTerm GHC.Word.Word64
instance Agda.TypeChecking.Primitive.PrimTerm GHC.Types.Bool
instance Agda.TypeChecking.Primitive.PrimTerm GHC.Types.Char
instance Agda.TypeChecking.Primitive.PrimTerm GHC.Types.Double
instance Agda.TypeChecking.Primitive.PrimTerm Agda.Utils.String.Str
instance Agda.TypeChecking.Primitive.PrimTerm Agda.TypeChecking.Primitive.Nat
instance Agda.TypeChecking.Primitive.PrimTerm Agda.TypeChecking.Primitive.Lvl
instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Abstract.Name.QName
instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Common.MetaId
instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Internal.Type
instance Agda.TypeChecking.Primitive.PrimTerm Agda.Syntax.Fixity.Fixity'
instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimTerm [a]
instance Agda.TypeChecking.Primitive.PrimTerm a => Agda.TypeChecking.Primitive.PrimTerm (GHC.Types.IO a)
instance GHC.Show.Show Agda.TypeChecking.Primitive.Lvl
instance GHC.Real.Integral Agda.TypeChecking.Primitive.Nat
instance Agda.Syntax.Internal.Generic.TermLike Agda.TypeChecking.Primitive.Nat
instance GHC.Show.Show Agda.TypeChecking.Primitive.Nat

module Agda.TypeChecking.Primitive.Cubical

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

-- | Like transpTel but performing a transpFill.
trFillTel :: Abs Telescope -> Term -> Args -> Term -> ExceptT (Closure (Abs Type)) TCM Args

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.Erase
eraseTerms :: QName -> EvaluationStrategy -> TTerm -> TCM TTerm

-- | Takes the name of the data/record type.
computeErasedConstructorArgs :: QName -> TCM ()
instance GHC.Show.Show Agda.Compiler.Treeless.Erase.TypeInfo
instance GHC.Classes.Eq Agda.Compiler.Treeless.Erase.TypeInfo

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

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
isConsideringInstance :: (ReadTCState m, HasOptions m) => m Bool
postponeInstanceConstraints :: TCM a -> TCM a
instance GHC.Show.Show Agda.TypeChecking.InstanceArguments.YesNoMaybe

module Agda.TypeChecking.Constraints

-- | Catches pattern violation errors and adds a constraint.
catchConstraint :: Constraint -> TCM () -> TCM ()
addConstraint :: Constraint -> TCM ()

-- | Don't allow the argument to produce any blocking constraints.
noConstraints :: TCM a -> TCM a

-- | Create a fresh problem for the given action.
newProblem :: TCM a -> TCM (ProblemId, a)
newProblem_ :: TCM () -> TCM 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 Guarded c cs constraint to
--   the blocker-generated constraints cs.
guardConstraint :: Constraint -> TCM () -> TCM ()
whenConstraints :: TCM () -> TCM () -> TCM ()

-- | Wake constraints matching the given predicate (and aren't instance
--   constraints if isConsideringInstance).
wakeConstraints' :: (ProblemConstraint -> TCM Bool) -> TCM ()

-- | Wake up the constraints depending on the given meta.
wakeupConstraints :: MetaId -> TCM ()

-- | Wake up all constraints.
wakeupConstraints_ :: TCM ()
solveAwakeConstraints :: TCM ()
solveAwakeConstraints' :: Bool -> TCM ()

-- | Solve awake constraints matching the predicate. If the second argument
--   is True solve constraints even if already isSolvingConstraints.
solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> TCM ()
solveConstraint :: Constraint -> TCM ()
solveConstraint_ :: Constraint -> TCM ()
checkTypeCheckingProblem :: TypeCheckingProblem -> TCM Term
debugConstraints :: TCM ()

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

-- | 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 :: MetaId -> [Arg ArgName] -> Term -> TCM ()

-- | Skip frozen check. Used for eta expanding frozen metas.
assignTerm' :: 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 :: TCM Sort

-- | Create a sort meta that may be instantiated with Inf (Setω).
newSortMetaCtx :: Args -> TCM Sort
newTypeMeta :: Sort -> TCM Type
newTypeMeta_ :: TCM Type

-- | newInstanceMeta s t cands creates a new instance metavariable
--   of type the output type of t with name suggestion s.
newInstanceMeta :: MetaNameSuggestion -> Type -> TCM (MetaId, Term)
newInstanceMetaCtx :: MetaNameSuggestion -> Type -> Args -> TCM (MetaId, Term)

-- | Create a new value meta with specific dependencies, possibly
--   η-expanding in the process.
newNamedValueMeta :: RunMetaOccursCheck -> MetaNameSuggestion -> Type -> TCM (MetaId, Term)

-- | Create a new value meta with specific dependencies without
--   η-expanding.
newNamedValueMeta' :: RunMetaOccursCheck -> MetaNameSuggestion -> Type -> TCM (MetaId, Term)

-- | Create a new metavariable, possibly η-expanding in the process.
newValueMeta :: RunMetaOccursCheck -> Type -> TCM (MetaId, Term)
newValueMetaCtx :: Frozen -> RunMetaOccursCheck -> Type -> Telescope -> Permutation -> Args -> TCM (MetaId, Term)

-- | Create a new value meta without η-expanding.
newValueMeta' :: RunMetaOccursCheck -> Type -> TCM (MetaId, Term)

-- | Create a new value meta with specific dependencies.
newValueMetaCtx' :: Frozen -> RunMetaOccursCheck -> Type -> Telescope -> Permutation -> Args -> TCM (MetaId, Term)
newTelMeta :: Telescope -> TCM Args
type Condition = Dom Type -> Abs Type -> Bool
trueCondition :: Condition
newArgsMeta :: Type -> TCM Args
newArgsMeta' :: Condition -> Type -> TCM Args
newArgsMetaCtx :: Type -> Telescope -> Permutation -> Args -> TCM Args
newArgsMetaCtx' :: Frozen -> Condition -> Type -> Telescope -> Permutation -> Args -> TCM 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 -> Type -> TCM (MetaId, Term)
newQuestionMark' :: (Type -> TCM (MetaId, Term)) -> InteractionId -> Type -> TCM (MetaId, Term)

-- | Construct a blocked constant if there are constraints.
blockTerm :: Type -> TCM Term -> TCM Term
blockTermOnProblem :: Type -> Term -> ProblemId -> TCM Term
blockTypeOnProblem :: Type -> ProblemId -> TCM Type

-- | unblockedTester t returns False if t is a
--   meta or a blocked term.
--   
--   Auxiliary function to create a postponed type checking problem.
unblockedTester :: Type -> TCM Bool

-- | 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 -> TCM Bool -> TCM Term

-- | Type of the term that is produced by solving the
--   TypeCheckingProblem.
problemType :: TypeCheckingProblem -> Type

-- | Eta expand metavariables listening on the current meta.
etaExpandListeners :: MetaId -> TCM ()

-- | Wake up a meta listener and let it do its thing
wakeupListener :: Listener -> TCM ()

-- | Do safe eta-expansions for meta (SingletonRecords,Levels).
etaExpandMetaSafe :: MetaId -> TCM ()

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

-- | Eta expand a metavariable, if it is of the specified kind. Don't do
--   anything if the metavariable is a blocked term.
etaExpandMeta :: [MetaKind] -> MetaId -> TCM ()

-- | Eta expand blocking metavariables of record type, and reduce the
--   blocked thing.
etaExpandBlocked :: Reduce t => Blocked t -> TCM (Blocked t)

-- | 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 :: CompareDirection -> MetaId -> Args -> Term -> TCM ()
assignWrapper :: CompareDirection -> MetaId -> Elims -> Term -> TCM () -> TCM ()

-- | Miller pattern unification:
--   
--   assign x vs v solves problem x vs = v 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:
--   
--   
--   
- Pruning.
--   
- Benign cases of non-linearity.
--   
- vs may contain record patterns.
--   
--   
--   For a reference to some of these extensions, read Andreas Abel and
--   Brigitte Pientka's TLCA 2011 paper.
assign :: CompareDirection -> MetaId -> Args -> 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. 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 ()

-- | 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 :: (Show a, PrettyTCM a, NoProjectedVar a, ReduceAndEtaContract a, PrettyTCM b, Subst Term 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, Subst Term 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 ProjVarExc ()
data ProjVarExc
ProjVarExc :: Int -> [(ProjOrigin, QName)] -> ProjVarExc

-- | Normalize just far enough to be able to eta-contract maximally.
class (TermLike a, Subst Term a, Reduce a) => ReduceAndEtaContract a
reduceAndEtaContract :: ReduceAndEtaContract a => a -> TCM a
reduceAndEtaContract :: (ReduceAndEtaContract a, Traversable f, TermLike b, Subst Term 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.
ProjectedVar :: Int -> [(ProjOrigin, QName)] -> 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:
--   
--   
--   
- We are inTopContext.
--   
- envCurrentModule is set to the top-level module.
--   
openMetasToPostulates :: TCM ()
instance GHC.Show.Show Agda.TypeChecking.MetaVars.MetaKind
instance GHC.Enum.Bounded Agda.TypeChecking.MetaVars.MetaKind
instance GHC.Enum.Enum Agda.TypeChecking.MetaVars.MetaKind
instance GHC.Classes.Eq Agda.TypeChecking.MetaVars.MetaKind
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 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]

module Agda.TypeChecking.Injectivity
headSymbol :: Term -> TCM (Maybe TermHead)

-- | Do a full whnf and treat neutral terms as rigid. Used on the arguments
--   to an injective functions and to the right-hand side.
headSymbol' :: Term -> TCM (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

-- | 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 :: Elims -> InversionMap Clause -> TCM (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 :: QName -> Elims -> InversionMap c -> TCM (Maybe (InversionMap c))

-- | Argument should be in weak head normal form.
functionInverse :: Term -> TCM InvView
data InvView
Inv :: QName -> [Elim] -> InversionMap Clause -> InvView
NoInv :: InvView
data MaybeAbort
Abort :: MaybeAbort
KeepGoing :: MaybeAbort

-- | Precondition: The first argument must be blocked and the second must
--   be neutral.
useInjectivity :: CompareDirection -> Type -> Term -> Term -> TCM ()

-- | The second argument should be a blocked application and the third
--   argument the inverse of the applied function.
invertFunction :: Comparison -> Term -> InvView -> TermHead -> TCM () -> TCM () -> (Term -> TCM ()) -> TCM ()
forcePiUsingInjectivity :: Type -> TCM Type

-- | 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 token highlighting info in
--   stTokens (that corresponding to the interval covered by the
--   declaration). If the boolean is True, then this token
--   highlighting info is additionally removed from stTokens.
generateAndPrintSyntaxInfo :: Declaration -> Level -> Bool -> TCM ()

-- | Generate and return the syntax highlighting information for the tokens
--   in the given file.
generateTokenInfo :: AbsolutePath -> TCM CompressedFile

-- | Generate and return the syntax highlighting information for the tokens
--   in the given file.
generateTokenInfoFromSource :: AbsolutePath -> String -> TCM CompressedFile

-- | 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 CompressedFile
printSyntaxInfo :: Range -> TCM ()

-- | Prints syntax highlighting info for an error.
printErrorInfo :: TCErr -> TCM ()

-- | Generate highlighting for error. Does something special for
--   termination errors.
errorHighlighting :: TCErr -> TCM File

-- | Generates and prints syntax highlighting information for unsolved
--   meta-variables and certain unsolved constraints.
printUnsolvedInfo :: TCM ()

-- | Lispify and print the given highlighting information.
printHighlightingInfo :: MonadTCM tcm => RemoveTokenBasedHighlighting -> HighlightingInfo -> tcm ()

-- | highlightAsTypeChecked rPre r m runs m and returns
--   its result. Additionally, some code may be highlighted:
--   
--   
--   
- If r is non-empty and not a sub-range of rPre
--   (after continuousPerLine has been applied to both): r
--   is highlighted as being type-checked while m is running (this
--   highlighting is removed if m completes
--   successfully).
--   
- Otherwise: Highlighting is removed for rPre - r before
--   m runs, and if m completes successfully, then
--   rPre - r is highlighted as being type-checked.
--   
highlightAsTypeChecked :: MonadTCM tcm => Range -> Range -> tcm a -> tcm a

-- | Generate syntax highlighting for warnings.
warningHighlighting :: TCWarning -> File

-- | Generates syntax highlighting information for unsolved meta variables.
computeUnsolvedMetaWarnings :: TCM File

-- | Generates syntax highlighting information for unsolved constraints
--   (ideally: that are not connected to a meta variable).
computeUnsolvedConstraints :: TCM File

-- | Remember a name disambiguation (during type checking). To be used
--   later during syntax highlighting.
storeDisambiguatedName :: QName -> TCM ()

-- | Store a disambiguation of record field tags for the purpose of
--   highlighting.
disambiguateRecordFields :: [Name] -> [QName] -> TCM ()

module Agda.TypeChecking.Conversion

-- | Try whether a computation runs without errors or new constraints (may
--   create new metas, though). Restores state upon failure.
tryConversion :: TCM () -> TCM 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' :: TCM a -> TCM (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]
equalTerm :: Type -> Term -> Term -> TCM ()
equalAtom :: Type -> Term -> Term -> TCM ()
equalType :: Type -> Type -> TCM ()

-- | Ignore errors in irrelevant context.
convError :: TypeError -> TCM ()

-- | Type directed equality on values.
compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()

-- | Try to assign meta. If meta is projected, try to eta-expand and run
--   conversion check again.
assignE :: CompareDirection -> MetaId -> Elims -> Term -> (Term -> Term -> TCM ()) -> TCM ()
compareTermDir :: CompareDirection -> Type -> Term -> Term -> TCM ()
compareTerm' :: Comparison -> Type -> Term -> Term -> TCM ()

-- | compareTel t1 t2 cmp tel1 tel1 checks whether pointwise
--   tel1 `cmp` tel2 and complains that t2 `cmp` t1
--   failed if not.
compareTel :: Type -> Type -> Comparison -> Telescope -> Telescope -> TCM ()

-- | Raise UnequalTerms if there is no hope that by meta solving and
--   subsequent eta-contraction these terms could become equal.
--   Precondition: the terms are in reduced form (with no top-level
--   pointer) and failed to be equal in the compareAtom check.
--   
--   By eta-contraction, a lambda or a record constructor term can become
--   anything.
etaInequal :: Comparison -> Type -> Term -> Term -> TCM ()
compareAtomDir :: CompareDirection -> Type -> Term -> Term -> TCM ()

-- | Compute the head type of an elimination. For projection-like functions
--   this requires inferring the type of the principal argument.
computeElimHeadType :: QName -> Elims -> Elims -> TCM Type

-- | Syntax directed equality on atomic values
compareAtom :: Comparison -> Type -> Term -> Term -> TCM ()

-- | Check whether a1 cmp a2 and continue in context
--   extended by a1.
compareDom :: Free c => Comparison -> Dom Type -> Dom Type -> Abs b -> Abs c -> TCM () -> TCM () -> TCM () -> TCM ()
compareRelevance :: Comparison -> Relevance -> Relevance -> Bool

-- | 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 :: ProblemId -> Type -> Term -> Term -> TCM Term
antiUnifyType :: ProblemId -> Type -> Type -> TCM Type
antiUnifyElims :: ProblemId -> Type -> Term -> Elims -> Elims -> TCM Term

-- | compareElims pols a v els1 els2 performs type-directed
--   equality on eliminator spines. t is the type of the head
--   v.
compareElims :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()

-- | 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 :: Type -> Term -> Term -> TCM ()
compareWithPol :: Polarity -> (Comparison -> a -> a -> TCM ()) -> a -> a -> TCM ()
polFromCmp :: Comparison -> Polarity

-- | Type-directed equality on argument lists
compareArgs :: [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> TCM ()

-- | Equality on Types
compareType :: Comparison -> Type -> Type -> TCM ()
leqType :: Type -> Type -> TCM ()

-- | 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.
--   
--   Precondition: a and b are reduced.
coerce :: Comparison -> Term -> Type -> Type -> TCM 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.
--   
--   Precondition: types are reduced.
coerceSize :: (Type -> Type -> TCM ()) -> Term -> Type -> Type -> TCM ()
compareLevel :: Comparison -> Level -> Level -> TCM ()
compareSort :: Comparison -> Sort -> Sort -> TCM ()

-- | 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 :: Sort -> Sort -> TCM ()
leqLevel :: Level -> Level -> TCM ()
equalLevel :: Level -> Level -> TCM ()

-- | Precondition: levels are normalised.
equalLevel' :: Level -> Level -> TCM ()

-- | Check that the first sort equal to the second.
equalSort :: Sort -> Sort -> TCM ()
forallFaceMaps :: Term -> (Map Int Bool -> MetaId -> Term -> TCM a) -> (Substitution -> TCM a) -> TCM [a]
compareInterval :: Comparison -> Type -> Term -> Term -> TCM ()
type Conj = (Map Int (Set Bool), [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 :: [Conj] -> [Conj] -> TCM 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 :: Conj -> Conj -> TCM Bool

-- | equalTermOnFace φ A u v = _ , φ ⊢ u = v : A
equalTermOnFace :: Term -> Type -> Term -> Term -> TCM ()
compareTermOnFace :: Comparison -> Term -> Type -> Term -> Term -> TCM ()
compareTermOnFace' :: (Comparison -> Type -> Term -> Term -> TCM ()) -> Comparison -> Term -> Type -> Term -> Term -> TCM ()
bothAbsurd :: QName -> QName -> TCM Bool

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 String
data ErrorPart
StrPart :: String -> ErrorPart
TermPart :: Term -> ErrorPart
NamePart :: QName -> ErrorPart

-- | 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
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.Integer.Type.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 Agda.Utils.String.Str
instance Agda.TypeChecking.Unquote.Unquote a => Agda.TypeChecking.Unquote.Unquote [a]
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.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.Common.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

-- | Solving size constraints under hypotheses.
--   
--   The size solver proceeds as follows:
--   
--   
--   
- Get size constraints, cluster into connected components.
--   
--   
--   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.
--   
--   
--   
- Find a joint context for each cluster.
--   
--   
--   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.
--   
--   
--   
- Convert the joint context into a hypothesis graph.
--   
--   
--   This is straightforward. Each de Bruijn index becomes a rigid
--   variable, each typing assumption j : Size< i becomes an
--   arc.
--   
--   
--   
- Convert the constraints into a constraint graph.
--   
--   
--   Here we need to convert MetaVs into flexible variables.
--   
--   
--   
- Run the solver
--   
- Convert the solution into meta instantiations.
--   
- Double-check whether the constraints are solved.
--   
module Agda.TypeChecking.SizedTypes.Solve
type CC = Closure Constraint

-- | 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 :: Closure Constraint -> MaybeT TCM Constraint

-- | 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 -> NonemptyList (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 :: Closure Constraint -> 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 :: DBSizeExpr -> TCM Term
instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Solve.SizeMeta
instance GHC.Show.Show Agda.TypeChecking.SizedTypes.Solve.NamedRigid
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 Agda.TypeChecking.SizedTypes.Syntax.Flexs Agda.TypeChecking.SizedTypes.Solve.SizeMeta Agda.TypeChecking.SizedTypes.Solve.HypSizeConstraint
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.SizedTypes.Solve.HypSizeConstraint
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term 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.Syntax.Internal.Term Agda.TypeChecking.SizedTypes.Solve.SizeMeta
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term (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

-- | 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. A telescope
--   eqTel containing the types of the equations. 3. Left- and
--   right-hand sides for each equation: varTel ⊢ eqLHS : eqTel
--   and varTel ⊢ eqRHS : eqTel.
--   
--   The unification algorithm can end in three different ways: (type
--   UnificationResult): - A *positive success* Unifies (tel,
--   sigma, ps) with tel ⊢ sigma : varTel, tel ⊢ eqLHS [
--   varTel ↦ sigma ] ≡ eqRHS [ varTel ↦ sigma ] : eqTel, and tel
--   ⊢ ps : eqTel. In this case, sigma;ps is an *equivalence*
--   between the telescopes tel and varTel(eqLHS ≡
--   eqRHS). - A *negative success* NoUnify err means that a
--   conflicting equation was found (e.g an equation between two distinct
--   constructors or a cycle). - A *failure* DontKnow err means
--   that the unifier got stuck.
--   
--   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. 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.
--   
--   The unification steps (of type UnifyStep) are the following:
--   - *Deletion* removes a reflexive equation u =?= v : a if the
--   left- and right-hand side u and v are
--   (definitionally) equal. This rule results in a failure if --without-K
--   is enabled (see "Pattern Matching Without K" by Jesper Cockx,
--   Dominique Devriese, and Frank Piessens (ICFP 2014). - *Solution*
--   solves an equation if one side is (eta-equivalent to) a flexible
--   variable. In case both sides are flexible variables, the unification
--   strategy makes a choice according to the chooseFlex function
--   in Agda.TypeChecking.Rules.LHS.Problem. - *Injectivity*
--   decomposes an equation of the form c us =?= c vs : D pars is
--   where c : Δc → D pars js is a constructor of the inductive
--   datatype D into a sequence of equations us =?= vs :
--   delta. In case D is an indexed datatype,
--   *higher-dimensional unification* is applied (see below). - *Conflict*
--   detects absurd equations of the form c₁ us =?= c₂ vs : D pars
--   is where c₁ and c₂ are two distinct
--   constructors of the datatype D. - *Cycle* detects absurd
--   equations of the form x =?= v : D pars is where x is
--   a variable of the datatype D that occurs strongly rigid in
--   v. - *EtaExpandVar* eta-expands a single flexible variable
--   x : R where R is a (eta-expandable) record type,
--   replacing it by one variable for each field of R. -
--   *EtaExpandEquation* eta-expands an equation u =?= v : R where
--   R is a (eta-expandable) record type, replacing it by one
--   equation for each field of R. The left- and right-hand sides
--   of these equations are the projections of u and v. -
--   *LitConflict* detects absurd equations of the form l₁ =?= l₂ :
--   A where l₁ and l₂ are distinct literal terms. -
--   *StripSizeSuc* simplifies an equation of the form sizeSuc x =?=
--   sizeSuc y : Size to x =?= y : Size. -
--   *SkipIrrelevantEquation removes an equation between irrelevant
--   terms. - *TypeConInjectivity* decomposes an equation of the form
--   D us =?= D vs : Set i where D@ is a datatype. This rule
--   is only used if --injective-type-constructors is enabled.
--   
--   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

-- | Some other error happened, unification got stuck.
DontKnow :: [UnificationFailure] -> UnificationResult' a

-- | Unify indices.
--   
--   In unifyIndices gamma flex us vs,
--   
--   us and vs are the argument lists to unify,
--   
--   gamma is the telescope of free variables in us and
--   vs.
--   
--   flex is the set of flexible (instantiable) variabes in
--   us and vs.
--   
--   The result is the most general unifier of us and vs.
unifyIndices :: MonadTCM tcm => Telescope -> FlexibleVars -> Type -> Args -> Args -> tcm UnificationResult
instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Unify.UnifyStep
instance GHC.Show.Show Agda.TypeChecking.Rules.LHS.Unify.UnifyState
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.Base.Semigroup Agda.TypeChecking.Rules.LHS.Unify.UnifyOutput
instance GHC.Base.Monoid Agda.TypeChecking.Rules.LHS.Unify.UnifyOutput
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Unify.UnifyStep
instance Agda.TypeChecking.Reduce.Reduce Agda.TypeChecking.Rules.LHS.Unify.UnifyState
instance Agda.TypeChecking.Reduce.Normalise Agda.TypeChecking.Rules.LHS.Unify.UnifyState
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Rules.LHS.Unify.UnifyState
instance Agda.TypeChecking.Reduce.Reduce Agda.TypeChecking.Rules.LHS.Unify.Equality

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 -> Closure Clause -> TCM ()

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

-- | Entry point for e.g. checking WithFunctionType.
checkType :: Type -> TCM ()

-- | 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' :: Type -> TCM Sort

-- | Check if sort is well-formed.
checkSort :: Action -> Sort -> TCM Sort

-- | Entry point for term checking.
checkInternal :: Term -> Type -> TCM ()
checkInternal' :: Action -> Term -> Type -> TCM Term

-- | checkInternal traverses the whole Term, and we can use
--   this traversal to modify the term.
data Action
Action :: (Type -> Term -> TCM Term) -> (Type -> Term -> TCM Term) -> (Relevance -> Relevance -> Relevance) -> Action

-- | Called on each subterm before the checker runs.
[preAction] :: Action -> Type -> Term -> TCM Term

-- | Called on each subterm after the type checking.
[postAction] :: Action -> Type -> Term -> TCM Term

-- | Called for each ArgInfo. The first Relevance is from
--   the type, the second from the term.
[relevanceAction] :: Action -> Relevance -> Relevance -> Relevance

-- | The default action is to not change the Term at all.
defaultAction :: Action
eraseUnusedAction :: Action

-- | Infer type of a neutral term.
infer :: Term -> TCM Type

-- | Compute the sort of a type.
inferSort :: Term -> TCM Sort

-- | Result is in reduced form.
shouldBeSort :: Type -> TCM Sort

-- | 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
reconstructParametersInTel :: Telescope -> TCM Telescope
reconstructParametersInEqView :: EqualityView -> TCM EqualityView
reconstructParameters :: Type -> Term -> TCM Term
dropParameters :: TermLike a => a -> TCM a

-- | 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 :: Type -> Term -> TCM Term

-- | Eta-expand functions and expressions of eta-record type wherever
--   possible.
deepEtaExpand :: Term -> Type -> TCM Term
etaExpandAction :: Action

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

-- | Add q : Γ → rel us lhs rhs as rewrite rule  Γ ⊢ lhs ↦ rhs
--   : B  to the signature where B = A[us/Δ]. Remember that
--   rel : Δ → A → A → Set i, so rel us : (lhs rhs : A[us/Δ])
--   → Set i.
addRewriteRule :: QName -> TCM ()

-- | Append rewrite rules to a definition.
addRewriteRules :: QName -> RewriteRules -> TCM ()

-- | rewriteWith t f es rew where f : t tries to rewrite
--   f es with rew, returning the reduct if successful.
rewriteWith :: Type -> 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_ -> Term -> RewriteRules -> Elims -> ReduceM (Reduced (Blocked Term) Term)
class NLPatVars a
nlPatVarsUnder :: NLPatVars a => Int -> a -> IntSet
nlPatVars :: NLPatVars a => a -> IntSet
rewArity :: RewriteRule -> Int

-- | Get all symbols that a rewrite rule matches against
class GetMatchables a
getMatchables :: GetMatchables a => a -> [QName]
instance (Data.Foldable.Foldable f, Agda.TypeChecking.Rewriting.GetMatchables a) => Agda.TypeChecking.Rewriting.GetMatchables (f a)
instance Agda.TypeChecking.Rewriting.GetMatchables Agda.TypeChecking.Monad.Base.NLPat
instance Agda.TypeChecking.Rewriting.GetMatchables Agda.TypeChecking.Monad.Base.RewriteRule
instance (Data.Foldable.Foldable f, Agda.TypeChecking.Rewriting.NLPatVars a) => Agda.TypeChecking.Rewriting.NLPatVars (f a)
instance Agda.TypeChecking.Rewriting.NLPatVars Agda.TypeChecking.Monad.Base.NLPType
instance Agda.TypeChecking.Rewriting.NLPatVars 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

-- | 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:
--   
--   
--   
- Memoise getConstInfo.
--   
--   
--   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.
--   
--   
--   
- Optimised case trees.
--   
--   
--   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:
--   
--   
--   
- Drop constructor arity information.
--   
- Use NameId instead of QName as map keys.
--   
- Special branch for natural number successor.
--   
--   
--   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 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 GHC.Base.Functor Agda.TypeChecking.Reduce.Fast.Thunk
instance GHC.Classes.Eq Agda.TypeChecking.Reduce.Fast.Normalisation
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)

-- | Functions for abstracting terms over other terms.
module Agda.TypeChecking.Abstract
typeOf :: Type -> Type

-- | abstractType a v b[v] = b where a : v.
abstractType :: Type -> Term -> Type -> TCM Type

-- | 
--   piAbstractTerm v a b[v] = (w : a) -> b[w]
--   
piAbstractTerm :: Term -> Type -> Type -> TCM Type

-- | 
--   piAbstract (v, a) b[v] = (w : a) -> 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 :: (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 :: Subst Term a => a -> 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 Agda.Syntax.Internal.LevelAtom
instance Agda.TypeChecking.Abstract.AbsTerm a => Agda.TypeChecking.Abstract.AbsTerm (Agda.Syntax.Internal.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.Common.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.Subst Agda.Syntax.Internal.Term 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)
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

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

-- | Type check a datatype definition. Assumes that the type has already
--   been checked.
checkDataDef :: DefInfo -> QName -> UniverseCheck -> DataDefParams -> [Constructor] -> 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
defineProjections :: QName -> ConHead -> Telescope -> [QName] -> Telescope -> Type -> TCM ()
freshAbstractQName'_ :: String -> TCM QName

-- | A Type with sort Type l Such a type supports both
--   hcomp and transp.
data LType
LEl :: Level -> Term -> LType
fromLType :: LType -> Type
lTypeLevel :: LType -> Level
toLType :: MonadReduce m => Type -> m (Maybe LType)

-- | 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 :: QName -> CType
LType :: LType -> CType
fromCType :: CType -> Type
toCType :: MonadReduce m => Type -> m (Maybe CType)
defineTranspOrHCompForFields :: TranspOrHComp -> 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.
--   
--   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
instance GHC.Show.Show Agda.TypeChecking.Rules.Data.CType
instance GHC.Classes.Eq Agda.TypeChecking.Rules.Data.CType
instance GHC.Show.Show Agda.TypeChecking.Rules.Data.LType
instance GHC.Classes.Eq Agda.TypeChecking.Rules.Data.LType
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Rules.Data.CType
instance Agda.TypeChecking.Substitute.Class.Subst Agda.Syntax.Internal.Term Agda.TypeChecking.Rules.Data.LType

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] -> [Int] -> 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 bσ 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 -> [Int]

-- | 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 => a -> MaybeT TCM FlexibleVarKind
isFlexiblePattern :: IsFlexiblePattern a => a -> TCM Bool
checkSortOfSplitVar :: (MonadTCM tcm, MonadReduce tcm, MonadError TCErr tcm, LensSort a) => DataOrRecord -> a -> Maybe (Arg Type) -> tcm ()
instance Agda.TypeChecking.Reduce.InstantiateFull Agda.TypeChecking.Rules.LHS.LHSResult
instance GHC.Base.Semigroup Agda.TypeChecking.Rules.LHS.LeftoverPatterns
instance GHC.Base.Monoid Agda.TypeChecking.Rules.LHS.LeftoverPatterns
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)

module Agda.TypeChecking.Rules.Term

-- | Check that an expression is a type.
isType :: Expr -> Sort -> TCM Type

-- | Check that an expression is a type without knowing the 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.
noFunctionsIntoSize :: Type -> Type -> TCM ()

-- | 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 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
ifPath :: Type -> TCM a -> TCM a -> TCM a
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

-- | 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 :: 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
lambdaAddContext :: Name -> ArgName -> Dom Type -> TCM a -> TCM a

-- | Checking a lambda whose domain type has already been checked.
checkPostponedLambda :: 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 -> (MetaId -> 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 qname cs e t check pattern matching
--   lambda. Precondition: e = ExtendedLam i di qname cs
checkExtendedLambda :: Comparison -> ExprInfo -> DefInfo -> QName -> [Clause] -> Expr -> Type -> TCM Term

-- | Run a computation.
--   
--   
--   
- If successful, that's it, we are done.
--   
- If IlltypedPattern p a, NotADatatype a or
--   CannotEliminateWithPattern p a is thrown and type a
--   is blocked on some meta x, reset any changes to the state and
--   pass (the error and) x to the handler.
--   
- If SplitError (UnificationStuck c tel us vs _) is thrown
--   and the unification problem us =?= vs : tel is blocked on
--   some meta x pass x to the handler.
--   
- If another error was thrown or the type a is not blocked,
--   reraise the error.
--   
--   
--   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, MetaId) -> 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 ei recexpr fs e t Precondition e =
--   RecUpdate ei recexpr fs.
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

-- | Checking quoteGoal (deprecated)
quoteGoal :: Type -> TCM (Either [MetaId] Term)

-- | Checking quoteContext (deprecated)
quoteContext :: TCM (Either [MetaId] 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 :: (Type -> TCM (MetaId, Term)) -> Type -> MetaInfo -> InteractionId -> TCM Term

-- | Check an underscore without arguments.
checkUnderscore :: Type -> MetaInfo -> TCM Term

-- | Type check a meta variable.
checkMeta :: (Type -> TCM (MetaId, Term)) -> 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 :: (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 :: (Type -> TCM (MetaId, Term)) -> Maybe 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 -> 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 :: Expr -> TCM (Term, Type)
checkLetBindings :: [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.With

-- | Split pattern variables according to with-expressions.
splitTelForWith :: Telescope -> Type -> [EqualityView] -> [Term] -> (Telescope, Telescope, Permutation, Type, [EqualityView], [Term])

-- | Abstract with-expressions vs to generate type for with-helper
--   function.
--   
--   Each EqualityType, coming from a rewrite, will turn
--   into 2 abstractions.
withFunctionType :: Telescope -> [Term] -> [EqualityView] -> Telescope -> Type -> 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 :: [Term] -> [EqualityView] -> [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.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 -> TCM (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 ()

-- | 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 (Arg 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. This invariant is
--   broken before calls to fixTarget; there, scTarget lives
--   in the old context. fixTarget moves scTarget to the new
--   context by applying substitution scSubst.
[scTarget] :: SplitClause -> Maybe (Arg Type)

-- | Create a split clause from a clause in internal syntax. Used by
--   make-case.
clauseToSplitClause :: Clause -> SplitClause

-- | Update the target type, add more patterns to split clause if target
--   becomes a function type. Returns the domains of the function type (if
--   any).
fixTarget :: SplitClause -> TCM (Telescope, SplitClause)

-- | A Covering is the result of splitting a SplitClause.
data Covering
Covering :: Arg Nat -> [(SplitTag, SplitClause)] -> 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)]

-- | Project the split clauses out of a covering.
splitClauses :: Covering -> [SplitClause]

-- | Top-level function for checking pattern coverage.
--   
--   Effects:
--   
--   
--   
- Marks unreachable clauses as such in the signature.
--   
- Adds missing instances clauses to the signature.
--   
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.AllowPartialCover
instance GHC.Classes.Eq Agda.TypeChecking.Coverage.AllowPartialCover
instance GHC.Show.Show Agda.TypeChecking.Coverage.FixTarget
instance Agda.TypeChecking.Pretty.PrettyTCM Agda.TypeChecking.Coverage.SplitClause

module Agda.TypeChecking.Empty
data ErrorNonEmpty

-- | Generic failure
Fail :: ErrorNonEmpty

-- | Failure with informative error
FailBecause :: TCErr -> ErrorNonEmpty

-- | Emptyness check blocked
DontKnow :: ErrorNonEmpty

-- | Ensure that a type is empty. This check may be postponed as emptiness
--   constraint.
ensureEmptyType :: Range -> Type -> TCM ()

-- | Check whether a type is empty.
isEmptyType :: Type -> TCM Bool

-- | Check whether some type in a telescope is empty.
isEmptyTel :: Telescope -> TCM Bool
checkEmptyType :: Range -> Type -> TCM (Either ErrorNonEmpty ())

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

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, 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 t a => Int -> Int -> t -> a -> a
instance GHC.Show.Show Agda.TypeChecking.CompiledClause.Compile.Cl
instance GHC.Classes.Eq Agda.TypeChecking.CompiledClause.Compile.RunRecordPatternTranslation
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)

module Agda.TypeChecking.Rules.Record

-- | 
--   checkRecDef i name con ps contel fields
--   
--   
--   
--   
- name Record type identifier.
--   
- con Maybe constructor name and info.
--   
- ps Record parameters.
--   
- contel Approximate type of constructor
--   (fields -> Set). Does not include record parameters.
--   
- fields List of field signatures.
--   
checkRecDef :: DefInfo -> QName -> UniverseCheck -> Maybe (Ranged Induction) -> Maybe HasEta -> Maybe QName -> DataDefParams -> Expr -> [Field] -> TCM ()
addCompositionForRecord :: QName -> ConHead -> Telescope -> [Arg QName] -> Telescope -> Type -> TCM ()
defineCompKitR :: QName -> Telescope -> Telescope -> [Arg QName] -> Type -> TCM CompKit
defineTranspOrHCompR :: TranspOrHComp -> QName -> Telescope -> Telescope -> [Arg QName] -> Type -> TCM (Maybe QName)

-- | checkRecordProjections m r q tel ftel fs.
--   
--   
--   
- m  name of the generated module
--   
- r  name of the record type
--   
- con  name of the record constructor
--   
- tel  parameters and record variable r
--   ("self")
--   
- ftel  telescope of fields
--   
- fs  the fields to be checked
--   
checkRecordProjections :: ModuleName -> QName -> Bool -> ConHead -> Telescope -> Telescope -> [Declaration] -> TCM ()

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

-- | Insert some with-patterns into the with-clauses LHS of the given RHS.
--   (Used for rewrite.)
insertPatterns :: [Pattern] -> RHS -> RHS

-- | Insert with-patterns before the trailing with patterns. If there are
--   none, append the with-patterns.
insertPatternsLHSCore :: [Pattern] -> LHSCore -> LHSCore

-- | Parameters for creating a with-function.
data WithFunctionProblem
NoWithFunction :: WithFunctionProblem
WithFunction :: QName -> QName -> Type -> Telescope -> Telescope -> Telescope -> [Term] -> [EqualityView] -> Type -> [NamedArg DeBruijnPattern] -> Nat -> Permutation -> Permutation -> Permutation -> [Clause] -> 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.
[wfExprs] :: WithFunctionProblem -> [Term]

-- | Types of the with and rewrite expressions.
[wfExprTypes] :: WithFunctionProblem -> [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]
checkSystemCoverage :: QName -> [Int] -> Type -> [Clause] -> TCM System
data ClausesPostChecks
CPC :: [Int] -> ClausesPostChecks

-- | Which argument indexes have a partial split.
[cpcPartialSplits] :: ClausesPostChecks -> [Int]

-- | Type check a function clause.
checkClause :: Type -> Maybe Substitution -> SpineClause -> TCM (Clause, ClausesPostChecks)

-- | 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 -> [Term] -> [EqualityView] -> [Clause] -> TCM (Maybe Term, WithFunctionProblem)

-- | Invoked in empty context.
checkWithFunction :: [Name] -> WithFunctionProblem -> TCM ()

-- | 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 -> RHS -> 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.Rules.Application

-- | checkArguments 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 :: ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> (MaybeRanges -> Elims -> Type -> 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_ :: 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 -> NonemptyList QName -> Args -> Type -> Int -> Term -> Type -> TCM Term

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.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.ExtractCalls Agda.Syntax.Internal.Level
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.Common.Dom a)
instance Agda.Termination.TermCheck.ExtractCalls a => Agda.Termination.TermCheck.ExtractCalls (Agda.Syntax.Internal.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 Agda.Syntax.Internal.Sort
instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.Type
instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.Term
instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.PlusLevel
instance Agda.Termination.TermCheck.ExtractCalls Agda.Syntax.Internal.LevelAtom
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

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 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 :: Axiom -> 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 -> Axiom -> DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> Expr -> TCM ()

-- | Type check a primitive function declaration.
checkPrimitive :: DefInfo -> QName -> Expr -> TCM ()
assertCurrentModule :: QName -> String -> 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)

-- | Type check the type signature of an inductive or recursive definition.
checkTypeSignature :: TypeSignature -> TCM ()
checkTypeSignature' :: Maybe GeneralizeTelescope -> TypeSignature -> TCM ()

-- | Type check a module.
checkSection :: ModuleInfo -> 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 (top-level function, includes
--   traceCall).
checkSectionApplication :: ModuleInfo -> ModuleName -> ModuleApplication -> ScopeCopyInfo -> TCM ()

-- | Check an application of a section.
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.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

module Agda.Syntax.Abstract.Copatterns
translateCopatternClauses :: [Clause] -> ScopeM (Delayed, [Clause])
instance GHC.Classes.Ord Agda.Syntax.Abstract.Copatterns.ProjEntry
instance GHC.Classes.Eq Agda.Syntax.Abstract.Copatterns.ProjEntry
instance GHC.Base.Functor (Agda.Syntax.Abstract.Copatterns.Path a)
instance Agda.Syntax.Abstract.Copatterns.Alpha Agda.Syntax.Abstract.Name.Name
instance Agda.Syntax.Abstract.Copatterns.Alpha (Agda.Syntax.Abstract.Pattern' e)
instance Agda.Syntax.Abstract.Copatterns.Alpha (Agda.Syntax.Abstract.LHSCore' e)
instance Agda.Syntax.Abstract.Copatterns.Alpha Agda.Syntax.Abstract.LHS
instance Agda.Syntax.Abstract.Copatterns.Alpha a => Agda.Syntax.Abstract.Copatterns.Alpha (Agda.Syntax.Common.Arg a)
instance (GHC.Classes.Eq n, Agda.Syntax.Abstract.Copatterns.Alpha a) => Agda.Syntax.Abstract.Copatterns.Alpha (Agda.Syntax.Common.Named n a)
instance Agda.Syntax.Abstract.Copatterns.Alpha a => Agda.Syntax.Abstract.Copatterns.Alpha [a]
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Name.QName
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Name.Name
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.BindName
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Name.ModuleName
instance Agda.Syntax.Abstract.Copatterns.Rename a => Agda.Syntax.Abstract.Copatterns.Rename (Agda.Syntax.Concrete.FieldAssignment' a)
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.LetBinding
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.LamBinding
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.TypedBinding
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.ProblemEq
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Clause
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.RHS
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.WhereDeclarations
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.LHS
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.LHSCore
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Pattern
instance Agda.Syntax.Abstract.Copatterns.Rename Agda.Syntax.Abstract.Declaration
instance Agda.Syntax.Abstract.Copatterns.Rename a => Agda.Syntax.Abstract.Copatterns.Rename (Agda.Syntax.Common.Arg a)
instance Agda.Syntax.Abstract.Copatterns.Rename a => Agda.Syntax.Abstract.Copatterns.Rename (Agda.Syntax.Common.Named n a)
instance Agda.Syntax.Abstract.Copatterns.Rename a => Agda.Syntax.Abstract.Copatterns.Rename [a]
instance (Agda.Syntax.Abstract.Copatterns.Rename a, Agda.Syntax.Abstract.Copatterns.Rename b) => Agda.Syntax.Abstract.Copatterns.Rename (Data.Either.Either a b)
instance (Agda.Syntax.Abstract.Copatterns.Rename a, Agda.Syntax.Abstract.Copatterns.Rename b) => Agda.Syntax.Abstract.Copatterns.Rename (a, b)
instance Agda.Syntax.Position.HasRange Agda.Syntax.Abstract.Copatterns.ProjEntry

-- | 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 into an application.
parseApplication :: [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

module Agda.Syntax.IdiomBrackets
parseIdiomBrackets :: Range -> Expr -> ScopeM Expr

-- | Desugaring for do-notation. Uses whatever `_&gt;&gt;=_` and
--   `_&gt;&gt;_` 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 -> [DoStmt] -> ScopeM Expr

-- | 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 concrete abstract | concrete -> abstract
toAbstract :: ToAbstract concrete abstract => concrete -> ScopeM abstract

-- | This operation does not affect the scope, i.e. the original scope is
--   restored upon completion.
localToAbstract :: ToAbstract c a => c -> (a -> ScopeM b) -> ScopeM b
concreteToAbstract_ :: ToAbstract c a => c -> ScopeM a
concreteToAbstract :: ToAbstract c a => ScopeInfo -> c -> ScopeM a
newtype NewModuleQName
NewModuleQName :: QName -> NewModuleQName
newtype OldName a
OldName :: a -> OldName a

-- | 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 LeftHandSide
data RightHandSide
data PatName
data APatName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Pragma [Agda.Syntax.Abstract.Pragma]
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Definitions.Clause Agda.Syntax.Abstract.Clause
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.LeftHandSide Agda.Syntax.Abstract.LHS
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.AbstractRHS Agda.Syntax.Abstract.RHS
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.RightHandSide Agda.Syntax.Translation.ConcreteToAbstract.AbstractRHS
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.RHS Agda.Syntax.Translation.ConcreteToAbstract.AbstractRHS
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Definitions.NiceDeclaration Agda.Syntax.Abstract.Declaration
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.ConstrDecl Agda.Syntax.Abstract.Declaration
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 (Agda.Syntax.Abstract.GeneralizeTelescope, Agda.Syntax.Abstract.Expr)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.GenTel Agda.Syntax.Abstract.GeneralizeTelescope
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.Blind a) (Agda.Syntax.Translation.ConcreteToAbstract.Blind a)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.LetDefs [Agda.Syntax.Abstract.LetBinding]
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.LetDef [Agda.Syntax.Abstract.LetBinding]
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Expr Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.TypedBinding Agda.Syntax.Abstract.TypedBinding
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.TopLevel [Agda.Syntax.Concrete.Declaration]) Agda.Syntax.Translation.ConcreteToAbstract.TopLevelInfo
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 [a]
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.OldModuleName Agda.Syntax.Abstract.Name.ModuleName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.ModuleAssignment (Agda.Syntax.Abstract.Name.ModuleName, [Agda.Syntax.Abstract.LetBinding])
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.NewModuleQName Agda.Syntax.Abstract.Name.ModuleName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.NewModuleName Agda.Syntax.Abstract.Name.ModuleName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToQName Agda.Syntax.Concrete.Name.Name
instance Agda.Syntax.Translation.ConcreteToAbstract.ToQName Agda.Syntax.Concrete.Name.QName
instance (GHC.Show.Show a, Agda.Syntax.Translation.ConcreteToAbstract.ToQName a) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.OldName a) Agda.Syntax.Abstract.Name.QName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.PatName Agda.Syntax.Translation.ConcreteToAbstract.APatName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.ResolveQName Agda.Syntax.Scope.Base.ResolvedName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.LHSCore (Agda.Syntax.Abstract.LHSCore' Agda.Syntax.Concrete.Expr)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.OldQName Agda.Syntax.Abstract.Expr
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.Pattern (Agda.Syntax.Abstract.Pattern' Agda.Syntax.Concrete.Expr)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.NewName Agda.Syntax.Concrete.Name.Name) Agda.Syntax.Abstract.Name.Name
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Translation.ConcreteToAbstract.NewName Agda.Syntax.Concrete.BoundName) Agda.Syntax.Abstract.BindName
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.LamBinding Agda.Syntax.Abstract.LamBinding
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Translation.ConcreteToAbstract.RecordConstructorType Agda.Syntax.Abstract.Expr
instance (Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c1 a1, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c2 a2) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (c1, c2) (a1, a2)
instance (Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c1 a1, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c2 a2, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c3 a3) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (c1, c2, c3) (a1, a2, a3)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract [c] [a]
instance (Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c1 a1, Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c2 a2) => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Data.Either.Either c1 c2) (Data.Either.Either a1 a2)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (GHC.Maybe.Maybe c) (GHC.Maybe.Maybe a)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Concrete.FieldAssignment' c) (Agda.Syntax.Concrete.FieldAssignment' a)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract [Agda.Syntax.Concrete.Declaration] [Agda.Syntax.Abstract.Declaration]
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.WithHiding c) (Agda.Syntax.Common.WithHiding a)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.Arg c) (Agda.Syntax.Common.Arg a)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract c a => Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Common.Named name c) (Agda.Syntax.Common.Named name a)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Abstract.LHSCore' Agda.Syntax.Concrete.Expr) (Agda.Syntax.Abstract.LHSCore' Agda.Syntax.Abstract.Expr)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract (Agda.Syntax.Abstract.Pattern' Agda.Syntax.Concrete.Expr) (Agda.Syntax.Abstract.Pattern' Agda.Syntax.Abstract.Expr)
instance Agda.Syntax.Translation.ConcreteToAbstract.ToAbstract Agda.Syntax.Concrete.HoleContent Agda.Syntax.Abstract.HoleContent

-- | This module deals with finding imported modules and loading their
--   interface files.
module Agda.Interaction.Imports

-- | Some information about the source code.
data SourceInfo
SourceInfo :: Text -> FileType -> Module -> TopLevelModuleName -> SourceInfo

-- | Source code.
[siSource] :: SourceInfo -> Text

-- | Source file type
[siFileType] :: SourceInfo -> FileType

-- | The parsed module.
[siModule] :: SourceInfo -> Module

-- | The top-level module name.
[siModuleName] :: SourceInfo -> TopLevelModuleName

-- | Computes a SourceInfo record for the given file.
sourceInfo :: AbsolutePath -> TCM SourceInfo

-- | Is the aim to type-check the top-level module, or only to scope-check
--   it?
data Mode
ScopeCheck :: Mode
TypeCheck :: Mode

-- | Are we loading the interface for the user-loaded file or for an
--   import?
data MainInterface

-- | For the main file.
--   
--   In this case state changes inflicted by createInterface are
--   preserved.
MainInterface :: Mode -> MainInterface

-- | For an imported file.
--   
--   In this case state changes inflicted by createInterface are not
--   preserved.
NotMainInterface :: MainInterface

-- | Should state changes inflicted by createInterface be preserved?
includeStateChanges :: MainInterface -> Bool

-- | Merge an interface into the current proof state.
mergeInterface :: Interface -> TCM ()
addImportedThings :: Signature -> BuiltinThings PrimFun -> PatternSynDefns -> DisplayForms -> Map QName String -> [TCWarning] -> TCM ()

-- | Scope checks the given module. A proper version of the module name
--   (with correct definition sites) is returned.
scopeCheckImport :: ModuleName -> TCM (ModuleName, Map ModuleName Scope)
data MaybeWarnings' a
NoWarnings :: MaybeWarnings' a
SomeWarnings :: a -> MaybeWarnings' a
type MaybeWarnings = MaybeWarnings' [TCWarning]
applyFlagsToMaybeWarnings :: MaybeWarnings -> TCM MaybeWarnings
hasWarnings :: MaybeWarnings -> Bool

-- | If the module has already been visited (without warnings), then its
--   interface is returned directly. Otherwise the computation is used to
--   find the interface and the computed interface is stored for potential
--   later use (unless the MainInterface is MainInterface
--   ScopeCheck).
alreadyVisited :: TopLevelModuleName -> MainInterface -> PragmaOptions -> TCM (Interface, MaybeWarnings) -> TCM (Interface, MaybeWarnings)

-- | 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 :: AbsolutePath -> Mode -> SourceInfo -> TCM (Interface, MaybeWarnings)

-- | Tries to return the interface associated to the given (imported)
--   module. The time stamp of the relevant interface file is also
--   returned. Calls itself recursively for the imports of the given
--   module. May type check the module. An error is raised if a warning is
--   encountered.
--   
--   Do not use this for the main file, use typeCheckMain instead.
getInterface :: ModuleName -> TCM Interface

-- | See getInterface.
getInterface_ :: TopLevelModuleName -> Maybe SourceInfo -> TCM Interface

-- | A more precise variant of getInterface. If warnings are
--   encountered then they are returned instead of being turned into
--   errors.
getInterface' :: TopLevelModuleName -> MainInterface -> Maybe SourceInfo -> TCM (Interface, MaybeWarnings)

-- | Check if the options used for checking an imported module are
--   compatible with the current options. Raises Non-fatal errors if not.
checkOptionsCompatible :: PragmaOptions -> PragmaOptions -> ModuleName -> TCM Bool

-- | Check whether interface file exists and is in cache in the correct
--   version (as testified by the interface file hash).
isCached :: TopLevelModuleName -> AbsolutePath -> MaybeT TCM Interface

-- | Try to get the interface from interface file or cache.
getStoredInterface :: TopLevelModuleName -> AbsolutePath -> MainInterface -> Maybe SourceInfo -> TCM (Bool, (Interface, MaybeWarnings))

-- | Run the type checker on a file and create an interface.
--   
--   Mostly, this function calls createInterface. But if it is not
--   the main module we check, we do it in a fresh state, suitably
--   initialize, in order to forget some state changes after successful
--   type checking.
typeCheck :: TopLevelModuleName -> AbsolutePath -> MainInterface -> Maybe SourceInfo -> TCM (Bool, (Interface, MaybeWarnings))

-- | Formats and outputs the Checking, Finished and "Loading
--   " messages.
chaseMsg :: String -> TopLevelModuleName -> Maybe String -> TCM ()

-- | Print the highlighting information contained in the given interface.
highlightFromInterface :: Interface -> AbsolutePath -> TCM ()
readInterface :: FilePath -> TCM (Maybe Interface)

-- | Writes the given interface to the given file.
writeInterface :: FilePath -> Interface -> TCM ()
removePrivates :: ScopeInfo -> ScopeInfo
concreteOptionsToOptionPragmas :: [Pragma] -> TCM [OptionsPragma]

-- | Tries to type check a module and write out its interface. The function
--   only writes out an interface file if it does not encounter any
--   warnings.
--   
--   If appropriate this function writes out syntax highlighting
--   information.
createInterface :: AbsolutePath -> TopLevelModuleName -> MainInterface -> Maybe SourceInfo -> TCM (Interface, MaybeWarnings)
getUniqueMetasRanges :: [MetaId] -> TCM [Range]
getUnsolvedMetas :: TCM [Range]
getAllUnsolved :: TCM [TCWarning]

-- | Collect all warnings that have accumulated in the state.
getAllWarnings :: WhichWarnings -> TCM [TCWarning]

-- | Expert version of getAllWarnings; if isMain is a
--   MainInterface, the warnings definitely include also unsolved
--   warnings.
getAllWarnings' :: MainInterface -> WhichWarnings -> TCM [TCWarning]
getMaybeWarnings :: WhichWarnings -> TCM MaybeWarnings
getMaybeWarnings' :: MainInterface -> WhichWarnings -> TCM MaybeWarnings
getAllWarningsOfTCErr :: TCErr -> TCM [TCWarning]

-- | Reconstruct the iScope (not serialized) from the
--   iInsideScope (serialized).
constructIScope :: Interface -> Interface

-- | Builds an interface for the current module, which should already have
--   been successfully type checked.
buildInterface :: Text -> FileType -> TopLevelInfo -> [OptionsPragma] -> TCM Interface

-- | Returns (iSourceHash, iFullHash)
getInterfaceFileHashes :: FilePath -> TCM (Maybe (Hash, Hash))
moduleHash :: ModuleName -> TCM Hash

-- | 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
instance Data.Traversable.Traversable Agda.Interaction.Imports.MaybeWarnings'
instance Data.Foldable.Foldable Agda.Interaction.Imports.MaybeWarnings'
instance GHC.Base.Functor Agda.Interaction.Imports.MaybeWarnings'
instance GHC.Show.Show a => GHC.Show.Show (Agda.Interaction.Imports.MaybeWarnings' a)
instance GHC.Show.Show Agda.Interaction.Imports.MainInterface
instance GHC.Classes.Eq Agda.Interaction.Imports.MainInterface
instance GHC.Show.Show Agda.Interaction.Imports.Mode
instance GHC.Classes.Eq Agda.Interaction.Imports.Mode
instance Agda.Utils.Null.Null a => Agda.Utils.Null.Null (Agda.Interaction.Imports.MaybeWarnings' a)

-- | Generate an import dependency graph for a given module.
module Agda.Interaction.Highlighting.Dot

-- | Internal module identifiers for construction of dependency graph.
type ModuleId = String
data DotState
DotState :: Map ModuleName ModuleId -> [ModuleId] -> Set (ModuleId, ModuleId) -> DotState

-- | Records already processed modules and maps them to an internal
--   identifier.
[dsModules] :: DotState -> Map ModuleName ModuleId

-- | Supply of internal identifiers.
[dsNameSupply] :: DotState -> [ModuleId]

-- | Edges of dependency graph.
[dsConnection] :: DotState -> Set (ModuleId, ModuleId)
initialDotState :: DotState
type DotM = StateT DotState TCM

-- | Translate a ModuleName to an internal ModuleId. Returns
--   True if the ModuleName is new, i.e., has not been
--   encountered before and is thus added to the map of processed modules.
addModule :: ModuleName -> DotM (ModuleId, Bool)

-- | Add an arc from importer to imported.
addConnection :: ModuleId -> ModuleId -> DotM ()

-- | Recursively build import graph, starting from given Interface.
--   Modifies the state in DotM and returns the ModuleId of
--   the Interface.
dottify :: Interface -> DotM ModuleId

-- | Generate a .dot file for the import graph starting with the given
--   Interface and write it to the file specified by the command
--   line option.
generateDot :: Interface -> TCM ()

-- | 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 Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Highlighting.Precise.TokenBased

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

-- | Parses an expression.
parseExpr :: Range -> String -> TCM Expr
parseExprIn :: InteractionId -> Range -> String -> TCM Expr
giveExpr :: UseForce -> Maybe InteractionId -> MetaId -> Expr -> TCM ()

-- | 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 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 :: Expr -> TCM Expr
evalInMeta :: InteractionId -> Expr -> TCM Expr

-- | Modifier for interactive commands, specifying the amount of
--   normalization in the output.
data Rewrite
AsIs :: Rewrite
Instantiated :: Rewrite
HeadNormal :: Rewrite
Simplified :: Rewrite
Normalised :: Rewrite
normalForm :: (Reduce t, Simplify t, Normalise t) => Rewrite -> t -> TCM t

-- | Modifier for the interactive computation command, specifying the mode
--   of computation and result display.
data ComputeMode
DefaultCompute :: ComputeMode
IgnoreAbstract :: ComputeMode
UseShowInstance :: ComputeMode
computeIgnoreAbstract :: ComputeMode -> Bool
computeWrapInput :: ComputeMode -> String -> String
showComputed :: ComputeMode -> Expr -> TCM Doc

-- | Modifier for interactive commands, specifying whether safety checks
--   should be ignored.
data UseForce

-- | Ignore additional checks, like termination/positivity...
WithForce :: UseForce

-- | Don't ignore any checks.
WithoutForce :: UseForce
data OutputForm a b
OutputForm :: Range -> [ProblemId] -> 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
Guard :: OutputConstraint a b -> ProblemId -> 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)] -> OutputConstraint a b
PTSInstance :: b -> b -> OutputConstraint a b
PostponedCheckFunDef :: QName -> a -> 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
outputFormId :: OutputForm a b -> b
reifyElimToExpr :: Elim -> TCM Expr
getConstraints :: TCM [OutputForm Expr Expr]
getConstraints' :: (ProblemConstraint -> Bool) -> TCM [OutputForm Expr Expr]

-- | 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]
metaHelperType :: Rewrite -> InteractionId -> Range -> String -> TCM (OutputConstraint' Expr Expr)
contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputConstraint' Expr Name]

-- | 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
withInteractionId :: InteractionId -> TCM a -> TCM a
withMetaId :: MetaId -> TCM a -> TCM a

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

-- | 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 -> QName -> TCM ([Name], Telescope, [(Name, Type)])
whyInScope :: String -> TCM (Maybe LocalVar, [AbstractName], [AbstractModule])
instance GHC.Base.Functor (Agda.Interaction.BasicOps.OutputForm a)
instance GHC.Base.Functor (Agda.Interaction.BasicOps.OutputConstraint a)
instance GHC.Show.Show Agda.Interaction.BasicOps.UseForce
instance GHC.Read.Read Agda.Interaction.BasicOps.UseForce
instance GHC.Classes.Eq Agda.Interaction.BasicOps.UseForce
instance GHC.Classes.Eq Agda.Interaction.BasicOps.ComputeMode
instance GHC.Read.Read Agda.Interaction.BasicOps.ComputeMode
instance GHC.Show.Show Agda.Interaction.BasicOps.ComputeMode
instance GHC.Read.Read Agda.Interaction.BasicOps.Rewrite
instance GHC.Show.Show Agda.Interaction.BasicOps.Rewrite
instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Interaction.BasicOps.OutputConstraint' a b)
instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete b d) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Interaction.BasicOps.OutputConstraint' a b) (Agda.Interaction.BasicOps.OutputConstraint' c d)
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.TypeChecking.Monad.Base.ProblemConstraint (Agda.TypeChecking.Monad.Base.Closure (Agda.Interaction.BasicOps.OutputForm Agda.Syntax.Abstract.Expr Agda.Syntax.Abstract.Expr))
instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Interaction.BasicOps.OutputForm a b)
instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete b d) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Interaction.BasicOps.OutputForm a b) (Agda.Interaction.BasicOps.OutputForm c d)
instance Agda.Syntax.Translation.InternalToAbstract.Reify Agda.TypeChecking.Monad.Base.Constraint (Agda.Interaction.BasicOps.OutputConstraint Agda.Syntax.Abstract.Expr Agda.Syntax.Abstract.Expr)
instance (Agda.Utils.Pretty.Pretty a, Agda.Utils.Pretty.Pretty b) => Agda.Utils.Pretty.Pretty (Agda.Interaction.BasicOps.OutputConstraint a b)
instance (Agda.Syntax.Translation.AbstractToConcrete.ToConcrete a c, Agda.Syntax.Translation.AbstractToConcrete.ToConcrete b d) => Agda.Syntax.Translation.AbstractToConcrete.ToConcrete (Agda.Interaction.BasicOps.OutputConstraint a b) (Agda.Interaction.BasicOps.OutputConstraint c d)

module Agda.Interaction.SearchAbout
findMentions :: Rewrite -> Range -> String -> ScopeM [(Name, Type)]

module Agda.Interaction.MakeCase
type CaseContext = Maybe ExtLamInfo

-- | Parse variables (visible or hidden), returning their de Bruijn
--   indices. Used in makeCase.
parseVariables :: QName -> Telescope -> 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)

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

-- | Make clause with no rhs (because of absurd match).
makeAbsurdClause :: QName -> SplitClause -> TCM Clause

-- | Make a clause with a question mark as rhs.
makeAbstractClause :: QName -> RHS -> SplitClause -> TCM Clause

module Agda.Auto.Convert
data Hint
Hint :: Bool -> QName -> Hint
[hintIsConstructor] :: Hint -> Bool
[hintQName] :: Hint -> QName
type O = (Maybe Int, 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
getMeta :: MetaId -> TOM (Metavar (Exp O) (RefInfo O))
getEqs :: TCM [(Bool, Term, Term)]
copatternsNotImplemented :: TCM a
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.Interaction.CommandLine
data ExitCode a
Continue :: ExitCode a
ContinueIn :: TCEnv -> ExitCode a
Return :: a -> ExitCode a
type Command a = (String, [String] -> TCM (ExitCode a))
matchCommand :: String -> [Command a] -> Either [String] ([String] -> TCM (ExitCode a))
interaction :: String -> [Command a] -> (String -> TCM (ExitCode a)) -> IM a

-- | The interaction loop.
interactionLoop :: TCM (Maybe Interface) -> IM ()
continueAfter :: TCM a -> TCM (ExitCode b)

-- | Set envCurrentPath to optInputFile.
withCurrentFile :: TCM a -> TCM a
loadFile :: TCM () -> [String] -> TCM ()
showConstraints :: [String] -> TCM ()
showMetas :: [String] -> TCM ()
showScope :: TCM ()
metaParseExpr :: InteractionId -> String -> TCM Expr
actOnMeta :: [String] -> (InteractionId -> Expr -> TCM a) -> TCM a
giveMeta :: [String] -> TCM ()
refineMeta :: [String] -> TCM ()
retryConstraints :: TCM ()
evalIn :: [String] -> TCM ()
parseExpr :: String -> TCM Expr
evalTerm :: String -> TCM (ExitCode a)
typeOf :: [String] -> TCM ()
typeIn :: [String] -> TCM ()
showContext :: [String] -> TCM ()

-- | The logo that prints when Agda is started in interactive mode.
splashScreen :: String

-- | The help message
help :: [Command a] -> IO ()

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:
--   
--   
--   
- Solutions [(ii,s)] A list of solutions s for
--   interaction ids ii. In particular, Solutions []
--   means Agsy found no solution.
--   
- FunClauses cs A list of clauses for the interaction id
--   ii in which Auto was invoked with case-splitting turned
--   on.
--   
- Refinement s A refinement for the interaction id
--   ii in which Auto was invoked.
--   
data AutoProgress
Solutions :: [(InteractionId, String)] -> AutoProgress
FunClauses :: [String] -> AutoProgress
Refinement :: String -> AutoProgress

module Agda.Compiler.Common
data IsMain
IsMain :: IsMain
NotMain :: IsMain
doCompile :: forall r. Monoid r => IsMain -> Interface -> (IsMain -> Interface -> TCM r) -> TCM r
setInterface :: Interface -> TCM ()
curIF :: TCM Interface
curSig :: TCM Signature
curMName :: TCM ModuleName
curDefs :: TCM Definitions
sortDefs :: Definitions -> [(QName, Definition)]
sigMName :: Signature -> ModuleName
compileDir :: TCM FilePath
repl :: [String] -> String -> String

-- | Copy pasted from MAlonzo.... Move somewhere else!
conArityAndPars :: QName -> TCM (Nat, Nat)

-- | Sets up the compilation environment.
inCompilerEnv :: Interface -> TCM a -> TCM a
topLevelModuleName :: ModuleName -> TCM ModuleName
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

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 :: CompilerPragma -> TCM HaskellPragma
getHaskellPragma :: QName -> TCM (Maybe HaskellPragma)
sanityCheckPragma :: Definition -> Maybe HaskellPragma -> TCM ()
getHaskellConstructor :: QName -> TCM (Maybe HaskellCode)

-- | Get content of FOREIGN GHC pragmas, sorted by
--   KindOfForeignCode: file header pragmas, import statements,
--   rest.
foreignHaskell :: TCM ([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

module Agda.Compiler.MAlonzo.Misc
curHsMod :: TCM ModuleName
ihname :: String -> Nat -> Name
unqhname :: String -> QName -> Name
tlmodOf :: ModuleName -> TCM ModuleName
xqual :: QName -> Name -> TCM QName
xhqn :: String -> QName -> TCM QName
hsName :: String -> QName
conhqn :: QName -> TCM QName
bltQual :: String -> String -> TCM 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
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 :: ModuleName -> ModuleName
mazerror :: String -> a
mazCoerceName :: String
mazErasedName :: String
mazAnyTypeName :: String
mazCoerce :: Exp
mazIncompleteMatch :: Exp
rtmIncompleteMatch :: QName -> Exp
mazUnreachableError :: Exp
rtmUnreachableError :: Exp
mazAnyType :: Type
mazRTE :: ModuleName
rtmQual :: String -> QName
rtmVar :: String -> Exp
rtmError :: String -> 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

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.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.Primitives
isMainFunction :: QName -> Defn -> Bool
hasMainFunction :: Interface -> IsMain

-- | Check that the main function has type IO a, for some a.
checkTypeOfMain :: IsMain -> QName -> Definition -> TCM [Decl] -> TCM [Decl]
treelessPrimName :: TPrim -> String

-- | Haskell modules to be imported for BUILT-INs
importsForPrim :: TCM [ModuleName]
xForPrim :: [(String, TCM [a])] -> TCM [a]

-- | Definition bodies for primitive functions
primBody :: String -> TCM Exp
noCheckCover :: QName -> TCM Bool
pconName :: String -> TCM String
bltQual' :: String -> String -> TCM String

-- | Translating Agda types to Haskell types. Used to ensure that imported
--   Haskell functions have the right type.
module Agda.Compiler.MAlonzo.HaskellTypes
haskellType :: QName -> TCM Type
checkConstructorCount :: QName -> [QName] -> [HaskellCode] -> TCM ()
hsTelApproximation :: Type -> TCM ([Type], Type)
hsTelApproximation' :: PolyApprox -> Type -> TCM ([Type], Type)
instance GHC.Classes.Eq Agda.Compiler.MAlonzo.HaskellTypes.PolyApprox

-- | Function for generating highlighted and aligned LaTeX from literate
--   Agda source.
module Agda.Interaction.Highlighting.LaTeX

-- | Generates a LaTeX file for the given interface.
--   
--   The underlying source file is assumed to match the interface, but this
--   is not checked. TODO: Fix this problem, perhaps by storing the source
--   code in the interface.
generateLaTeX :: Interface -> TCM ()
instance GHC.Show.Show Agda.Interaction.Highlighting.LaTeX.Debug
instance GHC.Classes.Eq Agda.Interaction.Highlighting.LaTeX.Debug
instance GHC.Show.Show Agda.Interaction.Highlighting.LaTeX.Token
instance GHC.Show.Show Agda.Interaction.Highlighting.LaTeX.Output
instance GHC.Show.Show Agda.Interaction.Highlighting.LaTeX.AlignmentColumn
instance GHC.Show.Show Agda.Interaction.Highlighting.LaTeX.Kind
instance GHC.Classes.Eq Agda.Interaction.Highlighting.LaTeX.Kind

-- | Function for generating highlighted, hyperlinked HTML from Agda
--   sources.
module Agda.Interaction.Highlighting.HTML
generateHTML :: TCM ()

-- | The name of the default CSS file.
defaultCSSFile :: FilePath

-- | Prepare information for HTML page generation.
--   
--   The page generator receives the output directory as well as the
--   module's top level module name, its source code, and its highlighting
--   information.
generateHTMLWithPageGen :: PageGen -> TCM ()

-- | Generates a highlighted, hyperlinked version of the given module.
generatePage :: (FilePath -> FilePath -> Text) -> String -> FilePath -> TopLevelModuleName -> TCM ()

-- | Constructs the web page, including headers.
page :: FilePath -> Bool -> TopLevelModuleName -> Html -> Text

-- | Constructs token stream ready to print.
tokenStream :: Text -> CompressedFile -> [TokenInfo]

-- | Constructs the HTML displaying the code.
code :: Bool -> FileType -> [TokenInfo] -> Html

-- | Interface for compiler backend writers.
module Agda.Compiler.Backend
data Backend
[Backend] :: 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 ModuleName mod -> TCM ()) -> (env -> ModuleName -> FilePath -> TCM (Recompile menv mod)) -> (env -> menv -> IsMain -> ModuleName -> [def] -> TCM mod) -> (env -> menv -> IsMain -> Definition -> TCM def) -> 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 ModuleName 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.
[preModule] :: Backend' opts env menv mod def -> env -> ModuleName -> FilePath -> TCM (Recompile menv mod)

-- | Called after all definitions of a module has been compiled.
[postModule] :: Backend' opts env menv mod def -> env -> menv -> IsMain -> ModuleName -> [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
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)
backendInteraction :: [Backend] -> (TCM (Maybe Interface) -> TCM ()) -> TCM (Maybe Interface) -> TCM ()
parseBackendOptions :: [Backend] -> [String] -> CommandLineOptions -> OptM ([Backend], CommandLineOptions)
callBackend :: String -> IsMain -> Interface -> TCM ()

module Agda.Interaction.InteractionTop

-- | Print open metas nicely.
showOpenMetas :: TCM [String]
data GiveRefine
Give :: GiveRefine
Refine :: GiveRefine
Intro :: GiveRefine
ElaborateGive :: GiveRefine

-- | Available backends.
data CompilerBackend
LaTeX :: CompilerBackend
QuickLaTeX :: CompilerBackend
OtherBackend :: String -> CompilerBackend

-- | The Parse monad. StateT state holds the remaining input.
type Parse a = ExceptT String (StateT String Identity) a

-- | Used to indicate whether something should be removed or not.
data Remove
Remove :: Remove
Keep :: Remove
data IOTCM' range
IOTCM :: FilePath -> HighlightingLevel -> HighlightingMethod -> Interaction' range -> IOTCM' range
type IOTCM = IOTCM' 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 :: 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

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

-- | An interactive computation.
type Interaction = Interaction' 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)

-- | IOTCM commands.
type Command = Command' IOTCM

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

-- | Monad for computing answers to interactive commands.
--   
--   CommandM is TCMT extended with state
--   CommandState.
type CommandM = StateT CommandState TCM
type OldInteractionScopes = Map InteractionId ScopeInfo

-- | Auxiliary state of an interactive computation.
data CommandState
CommandState :: [InteractionId] -> Maybe (AbsolutePath, ClockTime) -> 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). The
--   ClockTime is the modification time stamp of the file when it
--   was last loaded.
[theCurrentFile] :: CommandState -> Maybe (AbsolutePath, ClockTime)

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

-- | Initial auxiliary interaction state
initCommandState :: CommandQueue -> CommandState

-- | 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. Use only if main errors
--   are already catched.
commandMToIO :: (forall x. (CommandM a -> IO x) -> IO x) -> CommandM a

-- | Lift a TCM action transformer to a CommandM action transformer.
liftCommandMT :: (forall a. TCM a -> TCM a) -> CommandM a -> CommandM a

-- | Ditto, but restore state.
liftCommandMTLocalState :: (forall a. TCM a -> TCM a) -> 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

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

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

-- | Show warnings
interpretWarnings :: CommandM (String, String)

-- | 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 -> ((Interface, MaybeWarnings) -> CommandM ()) -> CommandM ()

-- | Set envCurrentPath to theCurrentFile, if any.
withCurrentFile :: 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 :: [InteractionId] -> TCM [InteractionId]

-- | Pretty-prints the type of the meta-variable.
prettyTypeOfMeta :: Rewrite -> InteractionId -> TCM Doc

-- | Pretty-prints the context of the given meta-variable.
prettyContext :: Rewrite -> Bool -> InteractionId -> TCM Doc

-- | Create type of application of new helper function that would solve the
--   goal.
cmd_helper_function :: Rewrite -> InteractionId -> Range -> String -> TCM Doc

-- | Displays the current goal, the given document, and the current
--   context.
--   
--   Should not modify the state.
cmd_goal_type_context_and :: Doc -> Rewrite -> InteractionId -> Range -> String -> StateT CommandState (TCMT IO) ()

-- | 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 ()
refreshStr :: [String] -> String -> ([String], String)
nameModifiers :: [String]

-- | Parses and scope checks an expression (using the "inside scope" as the
--   scope), performs the given command with the expression as input, and
--   displays the result.
parseAndDoAtToplevel :: (Expr -> TCM Doc) -> (Doc -> DisplayInfo) -> String -> CommandM ()
maybeTimed :: CommandM a -> CommandM (Maybe Doc, 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
instance Data.Traversable.Traversable Agda.Interaction.InteractionTop.IOTCM'
instance Data.Foldable.Foldable Agda.Interaction.InteractionTop.IOTCM'
instance GHC.Base.Functor Agda.Interaction.InteractionTop.IOTCM'
instance GHC.Read.Read range => GHC.Read.Read (Agda.Interaction.InteractionTop.IOTCM' range)
instance GHC.Show.Show range => GHC.Show.Show (Agda.Interaction.InteractionTop.IOTCM' range)
instance Data.Traversable.Traversable Agda.Interaction.InteractionTop.Interaction'
instance Data.Foldable.Foldable Agda.Interaction.InteractionTop.Interaction'
instance GHC.Base.Functor Agda.Interaction.InteractionTop.Interaction'
instance GHC.Read.Read range => GHC.Read.Read (Agda.Interaction.InteractionTop.Interaction' range)
instance GHC.Show.Show range => GHC.Show.Show (Agda.Interaction.InteractionTop.Interaction' range)
instance GHC.Classes.Eq Agda.Interaction.InteractionTop.CompilerBackend
instance GHC.Read.Read Agda.Interaction.InteractionTop.Remove
instance GHC.Show.Show Agda.Interaction.InteractionTop.Remove
instance GHC.Show.Show a => GHC.Show.Show (Agda.Interaction.InteractionTop.Command' a)
instance GHC.Show.Show Agda.Interaction.InteractionTop.CompilerBackend
instance GHC.Read.Read Agda.Interaction.InteractionTop.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 a => GHC.Read.Read (Agda.Syntax.Position.Position' a)

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.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 Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.Status
instance Data.Aeson.Types.ToJSON.ToJSON Agda.Syntax.Common.InteractionId
instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.GiveResult
instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.MakeCaseVariant
instance Data.Aeson.Types.ToJSON.ToJSON Agda.Interaction.Response.DisplayInfo

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

module Agda.Compiler.MAlonzo.Compiler
ghcBackend :: Backend
ghcBackend' :: Backend' GHCOptions GHCOptions GHCModuleEnv IsMain [Decl]
data GHCOptions
GHCOptions :: Bool -> Bool -> [String] -> GHCOptions
[optGhcCompile] :: GHCOptions -> Bool
[optGhcCallGhc] :: GHCOptions -> Bool
[optGhcFlags] :: GHCOptions -> [String]
defaultGHCOptions :: GHCOptions
ghcCommandLineFlags :: [OptDescr (Flag GHCOptions)]
ghcPreCompile :: GHCOptions -> TCM GHCOptions
ghcPostCompile :: GHCOptions -> IsMain -> Map ModuleName IsMain -> TCM ()

-- | This environment is no longer used for anything.
type GHCModuleEnv = ()
ghcPreModule :: GHCOptions -> ModuleName -> FilePath -> TCM (Recompile GHCModuleEnv IsMain)
ghcPostModule :: GHCOptions -> GHCModuleEnv -> IsMain -> ModuleName -> [[Decl]] -> TCM IsMain
ghcCompileDef :: GHCOptions -> GHCModuleEnv -> IsMain -> Definition -> TCM [Decl]
imports :: TCM [ImportDecl]
definition :: GHCModuleEnv -> IsMain -> Definition -> TCM [Decl]
constructorCoverageCode :: QName -> Int -> [QName] -> HaskellType -> [HaskellCode] -> TCM [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
type CC = ReaderT CCEnv TCM
freshNames :: Int -> ([Name] -> CC a) -> CC a

-- | Introduce n variables into the context.
intros :: Int -> ([Name] -> CC a) -> CC a
checkConstructorType :: QName -> HaskellCode -> TCM [Decl]
checkCover :: QName -> HaskellType -> Nat -> [QName] -> [HaskellCode] -> TCM [Decl]
closedTerm :: TTerm -> TCM Exp
mkIf :: TTerm -> CC TTerm

-- | Extract Agda term to Haskell expression. Erased arguments are
--   extracted as (). Types are extracted as ().
term :: TTerm -> CC Exp
hsCoerce :: Exp -> Exp
compilePrim :: TPrim -> Exp
alt :: Int -> TAlt -> CC Alt
literal :: Literal -> Exp
hslit :: Literal -> Literal
litString :: String -> Exp
litqname :: QName -> Exp
litqnamepat :: QName -> Pat
erasedArity :: QName -> TCM Nat
condecl :: QName -> Induction -> TCM ConDecl
compiledcondecl :: QName -> TCM Decl
compiledTypeSynonym :: QName -> String -> Nat -> Decl
tvaldecl :: QName -> Induction -> Nat -> [ConDecl] -> Maybe Clause -> [Decl]
infodecl :: QName -> [Decl] -> [Decl]
copyRTEModules :: TCM ()
writeModule :: Module -> TCM ()
outFile' :: Pretty a => a -> TCM (FilePath, FilePath)
outFile :: ModuleName -> TCM FilePath
outFile_ :: TCM FilePath
callGHC :: GHCOptions -> IsMain -> Map ModuleName IsMain -> TCM ()

module Agda.Compiler.JS.Compiler
jsBackend :: Backend
jsBackend' :: Backend' JSOptions JSOptions JSModuleEnv () (Maybe Export)
data JSOptions
JSOptions :: Bool -> JSOptions
[optJSCompile] :: JSOptions -> Bool
defaultJSOptions :: JSOptions
jsCommandLineFlags :: [OptDescr (Flag JSOptions)]
jsPreCompile :: JSOptions -> TCM JSOptions
jsPostCompile :: JSOptions -> IsMain -> a -> TCM ()
type JSModuleEnv = Maybe CoinductionKit
jsPreModule :: JSOptions -> ModuleName -> FilePath -> TCM (Recompile JSModuleEnv ())
jsPostModule :: JSOptions -> JSModuleEnv -> IsMain -> ModuleName -> [Maybe Export] -> TCM ()
jsCompileDef :: JSOptions -> JSModuleEnv -> IsMain -> Definition -> TCM (Maybe Export)
prefix :: [Char]
jsMod :: ModuleName -> GlobalId
jsFileName :: GlobalId -> String
jsMember :: Name -> MemberId
global' :: QName -> TCM (Exp, [MemberId])
global :: QName -> TCM (Exp, [MemberId])
reorder :: [Export] -> [Export]
reorder' :: Set [MemberId] -> [Export] -> [Export]
isTopLevelValue :: Export -> Bool
isEmptyObject :: Export -> Bool
insertAfter :: Set [MemberId] -> Export -> [Export] -> [Export]
curModule :: IsMain -> TCM Module
definition :: Maybe CoinductionKit -> (QName, Definition) -> TCM (Maybe Export)

-- | Ensure that there is at most one pragma for a name.
checkCompilerPragmas :: QName -> TCM ()
defJSDef :: Definition -> Maybe String
definition' :: Maybe CoinductionKit -> QName -> Definition -> Type -> [MemberId] -> TCM (Maybe Export)
compileTerm :: TTerm -> TCM Exp
compileTerm' :: Maybe CoinductionKit -> TTerm -> TCM Exp
compilePrim :: TPrim -> Exp
compileAlt :: TAlt -> TCM (MemberId, Exp)
visitorName :: QName -> TCM MemberId
flatName :: MemberId
local :: Nat -> Exp
qname :: QName -> TCM Exp
literal :: Literal -> Exp
litqname :: QName -> Exp
writeModule :: Module -> TCM ()
outFile :: GlobalId -> TCM FilePath
outFile_ :: TCM FilePath
copyRTEModules :: TCM ()

-- | Primitives implemented in the JS Agda RTS.
primitives :: Set String

-- | Agda main module.
module Agda.Main
builtinBackends :: [Backend]

-- | The main function
runAgda :: [Backend] -> IO ()
runAgda' :: [Backend] -> IO ()
defaultInteraction :: CommandLineOptions -> TCM (Maybe Interface) -> TCM ()

-- | Run Agda with parsed command line options and with a custom HTML
--   generator
runAgdaWithOptions :: [Backend] -> TCM () -> (TCM (Maybe Interface) -> TCM a) -> String -> CommandLineOptions -> TCM (Maybe a)

-- | Print usage information.
printUsage :: [Backend] -> Help -> IO ()
backendUsage :: Backend -> String

-- | Print version information.
printVersion :: [Backend] -> IO ()

-- | What to do for bad options.
optionError :: String -> IO ()

-- | Run a TCM action in IO; catch and pretty print errors.
runTCMPrettyErrors :: TCM () -> IO ()

-- | Main
main :: IO ()
