    {-# OPTIONS_GHC -Wunused-imports #-}

    {-# LANGUAGE NondecreasingIndentation #-}

    module Agda.TypeChecking.Rules.Builtin
      ( bindBuiltin
      , bindBuiltinNoDef
      , builtinKindOfName
      , bindPostulatedName
      , isUntypedBuiltin
      , bindUntypedBuiltin
      ) where

    import Prelude hiding (null)

    import Control.Monad.Except      ( catchError )
    import Control.Monad.Trans.Maybe

    import Data.List (find, sortBy)
    import Data.Function (on)

    import Agda.Interaction.Options.Base

    import qualified Agda.Syntax.Abstract as A
    import Agda.Syntax.Common
    import Agda.Syntax.Internal
    import Agda.Syntax.Position
    import Agda.Syntax.Scope.Base

    import Agda.TypeChecking.Monad

    import qualified Agda.TypeChecking.CompiledClause as CC
    import Agda.TypeChecking.Conversion
    import Agda.TypeChecking.Constraints ( noConstraints )
    import Agda.TypeChecking.Functions
    import Agda.TypeChecking.Names
    import Agda.TypeChecking.Pretty
    import Agda.TypeChecking.Primitive
    import Agda.TypeChecking.Positivity.Occurrence
    import Agda.TypeChecking.Reduce
    import Agda.TypeChecking.Substitute
    import Agda.TypeChecking.Telescope
    import Agda.TypeChecking.Warnings

    import {-# SOURCE #-} Agda.TypeChecking.Rules.Term ( checkExpr , inferExpr )
    import {-# SOURCE #-} Agda.TypeChecking.Rules.Builtin.Coinduction
    import {-# SOURCE #-} Agda.TypeChecking.Rewriting

    import Agda.Utils.Functor
    import Agda.Utils.List
    import Agda.Utils.List1 (pattern (:|))
    import Agda.Utils.Maybe
    import Agda.Utils.Monad
    import Agda.Utils.Null
    import Agda.Utils.Size

    import Agda.Utils.Impossible

    ---------------------------------------------------------------------------
    -- * Checking builtin pragmas
    ---------------------------------------------------------------------------

    builtinPostulate :: TCM Type -> BuiltinDescriptor
    builtinPostulate :: TCM Type -> BuiltinDescriptor
    builtinPostulate = Relevance -> TCM Type -> BuiltinDescriptor
    BuiltinPostulate Relevance
    relevant

    builtinPostulateC :: Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC :: Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    c TCM Type
    m =
      TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type -> BuiltinDescriptor) -> TCM Type -> BuiltinDescriptor
    forall a b. (a -> b) -> a -> b
    $ Cubical -> TCM ()
    requireCubical Cubical
    c TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> TCM Type
    m

    findBuiltinInfo :: BuiltinId -> Maybe BuiltinInfo
    findBuiltinInfo :: BuiltinId -> Maybe BuiltinInfo
    findBuiltinInfo BuiltinId
    b = (BuiltinInfo -> Bool) -> [BuiltinInfo] -> Maybe BuiltinInfo
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
    find ((BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) (BuiltinId -> Bool)
    -> (BuiltinInfo -> BuiltinId) -> BuiltinInfo -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . BuiltinInfo -> BuiltinId
    builtinName) [BuiltinInfo]
    coreBuiltins

    coreBuiltins :: [BuiltinInfo]
    coreBuiltins :: [BuiltinInfo]
    coreBuiltins =
      [ (BuiltinId
    builtinList                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData (TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset) [BuiltinId
    builtinNil, BuiltinId
    builtinCons])
      , (BuiltinId
    builtinArg                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData (TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset) [BuiltinId
    builtinArgArg])
      , (BuiltinId
    builtinAbs                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData (TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset) [BuiltinId
    builtinAbsAbs])
      , (BuiltinId
    builtinArgInfo                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinArgArgInfo])
      , (BuiltinId
    builtinBool                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinTrue, BuiltinId
    builtinFalse])
      , (BuiltinId
    builtinNat                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinZero, BuiltinId
    builtinSuc])
      , (BuiltinId
    builtinMaybe                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData (TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset) [BuiltinId
    builtinNothing, BuiltinId
    builtinJust])
      , (BuiltinId
    builtinSigma                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData (Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCM Type)
    -> NamesT (TCMT IO) Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                  [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "la" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    a ->
                                                                  [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "lb" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    b ->
                                                                  [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "A" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    a) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \NamesT (TCMT IO) Term
    bA ->
                                                                  [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "B" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Type
    -> NamesT (TCMT IO) Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    b)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \NamesT (TCMT IO) Term
    bB ->
                                                                  ((Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort) (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    b))
                                                                  )
                                                                 [BuiltinId
    BuiltinSigmaCon])
      , (BuiltinId
    builtinUnit                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinUnitUnit])  -- actually record, but they are treated the same
      , (BuiltinId
    builtinAgdaLiteral                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinAgdaLitNat, BuiltinId
    builtinAgdaLitWord64, BuiltinId
    builtinAgdaLitFloat,
                                                                       BuiltinId
    builtinAgdaLitChar, BuiltinId
    builtinAgdaLitString,
                                                                       BuiltinId
    builtinAgdaLitQName, BuiltinId
    builtinAgdaLitMeta])
      , (BuiltinId
    builtinAgdaPattern                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinAgdaPatVar, BuiltinId
    builtinAgdaPatCon, BuiltinId
    builtinAgdaPatDot,
                                                                       BuiltinId
    builtinAgdaPatLit, BuiltinId
    builtinAgdaPatProj, BuiltinId
    builtinAgdaPatAbsurd])
      , (BuiltinId
    builtinAgdaPatVar                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tpat))
      , (BuiltinId
    builtinAgdaPatCon                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tpat) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tpat))
      , (BuiltinId
    builtinAgdaPatDot                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tpat))
      , (BuiltinId
    builtinAgdaPatLit                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tliteral TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tpat))
      , (BuiltinId
    builtinAgdaPatProj                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tpat))
      , (BuiltinId
    builtinAgdaPatAbsurd                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tpat))
      , (BuiltinId
    builtinLevel                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tLevelUniv)
      , (BuiltinId
    builtinWord64                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset)
      , (BuiltinId
    builtinInteger                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinIntegerPos, BuiltinId
    builtinIntegerNegSuc])
      , (BuiltinId
    builtinIntegerPos                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tinteger))
      , (BuiltinId
    builtinIntegerNegSuc                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tinteger))
      , (BuiltinId
    builtinFloat                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset)
      , (BuiltinId
    builtinChar                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset)
      , (BuiltinId
    builtinString                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset)
      , (BuiltinId
    builtinQName                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset)
      , (BuiltinId
    builtinAgdaMeta                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset)
      , (BuiltinId
    builtinIO                               BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset))
      , (BuiltinId
    builtinPath                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor
    BuiltinUnknown
                                                                 (TCM Type -> Maybe (TCM Type)
    forall a. a -> Maybe a
    Just (TCM Type -> Maybe (TCM Type)) -> TCM Type -> Maybe (TCM Type)
    forall a b. (a -> b) -> a -> b
    $ Cubical -> TCM ()
    requireCubical Cubical
    CErased TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                                                                 [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" (TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) (
                                                                  [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> TCM Type) -> Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ Sort -> Type
    sort (Sort -> Type) -> Sort -> Type
    forall a b. (a -> b) -> a -> b
    $ Int -> Sort
    varSort Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                  (Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Int -> Sort
    varSort Int
    1) (Term -> Type) -> TCMT IO Term -> TCM Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    -->
                                                                  (Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Int -> Sort
    varSort Int
    1) (Term -> Type) -> TCMT IO Term -> TCM Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    -->
                                                                  Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort -> Type
    sort (Sort -> Type) -> Sort -> Type
    forall a b. (a -> b) -> a -> b
    $ Int -> Sort
    varSort Int
    1)))
                                                                 Term -> Type -> TCM ()
    verifyPath)
      , (BuiltinId
    builtinPathP                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" (TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                  [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    nPi [Char]
    "A" (TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort -> Type
    sort (Sort -> Type) -> Sort -> Type
    forall a b. (a -> b) -> a -> b
    $ Int -> Sort
    varSort Int
    0)) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                  (Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Int -> Sort
    varSort Int
    1) (Term -> Type) -> TCMT IO Term -> TCM Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0 TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    -->
                                                                  (Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Int -> Sort
    varSort Int
    1) (Term -> Type) -> TCMT IO Term -> TCM Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0 TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIOne) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    -->
                                                                  Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort -> Type
    sort (Sort -> Type) -> Sort -> Type
    forall a b. (a -> b) -> a -> b
    $ Int -> Sort
    varSort Int
    1)))
      , (BuiltinId
    builtinIntervalUniv                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortIntervalUniv)
      , (BuiltinId
    builtinInterval                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData (Cubical -> TCM ()
    requireCubical Cubical
    CErased TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                                                                  Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort -> Type
    sort Sort
    forall t. Sort' t
    IntervalUniv)) [BuiltinId
    builtinIZero,BuiltinId
    builtinIOne])
      , (BuiltinId
    builtinSub                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCM Type)
    -> NamesT (TCMT IO) Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "a" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    a ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "A" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelSuc NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a) (Sort -> Term
    Sort (Sort -> Term) -> (Term -> Sort) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Term) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    a)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    bA ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "φ" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    phi ->
                                                                       NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el's NamesT (TCMT IO) Term
    a (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPartial NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA) NamesT (TCMT IO) Type
    -> NamesT (TCMT IO) Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> (Level -> Type
    ssort (Level -> Type) -> (Term -> Level) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Level
    forall t. t -> Level' t
    atomicLevel (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    a)
                                                                      ))
      , (BuiltinId
    builtinSubIn                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCM Type)
    -> NamesT (TCMT IO) Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "a" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    a ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "A" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelSuc NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a) (Sort -> Term
    Sort (Sort -> Term) -> (Term -> Sort) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Term) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    a)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    bA ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "φ" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    phi ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "x" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    bA) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    x ->
                                                                       NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el's NamesT (TCMT IO) Term
    a (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSub NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "o" (\ NamesT (TCMT IO) Term
    _ -> NamesT (TCMT IO) Term
    x)))
      , (BuiltinId
    builtinIZero                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval)
      , (BuiltinId
    builtinIOne                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval)
      , (BuiltinId
    builtinPartial                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimPartial (TCM () -> Term -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Term -> TCM ()) -> TCM () -> Term -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinPartialP                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimPartialP (TCM () -> Term -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Term -> TCM ()) -> TCM () -> Term -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinIsOne                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Level -> Type
    ssort (Level -> Type) -> Level -> Type
    forall a b. (a -> b) -> a -> b
    $ Integer -> Level
    ClosedLevel Integer
    0)))
      , (BuiltinId
    builtinItIsOne                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    elSSet (TCMT IO Term -> TCM Type) -> TCMT IO Term -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIsOne TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIOne))
      , (BuiltinId
    builtinIsOne1                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCM Type)
    -> NamesT (TCMT IO) Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "i" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    i ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "j" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    j ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "i1" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    elSSet (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIsOne NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    i) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    i1 ->
                                                                       (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    elSSet (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIsOne NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    i NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    j))))
      , (BuiltinId
    builtinIsOne2                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCM Type)
    -> NamesT (TCMT IO) Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "i" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    i ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "j" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    j ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "j1" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    elSSet (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIsOne NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    j) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    j1 ->
                                                                       (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    elSSet (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIsOne NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    i NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    j))))
      , (BuiltinId
    builtinIsOneEmpty                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Cubical -> TCM Type -> BuiltinDescriptor
    builtinPostulateC Cubical
    CErased (Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCM Type)
    -> NamesT (TCMT IO) Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    l ->
                                                                       [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "A" ([Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    _ ->
                                                                                      NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelSuc NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    l) (Sort -> Term
    Sort (Sort -> Term) -> (Term -> Sort) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Term) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    l)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    bA ->
                                                                       [Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero) (\ NamesT (TCMT IO) Term
    o ->
                                                                            NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    l (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ ArgInfo
    -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Applicative m =>
    ArgInfo -> m Term -> m Term -> m Term
    gApply' ArgInfo
    defaultIrrelevantArgInfo NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Term
    o)))

      , (BuiltinId
    builtinEquiv                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor
    BuiltinUnknown (TCM Type -> Maybe (TCM Type)
    forall a. a -> Maybe a
    Just (TCM Type -> Maybe (TCM Type)) -> TCM Type -> Maybe (TCM Type)
    forall a b. (a -> b) -> a -> b
    $ Cubical -> TCM ()
    requireCubical Cubical
    CErased TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (
                                                                        [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    a ->
                                                                        [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l'" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    b ->
                                                                        [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "A" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    a) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \NamesT (TCMT IO) Term
    bA ->
                                                                        [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "B" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    b) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \NamesT (TCMT IO) Term
    bB ->
                                                                        ((Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort) (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    b))
                                                                      ))
                                                                       ((Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. a -> b -> a
    const ((Type -> TCM ()) -> Term -> Type -> TCM ())
    -> (Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ TCM () -> Type -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Type -> TCM ()) -> TCM () -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinEquivFun                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor
    BuiltinUnknown (TCM Type -> Maybe (TCM Type)
    forall a. a -> Maybe a
    Just (TCM Type -> Maybe (TCM Type)) -> TCM Type -> Maybe (TCM Type)
    forall a b. (a -> b) -> a -> b
    $ Cubical -> TCM ()
    requireCubical Cubical
    CErased TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (
                                                                     [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    a ->
                                                                     [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l'" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    b ->
                                                                     [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "A" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    a) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \NamesT (TCMT IO) Term
    bA ->
                                                                     [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "B" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    b) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \NamesT (TCMT IO) Term
    bB ->
                                                                     NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    b) (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primEquiv NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    b NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bB) NamesT (TCMT IO) Type
    -> NamesT (TCMT IO) Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    -->
                                                                     (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Type
    -> NamesT (TCMT IO) Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    b NamesT (TCMT IO) Term
    bB)
                                                                   ))
                                                                    ((Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. a -> b -> a
    const ((Type -> TCM ()) -> Term -> Type -> TCM ())
    -> (Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ TCM () -> Type -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Type -> TCM ()) -> TCM () -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinEquivProof                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor
    BuiltinUnknown (TCM Type -> Maybe (TCM Type)
    forall a. a -> Maybe a
    Just (TCM Type -> Maybe (TCM Type)) -> TCM Type -> Maybe (TCM Type)
    forall a b. (a -> b) -> a -> b
    $ Cubical -> TCM ()
    requireCubical Cubical
    CErased TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    la ->
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l'" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    lb ->
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "A" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    la) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    bA ->
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "B" (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    lb) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    bB ->
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "e" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    lb)
                                                                                 (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primEquiv NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bB)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    e -> do
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "b" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    bB) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    b -> do
                                                                    let f :: NamesT (TCMT IO) Term
    f = TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primEquivFun NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    bB NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    e
                                                                        lub :: NamesT (TCMT IO) Term
    lub = TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelMax NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    lb
                                                                        fiber :: NamesT (TCMT IO) Type
    fiber = NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    lub
                                                                                    (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSigma NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb
                                                                                      NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA
                                                                                      NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "a" (\ NamesT (TCMT IO) Term
    a ->
                                                                                             TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPath NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    bB NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    b))
                                                                    [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "φ" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    phi ->
                                                                      [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "f" ([Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" NamesT (TCMT IO) Term
    phi (\ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Type
    fiber)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    pfib ->
                                                                        NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    lub (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSub NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lub NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> (Type -> Term) -> NamesT (TCMT IO) Type -> NamesT (TCMT IO) Term
    forall a b. (a -> b) -> NamesT (TCMT IO) a -> NamesT (TCMT IO) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type -> Term
    forall t a. Type'' t a -> a
    unEl NamesT (TCMT IO) Type
    fiber NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    pfib)
                                                                 ))
                                                                  ((Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. a -> b -> a
    const ((Type -> TCM ()) -> Term -> Type -> TCM ())
    -> (Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ TCM () -> Type -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Type -> TCM ()) -> TCM () -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinTranspProof                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor
    BuiltinUnknown (TCM Type -> Maybe (TCM Type)
    forall a. a -> Maybe a
    Just (TCM Type -> Maybe (TCM Type)) -> TCM Type -> Maybe (TCM Type)
    forall a b. (a -> b) -> a -> b
    $ Cubical -> TCM ()
    requireCubical Cubical
    CErased TCM () -> TCM Type -> TCM Type
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Names -> NamesT (TCMT IO) Type -> TCM Type
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    hPi' [Char]
    "l" (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    la -> do
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "e" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval NamesT (TCMT IO) Type
    -> NamesT (TCMT IO) Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> (Sort -> Type
    sort (Sort -> Type) -> (Term -> Sort) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    la)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    e -> do
                                                                   let lb :: NamesT (TCMT IO) Term
    lb = NamesT (TCMT IO) Term
    la; bA :: NamesT (TCMT IO) Term
    bA = NamesT (TCMT IO) Term
    e NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero; bB :: NamesT (TCMT IO) Term
    bB = NamesT (TCMT IO) Term
    e NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIOne
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "φ" (TCM Type -> NamesT (TCMT IO) Type
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Type
    forall {t}. TCMT IO (Type'' t Term)
    tinterval) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    phi -> do
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "a" ([Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" NamesT (TCMT IO) Term
    phi (\ NamesT (TCMT IO) Term
    _ -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    bA)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    a -> do
                                                                   let f :: NamesT (TCMT IO) Term
    f = TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primTrans NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "i" (\ NamesT (TCMT IO) Term
    _ -> NamesT (TCMT IO) Term
    la) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    e NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero
                                                                       z :: NamesT (TCMT IO) Term
    z = [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    ilam [Char]
    "o" ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
     -> NamesT (TCMT IO) Term)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    o)
                                                                   [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "b" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el's NamesT (TCMT IO) Term
    lb (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSub NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bB NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    z)) ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    b' -> do
                                                                   let b :: NamesT (TCMT IO) Term
    b = TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSubOut NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    bB NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    z NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    b'
                                                                       fiber :: NamesT (TCMT IO) Type
    fiber = NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    la
                                                                                   (TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSigma NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb
                                                                                      NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA
                                                                                      NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "a" (\ NamesT (TCMT IO) Term
    a ->
                                                                                             TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPath NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    bB NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    a) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    b))
                                                                   NamesT (TCMT IO) Type
    fiber
                                                                 ))
                                                                  ((Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. a -> b -> a
    const ((Type -> TCM ()) -> Term -> Type -> TCM ())
    -> (Type -> TCM ()) -> Term -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ TCM () -> Type -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Type -> TCM ()) -> TCM () -> Type -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinAgdaSort                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset
                                                       [ BuiltinId
    builtinAgdaSortSet, BuiltinId
    builtinAgdaSortLit
                                                       , BuiltinId
    builtinAgdaSortProp, BuiltinId
    builtinAgdaSortPropLit
                                                       , BuiltinId
    builtinAgdaSortInf, BuiltinId
    builtinAgdaSortUnsupported])
      , (BuiltinId
    builtinAgdaTerm                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset
                                                       [ BuiltinId
    builtinAgdaTermVar, BuiltinId
    builtinAgdaTermLam, BuiltinId
    builtinAgdaTermExtLam
                                                       , BuiltinId
    builtinAgdaTermDef, BuiltinId
    builtinAgdaTermCon
                                                       , BuiltinId
    builtinAgdaTermPi, BuiltinId
    builtinAgdaTermSort
                                                       , BuiltinId
    builtinAgdaTermLit, BuiltinId
    builtinAgdaTermMeta
                                                       , BuiltinId
    builtinAgdaTermUnsupported])
      , BuiltinId
    builtinAgdaErrorPart                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [ BuiltinId
    builtinAgdaErrorPartString, BuiltinId
    builtinAgdaErrorPartTerm, BuiltinId
    builtinAgdaErrorPartPatt, BuiltinId
    builtinAgdaErrorPartName ]
      , BuiltinId
    builtinAgdaErrorPartString               BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    terrorpart)
      , BuiltinId
    builtinAgdaErrorPartTerm                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    terrorpart)
      , BuiltinId
    builtinAgdaErrorPartPatt                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tpat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    terrorpart)
      , BuiltinId
    builtinAgdaErrorPartName                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    terrorpart)
      , BuiltinId
    builtinAgdaBlocker                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [ BuiltinId
    builtinAgdaBlockerAll, BuiltinId
    builtinAgdaBlockerAny, BuiltinId
    builtinAgdaBlockerMeta ]
      , BuiltinId
    builtinAgdaBlockerAny                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tblocker TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tblocker)
      , BuiltinId
    builtinAgdaBlockerAll                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tblocker TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tblocker)
      , BuiltinId
    builtinAgdaBlockerMeta                   BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tmeta TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tblocker)
      -- Andreas, 2017-01-12, issue #2386: special handling of builtinEquality
      -- , (builtinEquality                         |-> BuiltinData (hPi "a" (el primLevel) $
      --                                                             hPi "A" (return $ sort $ varSort 0) $
      --                                                             (El (varSort 1) <$> varM 0) -->
      --                                                             (El (varSort 1) <$> varM 0) -->
      --                                                             return (sort $ varSort 1))
      --                                                            [builtinRefl])
      , (BuiltinId
    builtinHiding                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinHidden, BuiltinId
    builtinInstance, BuiltinId
    builtinVisible])
        -- Relevance
      , (BuiltinId
    builtinRelevance                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinRelevant, BuiltinId
    builtinIrrelevant])
      , (BuiltinId
    builtinRelevant                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    trelevance)
      , (BuiltinId
    builtinIrrelevant                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    trelevance)
        -- Quantity
      , (BuiltinId
    builtinQuantity                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinQuantity0, BuiltinId
    builtinQuantityω])
      , (BuiltinId
    builtinQuantity0                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tquantity)
      , (BuiltinId
    builtinQuantityω                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tquantity)
        -- Modality
      , (BuiltinId
    builtinModality                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinModalityConstructor])
      , (BuiltinId
    builtinModalityConstructor              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    trelevance TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tquantity TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tmodality))
        -- Associativity
      , BuiltinId
    builtinAssoc                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinAssocLeft, BuiltinId
    builtinAssocRight, BuiltinId
    builtinAssocNon]
      , BuiltinId
    builtinAssocLeft                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tassoc
      , BuiltinId
    builtinAssocRight                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tassoc
      , BuiltinId
    builtinAssocNon                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tassoc
        -- Precedence
      , BuiltinId
    builtinPrecedence                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinPrecRelated, BuiltinId
    builtinPrecUnrelated]
      , BuiltinId
    builtinPrecRelated                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tfloat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tprec)
      , BuiltinId
    builtinPrecUnrelated                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tprec
        -- Fixity
      , BuiltinId
    builtinFixity                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinFixityFixity]
      , BuiltinId
    builtinFixityFixity                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tassoc TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tprec TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tfixity)
      -- Andreas, 2017-01-12, issue #2386: special handling of builtinEquality
      -- , (builtinRefl                             |-> BuiltinDataCons (hPi "a" (el primLevel) $
      --                                                                 hPi "A" (return $ sort $ varSort 0) $
      --                                                                 hPi "x" (El (varSort 1) <$> varM 0) $
      --                                                                 El (varSort 2) <$> primEquality <#> varM 2 <#> varM 1 <@> varM 0 <@> varM 0))
      , (BuiltinId
    builtinRewrite                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> Maybe (TCM Type) -> (Term -> Type -> TCM ()) -> BuiltinDescriptor
    BuiltinUnknown Maybe (TCM Type)
    forall a. Maybe a
    Nothing Term -> Type -> TCM ()
    verifyBuiltinRewrite)
      , (BuiltinId
    builtinNil                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset (TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    list TCMT IO Term
    v0))))
      , (BuiltinId
    builtinCons                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset (TCM Type
    tv0 TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    list TCMT IO Term
    v0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    list TCMT IO Term
    v0))))
      , (BuiltinId
    builtinNothing                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset (TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    tMaybe TCMT IO Term
    v0))))
      , (BuiltinId
    builtinJust                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset (TCM Type
    tv0 TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    tMaybe TCMT IO Term
    v0))))
      , (BuiltinId
    builtinZero                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tnat)
      , (BuiltinId
    builtinSuc                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tnat))
      , (BuiltinId
    builtinTrue                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tbool)
      , (BuiltinId
    builtinFalse                            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tbool)
      , (BuiltinId
    builtinArgArg                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset (TCM Type
    targinfo TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tv0 TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tv0)))
      , (BuiltinId
    builtinAbsAbs                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset (TCM Type
    tstring  TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tv0 TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {m :: * -> *} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m (Type'' t Term) -> m Type
    tabs TCM Type
    tv0)))
      , (BuiltinId
    builtinArgArgInfo                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    thiding TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tmodality TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    targinfo))
      , (BuiltinId
    builtinAgdaTermVar                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    targs TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermLam                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    thiding TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {m :: * -> *} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m (Type'' t Term) -> m Type
    tabs TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermExtLam                   BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tclause TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    targs TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermDef                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    targs TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermCon                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    targs TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermPi                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {m :: * -> *} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m (Type'' t Term) -> m Type
    tabs TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermSort                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tsort TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermLit                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tliteral TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermMeta                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tmeta TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    targs TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm))
      , (BuiltinId
    builtinAgdaTermUnsupported              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tterm)
      , (BuiltinId
    builtinAgdaLitNat                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinAgdaLitWord64                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tword64 TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinAgdaLitFloat                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tfloat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinAgdaLitChar                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tchar TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinAgdaLitString                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinAgdaLitQName                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinAgdaLitMeta                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tmeta TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tliteral))
      , (BuiltinId
    builtinHidden                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    thiding)
      , (BuiltinId
    builtinInstance                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    thiding)
      , (BuiltinId
    builtinVisible                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    thiding)
      , (BuiltinId
    builtinSizeUniv                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    tsetOmega) -- SizeUniv : Setω
      , (BuiltinId
    builtinSize                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tSizeUniv)
      , (BuiltinId
    builtinSizeLt                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tsize TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    ..--> TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tSizeUniv))
      , (BuiltinId
    builtinSizeSuc                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tsize TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsize))
      , (BuiltinId
    builtinSizeInf                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate TCM Type
    tsize)
      -- postulate max : {i : Size} -> Size< i -> Size< i -> Size< i
      , (BuiltinId
    builtinSizeMax                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tsize TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsize TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsize))
         -- (hPi "i" tsize $ let a = el $ primSizeLt <@> v0 in (a --> a --> a)))
      , (BuiltinId
    builtinAgdaSortSet                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsort))
      , (BuiltinId
    builtinAgdaSortLit                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsort))
      , (BuiltinId
    builtinAgdaSortProp                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsort))
      , (BuiltinId
    builtinAgdaSortPropLit                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsort))
      , (BuiltinId
    builtinAgdaSortInf                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tsort))
      , (BuiltinId
    builtinAgdaSortUnsupported              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tsort)
      , (BuiltinId
    builtinNatPlus                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatPlus Term -> TCM ()
    verifyPlus)
      , (BuiltinId
    builtinNatMinus                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatMinus Term -> TCM ()
    verifyMinus)
      , (BuiltinId
    builtinNatTimes                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatTimes Term -> TCM ()
    verifyTimes)
      , (BuiltinId
    builtinNatDivSucAux                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatDivSucAux Term -> TCM ()
    verifyDivSucAux)
      , (BuiltinId
    builtinNatModSucAux                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatModSucAux Term -> TCM ()
    verifyModSucAux)
      , (BuiltinId
    builtinNatEquals                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatEquality Term -> TCM ()
    verifyEquals)
      , (BuiltinId
    builtinNatLess                          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimNatLess Term -> TCM ()
    verifyLess)
      , (BuiltinId
    builtinLevelUniv                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortLevelUniv)
      , (BuiltinId
    builtinLevelZero                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimLevelZero (TCM () -> Term -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Term -> TCM ()) -> TCM () -> Term -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinLevelSuc                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimLevelSuc (TCM () -> Term -> TCM ()
    forall a b. a -> b -> a
    const (TCM () -> Term -> TCM ()) -> TCM () -> Term -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()))
      , (BuiltinId
    builtinLevelMax                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> PrimitiveId -> (Term -> TCM ()) -> BuiltinDescriptor
    BuiltinPrim PrimitiveId
    PrimLevelMax Term -> TCM ()
    forall {m :: * -> *} {p}. Monad m => p -> m ()
    verifyMax)
      , (BuiltinId
    builtinProp                             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortProp)
      , (BuiltinId
    builtinSet                              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortSet)
      , (BuiltinId
    builtinStrictSet                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortStrictSet)
      , (BuiltinId
    builtinPropOmega                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortPropOmega)
      , (BuiltinId
    builtinSetOmega                         BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortSetOmega)
      , (BuiltinId
    builtinSSetOmega                        BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> BuiltinSort -> BuiltinDescriptor
    BuiltinSort BuiltinSort
    SortStrictSetOmega)
      , (BuiltinId
    builtinAgdaClause                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinAgdaClauseClause, BuiltinId
    builtinAgdaClauseAbsurd])
      , (BuiltinId
    builtinAgdaClauseClause                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    ttelescope TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tpat) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tclause))
      , (BuiltinId
    builtinAgdaClauseAbsurd                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    ttelescope TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tpat) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tclause))
      , (BuiltinId
    builtinAgdaDefinition                   BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> [BuiltinId] -> BuiltinDescriptor
    BuiltinData TCM Type
    forall (m :: * -> *). Applicative m => m Type
    tset [BuiltinId
    builtinAgdaDefinitionFunDef
                                                                      ,BuiltinId
    builtinAgdaDefinitionDataDef
                                                                      ,BuiltinId
    builtinAgdaDefinitionDataConstructor
                                                                      ,BuiltinId
    builtinAgdaDefinitionRecordDef
                                                                      ,BuiltinId
    builtinAgdaDefinitionPostulate
                                                                      ,BuiltinId
    builtinAgdaDefinitionPrimitive])
      , (BuiltinId
    builtinAgdaDefinitionFunDef             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tclause TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tdefn))
      , (BuiltinId
    builtinAgdaDefinitionDataDef            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tdefn))
      , (BuiltinId
    builtinAgdaDefinitionDataConstructor    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tquantity TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tdefn))
      , (BuiltinId
    builtinAgdaDefinitionRecordDef          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tqname) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tdefn))
      , (BuiltinId
    builtinAgdaDefinitionPostulate          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tdefn)
      , (BuiltinId
    builtinAgdaDefinitionPrimitive          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    BuiltinDataCons TCM Type
    tdefn)
      , BuiltinId
    builtinAgdaTCM                           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0 TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0)
      , BuiltinId
    builtinAgdaTCMReturn                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel  (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *} {a}.
    Functor f =>
    Int -> f a -> f (Type'' Term a)
    elV Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMBind                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel  (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "b" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    1) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "B" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    1) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    3 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    1) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> (Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *} {a}.
    Functor f =>
    Int -> f a -> f (Type'' Term a)
    elV Int
    3 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    1) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    2 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0)) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    2 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMUnify                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMTypeError                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    terrorpart TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMInferType                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMCheckType                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMNormalise                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMReduce                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMCatchError                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMGetContext                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (Type -> Term
    forall t a. Type'' t a -> a
    unEl (Type -> Term) -> TCM Type -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCM Type
    ttelescope))
      , BuiltinId
    builtinAgdaTCMExtendContext              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMInContext                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       TCM Type
    ttelescope TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMFreshName                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primQName)
      , BuiltinId
    builtinAgdaTCMDeclareDef                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMDeclarePostulate           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMDeclareData                BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMDefineData                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist (TCMT IO Term -> TCMT IO Term -> TCM Type -> TCM Type -> TCM Type
    forall {m :: * -> *} {t} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    -> m Term -> m (Type'' t Term) -> m (Type'' t Term) -> m Type
    tpair TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCM Type
    tqname (TCMT IO Term -> TCMT IO Term -> TCM Type -> TCM Type -> TCM Type
    forall {m :: * -> *} {t} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    -> m Term -> m (Type'' t Term) -> m (Type'' t Term) -> m Type
    tpair TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCM Type
    tquantity TCM Type
    ttype)) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMDefineFun                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tclause TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMGetType                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMGetDefinition              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaDefinition)
      , BuiltinId
    builtinAgdaTCMQuoteTerm                  BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *} {a}.
    Functor f =>
    Int -> f a -> f (Type'' Term a)
    elV Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMUnquoteTerm                BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCM Type
    tterm TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMQuoteOmegaTerm             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" TCM Type
    tsetOmega (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    elInf (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMBlock                      BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCM Type
    tblocker TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMCommit                     BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMIsMacro                    BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primBool)
      , BuiltinId
    builtinAgdaTCMWithNormalisation          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCM Type
    tbool TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMWithReconstructed          BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCM Type
    tbool TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMWithExpandLast             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCM Type
    tbool TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMWithReduceDefs             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ (TCMT IO Term -> TCMT IO Term -> TCM Type -> TCM Type -> TCM Type
    forall {m :: * -> *} {t} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    -> m Term -> m (Type'' t Term) -> m (Type'' t Term) -> m Type
    tpair TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCM Type
    tbool (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tqname)) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMAskNormalisation           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (Type -> Term
    forall t a. Type'' t a -> a
    unEl (Type -> Term) -> TCM Type -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCM Type
    tbool))
      , BuiltinId
    builtinAgdaTCMAskReconstructed           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (Type -> Term
    forall t a. Type'' t a -> a
    unEl (Type -> Term) -> TCM Type -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCM Type
    tbool))
      , BuiltinId
    builtinAgdaTCMAskExpandLast              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (Type -> Term
    forall t a. Type'' t a -> a
    unEl (Type -> Term) -> TCM Type -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCM Type
    tbool))
      , BuiltinId
    builtinAgdaTCMAskReduceDefs              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (Type -> Term
    forall t a. Type'' t a -> a
    unEl (Type -> Term) -> TCM Type -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TCMT IO Term -> TCMT IO Term -> TCM Type -> TCM Type -> TCM Type
    forall {m :: * -> *} {t} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    -> m Term -> m (Type'' t Term) -> m (Type'' t Term) -> m Type
    tpair TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCM Type
    tbool (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tqname))))
      , BuiltinId
    builtinAgdaTCMFormatErrorParts           BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    terrorpart TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primString)
      , BuiltinId
    builtinAgdaTCMDebugPrint                 BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tnat TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    terrorpart TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)

      , BuiltinId
    builtinAgdaTCMNoConstraints              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMWorkOnTypes                BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMRunSpeculative             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate ([Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "a" TCM Type
    tlevel (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *).
    (MonadAddContext m, MonadDebug m) =>
    [Char] -> m Type -> m Type -> m Type
    hPi [Char]
    "A" (Int -> TCM Type
    forall {m :: * -> *}. Monad m => Int -> m Type
    tsetL Int
    0) (TCM Type -> TCM Type) -> TCM Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $
                                                                       Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSigma TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    1 TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0 TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> (Term -> Abs Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    Abs [Char]
    "_" (Term -> Term) -> TCMT IO Term -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primBool)) TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> Int -> TCMT IO Term -> TCM Type
    forall {f :: * -> *}.
    (HasBuiltins f, MonadError TCErr f, MonadTCEnv f, ReadTCState f) =>
    Int -> f Term -> f Type
    tTCM Int
    1 (Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0))
      , BuiltinId
    builtinAgdaTCMExec                       BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    -->
                                                                       TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSigma TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primNat TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@>
                                                                              (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> (Term -> Abs Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    Abs [Char]
    "_" (Term -> Term) -> TCMT IO Term -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSigma TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primString TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@>
                                                                               (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> (Term -> Abs Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    Abs [Char]
    "_" (Term -> Term) -> TCMT IO Term -> TCMT IO Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primString)))))
      , BuiltinId
    builtinAgdaTCMCheckFromString            BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    ttype TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm)
      , BuiltinId
    builtinAgdaTCMGetInstances               BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tmeta TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ (TCMT IO Term -> TCMT IO Term
    list TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm))
      , BuiltinId
    builtinAgdaTCMSolveInstances             BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMPragmaForeign              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      , BuiltinId
    builtinAgdaTCMPragmaCompile              BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    |-> TCM Type -> BuiltinDescriptor
    builtinPostulate (TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tqname TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCM Type
    tstring TCM Type -> TCM Type -> TCM Type
    forall (m :: * -> *). Applicative m => m Type -> m Type -> m Type
    --> TCMT IO Term -> TCM Type
    forall {m :: * -> *}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term -> m Type
    tTCM_ TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primUnit)
      ]
      where
            |-> :: BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    (|->) = BuiltinId -> BuiltinDescriptor -> BuiltinInfo
    BuiltinInfo

            v0 :: TCM Term
            v0 :: TCMT IO Term
    v0 = Int -> TCMT IO Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    0

            tv0 :: TCM Type
            tv0 :: TCM Type
    tv0 = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    v0

            arg :: TCM Term -> TCM Term
            arg :: TCMT IO Term -> TCMT IO Term
    arg TCMT IO Term
    t = TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primArg TCMT IO Term -> TCMT IO Term -> TCMT IO Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCMT IO Term
    t

            elV :: Int -> f a -> f (Type'' Term a)
    elV Int
    x f a
    a = Sort -> a -> Type'' Term a
    forall t a. Sort' t -> a -> Type'' t a
    El (Int -> Sort
    varSort Int
    x) (a -> Type'' Term a) -> f a -> f (Type'' Term a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f a
    a

            tsetL :: Int -> m Type
    tsetL Int
    l    = Type -> m Type
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> m Type) -> Type -> m Type
    forall a b. (a -> b) -> a -> b
    $ Sort -> Type
    sort (Int -> Sort
    varSort Int
    l)
            tsetOmega :: TCM Type
    tsetOmega  = Type -> TCM Type
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> TCM Type) -> Type -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ Sort -> Type
    sort (Sort -> Type) -> Sort -> Type
    forall a b. (a -> b) -> a -> b
    $ Univ -> Integer -> Sort
    forall t. Univ -> Integer -> Sort' t
    Inf Univ
    UType Integer
    0
            tlevel :: TCM Type
    tlevel     = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevel
            tlist :: TCMT IO (Type'' t Term) -> TCM Type
    tlist TCMT IO (Type'' t Term)
    x    = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCM Type) -> TCMT IO Term -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> TCMT IO Term
    list ((Type'' t Term -> Term) -> TCMT IO (Type'' t Term) -> TCMT IO Term
    forall a b. (a -> b) -> TCMT IO a -> TCMT IO b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type'' t Term -> Term
    forall t a. Type'' t a -> a
    unEl TCMT IO (Type'' t Term)
    x)
            tmaybe :: TCMT IO (Type'' t Term) -> TCM Type
    tmaybe TCMT IO (Type'' t Term)
    x   = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCM Type) -> TCMT IO Term -> TCM Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Term -> TCMT IO Term
    tMaybe ((Type'' t Term -> Term) -> TCMT IO (Type'' t Term) -> TCMT IO Term
    forall a b. (a -> b) -> TCMT IO a -> TCMT IO b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type'' t Term -> Term
    forall t a. Type'' t a -> a
    unEl TCMT IO (Type'' t Term)
    x)
            tpair :: m Term
    -> m Term -> m (Type'' t Term) -> m (Type'' t Term) -> m Type
    tpair m Term
    lx m Term
    ly m (Type'' t Term)
    x m (Type'' t Term)
    y = m Term -> m Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (m Term -> m Type) -> m Term -> m Type
    forall a b. (a -> b) -> a -> b
    $ m Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSigma
                                m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> m Term
    lx
                                m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> m Term
    ly
                                m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (Type'' t Term -> Term) -> m (Type'' t Term) -> m Term
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type'' t Term -> Term
    forall t a. Type'' t a -> a
    unEl m (Type'' t Term)
    x
                                m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> (Term -> Abs Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs [Char]
    "_" (Term -> Term) -> m Term -> m Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Type'' t Term -> Term) -> m (Type'' t Term) -> m Term
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type'' t Term -> Term
    forall t a. Type'' t a -> a
    unEl m (Type'' t Term)
    y)
            targ :: TCMT IO (Type'' t Term) -> TCM Type
    targ TCMT IO (Type'' t Term)
    x     = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    arg ((Type'' t Term -> Term) -> TCMT IO (Type'' t Term) -> TCMT IO Term
    forall a b. (a -> b) -> TCMT IO a -> TCMT IO b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type'' t Term -> Term
    forall t a. Type'' t a -> a
    unEl TCMT IO (Type'' t Term)
    x))
            tabs :: m (Type'' t Term) -> m Type
    tabs m (Type'' t Term)
    x     = m Term -> m Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (m Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAbs m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (Type'' t Term -> Term) -> m (Type'' t Term) -> m Term
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Type'' t Term -> Term
    forall t a. Type'' t a -> a
    unEl m (Type'' t Term)
    x)
            targs :: TCM Type
    targs      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (TCMT IO Term -> TCMT IO Term
    list (TCMT IO Term -> TCMT IO Term
    arg TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm))
            tterm :: TCM Type
    tterm      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm
            terrorpart :: TCM Type
    terrorpart = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaErrorPart
            tnat :: TCM Type
    tnat       = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primNat
            tword64 :: TCM Type
    tword64    = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primWord64
            tinteger :: TCM Type
    tinteger   = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primInteger
            tfloat :: TCM Type
    tfloat     = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primFloat
            tchar :: TCM Type
    tchar      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primChar
            tstring :: TCM Type
    tstring    = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primString
            tqname :: TCM Type
    tqname     = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primQName
            tmeta :: TCM Type
    tmeta      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaMeta
            tblocker :: TCM Type
    tblocker   = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaBlocker
            tsize :: TCM Type
    tsize      = Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El Sort
    sSizeUniv (Term -> Type) -> TCMT IO Term -> TCM Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSize
            tbool :: TCM Type
    tbool      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primBool
            thiding :: TCM Type
    thiding    = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primHiding
            trelevance :: TCM Type
    trelevance = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primRelevance
            tquantity :: TCM Type
    tquantity  = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primQuantity
            tmodality :: TCM Type
    tmodality  = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primModality
            tassoc :: TCM Type
    tassoc     = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAssoc
            tprec :: TCM Type
    tprec      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPrecedence
            tfixity :: TCM Type
    tfixity    = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primFixity
    --        tcolors    = el (list primAgdaTerm) -- TODO guilhem
            targinfo :: TCM Type
    targinfo   = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primArgInfo
            ttype :: TCM Type
    ttype      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm
            tsort :: TCM Type
    tsort      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaSort
            tdefn :: TCM Type
    tdefn      = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaDefinition
            tliteral :: TCM Type
    tliteral   = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaLiteral
            tpat :: TCM Type
    tpat       = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaPattern
            tclause :: TCM Type
    tclause    = TCMT IO Term -> TCM Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaClause
            ttelescope :: TCM Type
    ttelescope = TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    tlist (TCMT IO Term -> TCMT IO Term -> TCM Type -> TCM Type -> TCM Type
    forall {m :: * -> *} {t} {t}.
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    -> m Term -> m (Type'' t Term) -> m (Type'' t Term) -> m Type
    tpair TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero TCM Type
    tstring (TCM Type -> TCM Type
    forall {t}. TCMT IO (Type'' t Term) -> TCM Type
    targ TCM Type
    ttype))
            tTCM :: Int -> f Term -> f Type
    tTCM Int
    l f Term
    a   = Int -> f Term -> f Type
    forall {f :: * -> *} {a}.
    Functor f =>
    Int -> f a -> f (Type'' Term a)
    elV Int
    l (f Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTCM f Term -> f Term -> f Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> Int -> f Term
    forall (m :: * -> *). Applicative m => Int -> m Term
    varM Int
    l f Term -> f Term -> f Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> f Term
    a)
            tTCM_ :: m Term -> m Type
    tTCM_ m Term
    a    = m Term -> m Type
    forall (m :: * -> *). Functor m => m Term -> m Type
    el (m Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTCM m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> m Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelZero m Term -> m Term -> m Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> m Term
    a)
            tinterval :: TCMT IO (Type'' t Term)
    tinterval  = Sort' t -> Term -> Type'' t Term
    forall t a. Sort' t -> a -> Type'' t a
    El Sort' t
    forall t. Sort' t
    IntervalUniv (Term -> Type'' t Term) -> TCMT IO Term -> TCMT IO (Type'' t Term)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primInterval

            verifyPlus :: Term -> TCM ()
    verifyPlus Term
    plus =
                Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall {a}.
    Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify [[Char]
    "n",[Char]
    "m"] (((Term -> Term -> Term)
      -> Term
      -> (Term -> Term)
      -> (Term -> Term -> TCM ())
      -> (Term -> Term -> TCM ())
      -> ([TCM ()] -> TCM ())
      -> TCM ())
     -> TCM ())
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                    let m :: Term
    m = Int -> Term
    var Int
    0
                        n :: Term
    n = Int -> Term
    var Int
    1
                        Term
    x + :: Term -> Term -> Term
    + Term
    y = Term
    plus Term -> Term -> Term
    @@ Term
    x Term -> Term -> Term
    @@ Term
    y

                    -- We allow recursion on any argument
                    [TCM ()] -> TCM ()
    choice
                        [ do Term
    n Term -> Term -> Term
    + Term
    zero  Term -> Term -> TCM ()
    == Term
    n
                             Term
    n Term -> Term -> Term
    + Term -> Term
    suc Term
    m Term -> Term -> TCM ()
    == Term -> Term
    suc (Term
    n Term -> Term -> Term
    + Term
    m)
                        , do Term -> Term
    suc Term
    n Term -> Term -> Term
    + Term
    m Term -> Term -> TCM ()
    == Term -> Term
    suc (Term
    n Term -> Term -> Term
    + Term
    m)
                             Term
    zero  Term -> Term -> Term
    + Term
    m Term -> Term -> TCM ()
    == Term
    m
                        ]

            verifyMinus :: Term -> TCM ()
    verifyMinus Term
    minus =
                Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall {a}.
    Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify [[Char]
    "n",[Char]
    "m"] (((Term -> Term -> Term)
      -> Term
      -> (Term -> Term)
      -> (Term -> Term -> TCM ())
      -> (Term -> Term -> TCM ())
      -> ([TCM ()] -> TCM ())
      -> TCM ())
     -> TCM ())
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                    let m :: Term
    m = Int -> Term
    var Int
    0
                        n :: Term
    n = Int -> Term
    var Int
    1
                        Term
    x - :: Term -> Term -> Term
    - Term
    y = Term
    minus Term -> Term -> Term
    @@ Term
    x Term -> Term -> Term
    @@ Term
    y

                    -- We allow recursion on any argument
                    Term
    zero  Term -> Term -> Term
    - Term
    zero  Term -> Term -> TCM ()
    == Term
    zero
                    Term
    zero  Term -> Term -> Term
    - Term -> Term
    suc Term
    m Term -> Term -> TCM ()
    == Term
    zero
                    Term -> Term
    suc Term
    n Term -> Term -> Term
    - Term
    zero  Term -> Term -> TCM ()
    == Term -> Term
    suc Term
    n
                    Term -> Term
    suc Term
    n Term -> Term -> Term
    - Term -> Term
    suc Term
    m Term -> Term -> TCM ()
    == (Term
    n Term -> Term -> Term
    - Term
    m)

            verifyTimes :: Term -> TCM ()
    verifyTimes Term
    times = do
                plus <- TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primNatPlus
                verify ["n","m"] $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                    let m :: Term
    m = Int -> Term
    var Int
    0
                        n :: Term
    n = Int -> Term
    var Int
    1
                        Term
    x + :: Term -> Term -> Term
    + Term
    y = Term
    plus  Term -> Term -> Term
    @@ Term
    x Term -> Term -> Term
    @@ Term
    y
                        Term
    x * :: Term -> Term -> Term
    * Term
    y = Term
    times Term -> Term -> Term
    @@ Term
    x Term -> Term -> Term
    @@ Term
    y

                    [TCM ()] -> TCM ()
    choice
                        [ do Term
    n Term -> Term -> Term
    * Term
    zero Term -> Term -> TCM ()
    == Term
    zero
                             [TCM ()] -> TCM ()
    choice [ (Term
    n Term -> Term -> Term
    * Term -> Term
    suc Term
    m) Term -> Term -> TCM ()
    == (Term
    n Term -> Term -> Term
    + (Term
    n Term -> Term -> Term
    * Term
    m))
                                    , (Term
    n Term -> Term -> Term
    * Term -> Term
    suc Term
    m) Term -> Term -> TCM ()
    == ((Term
    n Term -> Term -> Term
    * Term
    m) Term -> Term -> Term
    + Term
    n)
                                    ]
                        , do Term
    zero Term -> Term -> Term
    * Term
    n Term -> Term -> TCM ()
    == Term
    zero
                             [TCM ()] -> TCM ()
    choice [ (Term -> Term
    suc Term
    n Term -> Term -> Term
    * Term
    m) Term -> Term -> TCM ()
    == (Term
    m Term -> Term -> Term
    + (Term
    n Term -> Term -> Term
    * Term
    m))
                                    , (Term -> Term
    suc Term
    n Term -> Term -> Term
    * Term
    m) Term -> Term -> TCM ()
    == ((Term
    n Term -> Term -> Term
    * Term
    m) Term -> Term -> Term
    + Term
    m)
                                    ]
                        ]

            verifyDivSucAux :: Term -> TCM ()
    verifyDivSucAux Term
    dsAux =
                Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall {a}.
    Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify [[Char]
    "k",[Char]
    "m",[Char]
    "n",[Char]
    "j"] (((Term -> Term -> Term)
      -> Term
      -> (Term -> Term)
      -> (Term -> Term -> TCM ())
      -> (Term -> Term -> TCM ())
      -> ([TCM ()] -> TCM ())
      -> TCM ())
     -> TCM ())
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                    let aux :: Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m Term
    n Term
    j = Term
    dsAux Term -> Term -> Term
    @@ Term
    k Term -> Term -> Term
    @@ Term
    m Term -> Term -> Term
    @@ Term
    n Term -> Term -> Term
    @@ Term
    j
                        k :: Term
    k           = Int -> Term
    var Int
    0
                        m :: Term
    m           = Int -> Term
    var Int
    1
                        n :: Term
    n           = Int -> Term
    var Int
    2
                        j :: Term
    j           = Int -> Term
    var Int
    3

                    Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m Term
    zero    Term
    j       Term -> Term -> TCM ()
    == Term
    k
                    Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m (Term -> Term
    suc Term
    n) Term
    zero    Term -> Term -> TCM ()
    == Term -> Term -> Term -> Term -> Term
    aux (Term -> Term
    suc Term
    k) Term
    m Term
    n Term
    m
                    Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m (Term -> Term
    suc Term
    n) (Term -> Term
    suc Term
    j) Term -> Term -> TCM ()
    == Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m Term
    n Term
    j

            verifyModSucAux :: Term -> TCM ()
    verifyModSucAux Term
    dsAux =
                Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall {a}.
    Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify [[Char]
    "k",[Char]
    "m",[Char]
    "n",[Char]
    "j"] (((Term -> Term -> Term)
      -> Term
      -> (Term -> Term)
      -> (Term -> Term -> TCM ())
      -> (Term -> Term -> TCM ())
      -> ([TCM ()] -> TCM ())
      -> TCM ())
     -> TCM ())
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                    let aux :: Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m Term
    n Term
    j = Term
    dsAux Term -> Term -> Term
    @@ Term
    k Term -> Term -> Term
    @@ Term
    m Term -> Term -> Term
    @@ Term
    n Term -> Term -> Term
    @@ Term
    j
                        k :: Term
    k           = Int -> Term
    var Int
    0
                        m :: Term
    m           = Int -> Term
    var Int
    1
                        n :: Term
    n           = Int -> Term
    var Int
    2
                        j :: Term
    j           = Int -> Term
    var Int
    3

                    Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m Term
    zero    Term
    j       Term -> Term -> TCM ()
    == Term
    k
                    Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m (Term -> Term
    suc Term
    n) Term
    zero    Term -> Term -> TCM ()
    == Term -> Term -> Term -> Term -> Term
    aux Term
    zero Term
    m Term
    n Term
    m
                    Term -> Term -> Term -> Term -> Term
    aux Term
    k Term
    m (Term -> Term
    suc Term
    n) (Term -> Term
    suc Term
    j) Term -> Term -> TCM ()
    == Term -> Term -> Term -> Term -> Term
    aux (Term -> Term
    suc Term
    k) Term
    m Term
    n Term
    j

            verifyEquals :: Term -> TCM ()
    verifyEquals Term
    eq =
                Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall {a}.
    Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify [[Char]
    "n",[Char]
    "m"] (((Term -> Term -> Term)
      -> Term
      -> (Term -> Term)
      -> (Term -> Term -> TCM ())
      -> (Term -> Term -> TCM ())
      -> ([TCM ()] -> TCM ())
      -> TCM ())
     -> TCM ())
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                true  <- TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primTrue
                false <- primFalse
                let Term
    x == Term
    y = Term
    eq Term -> Term -> Term
    @@ Term
    x Term -> Term -> Term
    @@ Term
    y
                    m      = Int -> Term
    var Int
    0
                    n      = Int -> Term
    var Int
    1
                (zero  == zero ) === true
                (suc n == suc m) === (n == m)
                (suc n == zero ) === false
                (zero  == suc n) === false

            verifyLess :: Term -> TCM ()
    verifyLess Term
    leq =
                Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall {a}.
    Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify [[Char]
    "n",[Char]
    "m"] (((Term -> Term -> Term)
      -> Term
      -> (Term -> Term)
      -> (Term -> Term -> TCM ())
      -> (Term -> Term -> TCM ())
      -> ([TCM ()] -> TCM ())
      -> TCM ())
     -> TCM ())
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM ())
    -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ \Term -> Term -> Term
    (@@) Term
    zero Term -> Term
    suc Term -> Term -> TCM ()
    (==) Term -> Term -> TCM ()
    (===) [TCM ()] -> TCM ()
    choice -> do
                true  <- TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primTrue
                false <- primFalse
                let Term
    x < Term
    y = Term
    leq Term -> Term -> Term
    @@ Term
    x Term -> Term -> Term
    @@ Term
    y
                    m     = Int -> Term
    var Int
    0
                    n     = Int -> Term
    var Int
    1
                (n     < zero)  === false
                (suc n < suc m) === (n < m)
                (zero  < suc m) === true

            verifyMax :: p -> m ()
    verifyMax p
    maxV = () -> m ()
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()  -- TODO: make max a postulate

            verify :: Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify Names
    xs = TCMT IO Term
    -> TCMT IO Term
    -> TCMT IO Term
    -> Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    forall a.
    TCMT IO Term
    -> TCMT IO Term
    -> TCMT IO Term
    -> Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify' TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primNat TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primZero TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSuc Names
    xs

            verify' ::  TCM Term -> TCM Term -> TCM Term ->
                        [String] -> ( (Term -> Term -> Term) -> Term -> (Term -> Term) ->
                                    (Term -> Term -> TCM ()) ->
                                    (Term -> Term -> TCM ()) ->
                                    ([TCM ()] -> TCM ()) -> TCM a) -> TCM a
            verify' :: forall a.
    TCMT IO Term
    -> TCMT IO Term
    -> TCMT IO Term
    -> Names
    -> ((Term -> Term -> Term)
        -> Term
        -> (Term -> Term)
        -> (Term -> Term -> TCM ())
        -> (Term -> Term -> TCM ())
        -> ([TCM ()] -> TCM ())
        -> TCM a)
    -> TCM a
    verify' TCMT IO Term
    pNat TCMT IO Term
    pZero TCMT IO Term
    pSuc Names
    xs (Term -> Term -> Term)
    -> Term
    -> (Term -> Term)
    -> (Term -> Term -> TCM ())
    -> (Term -> Term -> TCM ())
    -> ([TCM ()] -> TCM ())
    -> TCM a
    f = do
                nat  <- Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Integer -> Sort
    mkType Integer
    0) (Term -> Type) -> TCMT IO Term -> TCM Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Term
    pNat
                zero <- pZero
                s    <- pSuc
                let Term
    x == Term
    y  = TCM () -> TCM ()
    forall (m :: * -> *) a.
    (MonadConstraint m, MonadWarning m, MonadError TCErr m,
     MonadFresh ProblemId m) =>
    m a -> m a
    noConstraints (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ Type -> Term -> Term -> TCM ()
    forall (m :: * -> *).
    MonadConversion m =>
    Type -> Term -> Term -> m ()
    equalTerm Type
    nat Term
    x Term
    y
                    -- Andreas: 2013-10-21 I put primBool here on the inside
                    -- since some Nat-builtins do not require Bool-builtins
                    Term
    x === Term
    y = do bool <- Sort -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Integer -> Sort
    mkType Integer
    0) (Term -> Type) -> m Term -> m Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primBool
                                 noConstraints $ equalTerm bool x y
                    suc Term
    n  = Term
    s Term -> Term -> Term
    forall t. Apply t => t -> Term -> t
    `apply1` Term
    n
                    choice = (TCMT IO a -> TCMT IO a -> TCMT IO a) -> [TCMT IO a] -> TCMT IO a
    forall a. (a -> a -> a) -> [a] -> a
    forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
    foldr1 (\TCMT IO a
    x TCMT IO a
    y -> TCMT IO a
    x TCMT IO a -> (TCErr -> TCMT IO a) -> TCMT IO a
    forall a. TCMT IO a -> (TCErr -> TCMT IO a) -> TCMT IO a
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    `catchError` \TCErr
    _ -> TCMT IO a
    y)
                xs <- mapM freshName_ xs
                addContext (xs, domFromArg $ defaultArg nat) $ f apply1 zero suc (==) (===) choice

            verifyPath :: Term -> Type -> TCM ()
            verifyPath :: Term -> Type -> TCM ()
    verifyPath Term
    path Type
    t = do
              let hlam :: [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    hlam [Char]
    n NamesT m Term -> NamesT m Term
    t = ArgInfo
    -> [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    forall (m :: * -> *).
    Monad m =>
    ArgInfo
    -> [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    glam (Hiding -> ArgInfo -> ArgInfo
    forall a. LensHiding a => Hiding -> a -> a
    setHiding Hiding
    Hidden ArgInfo
    defaultArgInfo) [Char]
    n NamesT m Term -> NamesT m Term
    t
              TCM () -> TCM ()
    forall (m :: * -> *) a.
    (MonadConstraint m, MonadWarning m, MonadError TCErr m,
     MonadFresh ProblemId m) =>
    m a -> m a
    noConstraints (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ Type -> Term -> Term -> TCM ()
    forall (m :: * -> *).
    MonadConversion m =>
    Type -> Term -> Term -> m ()
    equalTerm Type
    t Term
    path (Term -> TCM ()) -> TCMT IO Term -> TCM ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Names -> NamesT (TCMT IO) Term -> TCMT IO Term
    forall (m :: * -> *) a. Names -> NamesT m a -> m a
    runNamesT [] (
                [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    hlam [Char]
    "l" ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
     -> NamesT (TCMT IO) Term)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    l -> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    hlam [Char]
    "A" ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
     -> NamesT (TCMT IO) Term)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    bA -> TCMT IO Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCMT IO Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPathP NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    l NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    Monad m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "i" (\ NamesT (TCMT IO) Term
    _ -> NamesT (TCMT IO) Term
    bA))

    -- | Checks that builtin with name @b : String@ of type @t : Term@
    --   is a data type or inductive record with @n : Int@ constructors.
    --   Returns the name of the data/record type.
    inductiveCheck :: BuiltinId -> Int -> Term -> TCM (QName, Definition)
    inductiveCheck :: BuiltinId -> Int -> Term -> TCM (QName, Definition)
    inductiveCheck BuiltinId
    b Int
    n Term
    t = do
      TCMT IO (Maybe QName)
    -> TCM (QName, Definition)
    -> (QName -> TCM (QName, Definition))
    -> TCM (QName, Definition)
    forall (m :: * -> *) a b.
    Monad m =>
    m (Maybe a) -> m b -> (a -> m b) -> m b
    caseMaybeM (Term -> TCMT IO (Maybe QName)
    headSymbol Term
    t) TCM (QName, Definition)
    no ((QName -> TCM (QName, Definition)) -> TCM (QName, Definition))
    -> (QName -> TCM (QName, Definition)) -> TCM (QName, Definition)
    forall a b. (a -> b) -> a -> b
    $ \QName
    q -> do
          def <- QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    q
          let yes = (QName, Definition) -> TCM (QName, Definition)
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (QName
    q, Definition
    def)
          case theDef def of
            Datatype { dataCons :: Defn -> [QName]
    dataCons = [QName]
    cs }
              | [QName] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [QName]
    cs Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    n -> TCM (QName, Definition)
    yes
              | Bool
    otherwise      -> TCM (QName, Definition)
    no
            Record { recInduction :: Defn -> Maybe Induction
    recInduction = Maybe Induction
    ind } | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 Bool -> Bool -> Bool
    && Maybe Induction
    ind Maybe Induction -> Maybe Induction -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Induction -> Maybe Induction
    forall a. a -> Maybe a
    Just Induction
    CoInductive -> TCM (QName, Definition)
    yes
            Defn
    _ -> TCM (QName, Definition)
    no
      where
      headSymbol :: Term -> TCM (Maybe QName)
      headSymbol :: Term -> TCMT IO (Maybe QName)
    headSymbol Term
    t = Term -> TCMT IO Term
    forall a (m :: * -> *). (Reduce a, MonadReduce m) => a -> m a
    reduce Term
    t TCMT IO Term
    -> (Term -> TCMT IO (Maybe QName)) -> TCMT IO (Maybe QName)
    forall a b. TCMT IO a -> (a -> TCMT IO b) -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \case
        Def QName
    q Elims
    _ -> Maybe QName -> TCMT IO (Maybe QName)
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe QName -> TCMT IO (Maybe QName))
    -> Maybe QName -> TCMT IO (Maybe QName)
    forall a b. (a -> b) -> a -> b
    $ QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    q
        Lam ArgInfo
    _ Abs Term
    b -> Term -> TCMT IO (Maybe QName)
    headSymbol (Term -> TCMT IO (Maybe QName)) -> Term -> TCMT IO (Maybe QName)
    forall a b. (a -> b) -> a -> b
    $ Abs Term -> SubstArg Term -> Term
    forall a. Subst a => Abs a -> SubstArg a -> a
    lazyAbsApp Abs Term
    b Term
    SubstArg Term
    HasCallStack => Term
    __DUMMY_TERM__
        Term
    _       -> Maybe QName -> TCMT IO (Maybe QName)
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe QName
    forall a. Maybe a
    Nothing

      no :: TCM (QName, Definition)
    no = TypeError -> TCM (QName, Definition)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (QName, Definition))
    -> TypeError -> TCM (QName, Definition)
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> Int -> TypeError
    BuiltinMustBeData BuiltinId
    b Int
    n

    -- | @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 ::
      BuiltinId -> ResolvedName -> (QName -> Definition -> TCM Term) -> TCM ()
    bindPostulatedName :: BuiltinId
    -> ResolvedName -> (QName -> Definition -> TCMT IO Term) -> TCM ()
    bindPostulatedName BuiltinId
    builtin ResolvedName
    x QName -> Definition -> TCMT IO Term
    m = do
      q   <- ResolvedName -> TCMT IO QName
    getName ResolvedName
    x
      def <- getConstInfo q
      case theDef def of
        Axiom {} -> BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    builtin (Term -> TCM ()) -> TCMT IO Term -> TCM ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> Definition -> TCMT IO Term
    m QName
    q Definition
    def
        Defn
    _        -> TCM ()
    forall (m :: * -> *) a. MonadTCError m => m a
    err
      where
      err :: forall m a. MonadTCError m => m a
      err :: forall (m :: * -> *) a. MonadTCError m => m a
    err = TypeError -> m a
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> m a) -> TypeError -> m a
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> TypeError
    BuiltinMustBePostulate BuiltinId
    builtin
      getName :: ResolvedName -> TCMT IO QName
    getName = \case
        DefinedName Access
    _ AbstractName
    d Suffix
    NoSuffix -> QName -> TCMT IO QName
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (QName -> TCMT IO QName) -> QName -> TCMT IO QName
    forall a b. (a -> b) -> a -> b
    $ AbstractName -> QName
    anameName AbstractName
    d
        ResolvedName
    _ -> TCMT IO QName
    forall (m :: * -> *) a. MonadTCError m => m a
    err

    addHaskellPragma :: QName -> String -> TCM ()
    addHaskellPragma :: QName -> [Char] -> TCM ()
    addHaskellPragma = BackendName -> QName -> [Char] -> TCM ()
    addPragma BackendName
    ghcBackendName

    bindAndSetHaskellCode :: BuiltinId -> String -> Term -> TCM ()
    bindAndSetHaskellCode :: BuiltinId -> [Char] -> Term -> TCM ()
    bindAndSetHaskellCode BuiltinId
    b [Char]
    hs Term
    t = do
      d <- QName -> Maybe QName -> QName
    forall a. a -> Maybe a -> a
    fromMaybe QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe QName -> QName) -> TCMT IO (Maybe QName) -> TCMT IO QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Term -> TCMT IO (Maybe QName)
    getDef Term
    t
      bindBuiltinName b t
      addHaskellPragma d hs

    bindBuiltinBool :: Term -> TCM ()
    bindBuiltinBool :: Term -> TCM ()
    bindBuiltinBool = BuiltinId -> [Char] -> Term -> TCM ()
    bindAndSetHaskellCode BuiltinId
    builtinBool [Char]
    "= type Bool"

    -- | Check that we're not trying to bind true and false to the same
    -- constructor.
    checkBuiltinBool :: TCM ()
    checkBuiltinBool :: TCM ()
    checkBuiltinBool = do
      true  <- BuiltinId -> TCMT IO (Maybe Term)
    forall (m :: * -> *). HasBuiltins m => BuiltinId -> m (Maybe Term)
    getBuiltin' BuiltinId
    builtinTrue
      false <- getBuiltin' builtinFalse
      when (true == false) $
        typeError $ InvalidBuiltin "Cannot bind TRUE and FALSE to the same constructor"

    bindBuiltinInt :: Term -> TCM ()
    bindBuiltinInt :: Term -> TCM ()
    bindBuiltinInt = BuiltinId -> [Char] -> Term -> TCM ()
    bindAndSetHaskellCode BuiltinId
    builtinInteger [Char]
    "= type Integer"

    bindBuiltinNat :: Term -> TCM ()
    bindBuiltinNat :: Term -> TCM ()
    bindBuiltinNat Term
    t = do
      BuiltinId -> Term -> TCM ()
    bindBuiltinData BuiltinId
    builtinNat Term
    t
      name <- QName -> Maybe QName -> QName
    forall a. a -> Maybe a -> a
    fromMaybe QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe QName -> QName) -> TCMT IO (Maybe QName) -> TCMT IO QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Term -> TCMT IO (Maybe QName)
    getDef Term
    t
      addHaskellPragma name "= type Integer"

    -- | Only use for datatypes with distinct arities of constructors.
    --   Binds the constructors together with the datatype.
    bindBuiltinData :: BuiltinId -> Term -> TCM ()
    bindBuiltinData :: BuiltinId -> Term -> TCM ()
    bindBuiltinData BuiltinId
    s Term
    t = do
      BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    s Term
    t
      name <- QName -> Maybe QName -> QName
    forall a. a -> Maybe a -> a
    fromMaybe QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe QName -> QName) -> TCMT IO (Maybe QName) -> TCMT IO QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Term -> TCMT IO (Maybe QName)
    getDef Term
    t
      Datatype{ dataCons = cs } <- theDef <$> getConstInfo name
      let getArity QName
    c = do
            Constructor{ conArity = a } <- Definition -> Defn
    theDef (Definition -> Defn) -> m Definition -> m Defn
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> QName -> m Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    c
            return a
          getBuiltinArity (BuiltinDataCons TCM Type
    t) = Type -> Int
    arity (Type -> Int) -> TCM Type -> TCMT IO Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCM Type
    t
          getBuiltinArity BuiltinDescriptor
    _ = TCMT IO Int
    forall a. HasCallStack => a
    __IMPOSSIBLE__
          sortByM a -> f b
    f [a]
    xs = ((a, b) -> a) -> [(a, b)] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    map (a, b) -> a
    forall a b. (a, b) -> a
    fst ([(a, b)] -> [a]) -> ([b] -> [(a, b)]) -> [b] -> [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((a, b) -> (a, b) -> Ordering) -> [(a, b)] -> [(a, b)]
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (b -> b -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (b -> b -> Ordering)
    -> ((a, b) -> b) -> (a, b) -> (a, b) -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` (a, b) -> b
    forall a b. (a, b) -> b
    snd) ([(a, b)] -> [(a, b)]) -> ([b] -> [(a, b)]) -> [b] -> [(a, b)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [a] -> [b] -> [(a, b)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [a]
    xs ([b] -> [a]) -> f [b] -> f [a]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (a -> f b) -> [a] -> f [b]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM a -> f b
    f [a]
    xs
      -- Order constructurs by arity
      cs <- sortByM getArity cs
      -- Do the same for the builtins
      let bcis = [BuiltinInfo] -> Maybe [BuiltinInfo] -> [BuiltinInfo]
    forall a. a -> Maybe a -> a
    fromMaybe [BuiltinInfo]
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe [BuiltinInfo] -> [BuiltinInfo])
    -> Maybe [BuiltinInfo] -> [BuiltinInfo]
    forall a b. (a -> b) -> a -> b
    $ do
            BuiltinData _ bcs <- BuiltinInfo -> BuiltinDescriptor
    builtinDesc (BuiltinInfo -> BuiltinDescriptor)
    -> Maybe BuiltinInfo -> Maybe BuiltinDescriptor
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BuiltinId -> Maybe BuiltinInfo
    findBuiltinInfo BuiltinId
    s
            mapM findBuiltinInfo bcs
      bcis <- sortByM (getBuiltinArity . builtinDesc) bcis
      unless (length cs == length bcis) __IMPOSSIBLE__  -- we already checked this
      zipWithM_ (\ QName
    c BuiltinInfo
    bci -> BuiltinInfo -> Expr -> TCM ()
    bindBuiltinInfo BuiltinInfo
    bci (AmbiguousQName -> Expr
    A.Con (AmbiguousQName -> Expr) -> AmbiguousQName -> Expr
    forall a b. (a -> b) -> a -> b
    $ QName -> AmbiguousQName
    unambiguous (QName -> AmbiguousQName) -> QName -> AmbiguousQName
    forall a b. (a -> b) -> a -> b
    $ Range -> QName -> QName
    forall a. SetRange a => Range -> a -> a
    setRange (QName -> Range
    forall a. HasRange a => a -> Range
    getRange QName
    name) QName
    c)) cs bcis

    bindBuiltinUnit :: Term -> TCM ()
    bindBuiltinUnit :: Term -> TCM ()
    bindBuiltinUnit Term
    t = do
      unit <- QName -> Maybe QName -> QName
    forall a. a -> Maybe a -> a
    fromMaybe QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe QName -> QName) -> TCMT IO (Maybe QName) -> TCMT IO QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Term -> TCMT IO (Maybe QName)
    getDef Term
    t
      def <- theDef <$> getConstInfo unit
      case def of
        Record { recFields :: Defn -> [Dom QName]
    recFields = [], recConHead :: Defn -> ConHead
    recConHead = ConHead
    con } -> do
          BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    builtinUnit Term
    t
          BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    builtinUnitUnit (ConHead -> ConInfo -> Elims -> Term
    Con ConHead
    con ConInfo
    ConOSystem [])
        Defn
    _ -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    InvalidBuiltin [Char]
    "Builtin UNIT must be a singleton record type"

    bindBuiltinSigma :: Term -> TCM ()
    bindBuiltinSigma :: Term -> TCM ()
    bindBuiltinSigma Term
    t = do
      sigma <- QName -> Maybe QName -> QName
    forall a. a -> Maybe a -> a
    fromMaybe QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe QName -> QName) -> TCMT IO (Maybe QName) -> TCMT IO QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Term -> TCMT IO (Maybe QName)
    getDef Term
    t
      def <- theDef <$> getConstInfo sigma
      case def of
        Record { recFields :: Defn -> [Dom QName]
    recFields = [Dom QName
    fst,Dom QName
    snd], recConHead :: Defn -> ConHead
    recConHead = ConHead
    con } -> do
          BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    builtinSigma Term
    t
        Defn
    _ -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    InvalidBuiltin [Char]
    "Builtin SIGMA must be a record type with two fields"

    -- | Bind BUILTIN EQUALITY and BUILTIN REFL.
    bindBuiltinEquality :: ResolvedName -> TCM ()
    bindBuiltinEquality :: ResolvedName -> TCM ()
    bindBuiltinEquality ResolvedName
    x = do
      (v, _t) <- Expr -> TCM (Term, Type)
    inferExpr (ResolvedName -> Expr
    forall a. NameToExpr a => a -> Expr
    A.nameToExpr ResolvedName
    x)

      -- Equality needs to be a data type with 1 constructor
      (eq, def) <- inductiveCheck builtinEquality 1 v

      -- Check that the type is the type of a polymorphic relation, i.e.,
      -- Γ → (A : Set _) → A → A → Set _
      TelV eqTel eqCore <- telView $ defType def
      let no = TypeError -> TCMT IO a
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO a) -> TypeError -> TCMT IO a
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    InvalidBuiltin [Char]
    "The type of BUILTIN EQUALITY must be a polymorphic relation"

      -- The target is a sort since eq is a data type.
      unless (isJust $ isSort $ unEl eqCore) __IMPOSSIBLE__

      -- The types of the last two arguments must be the third-last argument
      unless (natSize eqTel >= 3) no
      let (a, b) = fromMaybe __IMPOSSIBLE__ $ last2 $ telToList eqTel
      [a,b] <- reduce $ map (unEl . snd . unDom) [a,b]
      unless (deBruijnView a == Just 0) no
      unless (deBruijnView b == Just 1) no

      -- Get the single constructor.
      case theDef def of
        Datatype { dataCons :: Defn -> [QName]
    dataCons = [QName
    c] } -> do
          BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    builtinEquality Term
    v

          -- Check type of REFL.  It has to be of the form
          -- pars → (x : A) → Eq ... x x

          -- Check the arguments
          cdef <- QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    c
          TelV conTel conCore <- telView $ defType cdef
          ts <- reduce $ map (unEl . snd . unDom) $ drop (conPars $ theDef cdef) $ telToList conTel
          -- After dropping the parameters, there should be maximally one argument.
          unless (length ts <= 1) wrongRefl
          unless (all ((Just 0 ==) . deBruijnView) ts) wrongRefl

          -- Check the target
          case unEl conCore of
            Def QName
    _ Elims
    es -> do
              let vs :: [Term]
    vs = (Arg Term -> Term) -> [Arg Term] -> [Term]
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> Term
    forall e. Arg e -> e
    unArg ([Arg Term] -> [Term]) -> [Arg Term] -> [Term]
    forall a b. (a -> b) -> a -> b
    $ [Arg Term] -> Maybe [Arg Term] -> [Arg Term]
    forall a. a -> Maybe a -> a
    fromMaybe [Arg Term]
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe [Arg Term] -> [Arg Term]) -> Maybe [Arg Term] -> [Arg Term]
    forall a b. (a -> b) -> a -> b
    $ Elims -> Maybe [Arg Term]
    forall a. [Elim' a] -> Maybe [Arg a]
    allApplyElims Elims
    es
              (a,b) <- (Term, Term) -> TCMT IO (Term, Term)
    forall a (m :: * -> *). (Reduce a, MonadReduce m) => a -> m a
    reduce ((Term, Term) -> TCMT IO (Term, Term))
    -> (Term, Term) -> TCMT IO (Term, Term)
    forall a b. (a -> b) -> a -> b
    $ (Term, Term) -> Maybe (Term, Term) -> (Term, Term)
    forall a. a -> Maybe a -> a
    fromMaybe (Term, Term)
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe (Term, Term) -> (Term, Term))
    -> Maybe (Term, Term) -> (Term, Term)
    forall a b. (a -> b) -> a -> b
    $ [Term] -> Maybe (Term, Term)
    forall a. [a] -> Maybe (a, a)
    last2 [Term]
    vs
              unless (deBruijnView a == Just 0) wrongRefl
              unless (deBruijnView b == Just 0) wrongRefl
              bindBuiltinName builtinRefl (Con (ConHead c IsData Inductive []) ConOSystem [])
            Term
    _ -> TCM ()
    forall a. HasCallStack => a
    __IMPOSSIBLE__
        Defn
    _ -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    InvalidBuiltin [Char]
    "Builtin EQUALITY must be a data type with a single constructor"
      where
      wrongRefl :: TCMT IO a
    wrongRefl = TypeError -> TCMT IO a
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO a) -> TypeError -> TCMT IO a
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    InvalidBuiltin [Char]
    "Wrong type of constructor of BUILTIN EQUALITY"

    bindBuiltinInfo :: BuiltinInfo -> A.Expr -> TCM ()
    bindBuiltinInfo :: BuiltinInfo -> Expr -> TCM ()
    bindBuiltinInfo (BuiltinInfo BuiltinId
    s BuiltinDescriptor
    d) Expr
    e = do
        case BuiltinDescriptor
    d of
          BuiltinData TCM Type
    t [BuiltinId]
    cs -> do
            v <- Expr -> Type -> TCMT IO Term
    checkExpr Expr
    e (Type -> TCMT IO Term) -> TCM Type -> TCMT IO Term
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< TCM Type
    t
            unless (s == builtinUnit) $ do
              void $ inductiveCheck s (length cs) v
            if | s == builtinEquality -> __IMPOSSIBLE__ -- bindBuiltinEquality v
               | s == builtinBool     -> bindBuiltinBool     v
               | s == builtinNat      -> bindBuiltinNat      v
               | s == builtinInteger  -> bindBuiltinInt      v
               | s == builtinUnit     -> bindBuiltinUnit     v
               | s == builtinSigma    -> bindBuiltinSigma    v
               | s == builtinList     -> bindBuiltinData s   v
               | s == builtinMaybe    -> bindBuiltinData s   v
               | otherwise            -> bindBuiltinName s   v

          BuiltinDataCons TCM Type
    t -> do

            let name :: Term -> Term
    name (Lam ArgInfo
    h Abs Term
    b)  = Term -> Term
    name (Abs Term -> Term
    forall a. Subst a => Abs a -> a
    absBody Abs Term
    b)
                name (Con ConHead
    c ConInfo
    ci Elims
    _) = ConHead -> ConInfo -> Elims -> Term
    Con ConHead
    c ConInfo
    ci []
                name Term
    _          = Term
    forall a. HasCallStack => a
    __IMPOSSIBLE__

            v0 <- Expr -> Type -> TCMT IO Term
    checkExpr Expr
    e (Type -> TCMT IO Term) -> TCM Type -> TCMT IO Term
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< TCM Type
    t

            case e of
              A.Con{} -> () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
              Expr
    _       -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> Expr -> TypeError
    BuiltinMustBeConstructor BuiltinId
    s Expr
    e

            let v@(Con h _ []) = name v0

            bindBuiltinName s v

            when (s `elem` [builtinFalse, builtinTrue]) checkBuiltinBool

          BuiltinPrim PrimitiveId
    pfname Term -> TCM ()
    axioms -> do
            case Expr
    e of
              A.Def QName
    qx -> do

                PrimImpl t pf <- PrimitiveId -> TCM PrimitiveImpl
    lookupPrimitiveFunction PrimitiveId
    pfname
                v <- checkExpr e t

                axioms v

                info <- getConstInfo qx
                let cls = Definition -> [Clause]
    defClauses Definition
    info
                    a   = Definition -> IsAbstract
    defAbstract Definition
    info
                    o   = Definition -> IsOpaque
    defOpaque Definition
    info
                    mcc = Definition -> Maybe CompiledClauses
    defCompiled Definition
    info
                    inv = Definition -> FunctionInverse
    defInverse Definition
    info
                -- What happens if defArgOccurrences info does not match
                -- primFunArgOccurrences pf? Let's require the latter to
                -- be the empty list.
                unless (primFunArgOccurrences pf == []) __IMPOSSIBLE__
                bindPrimitive pfname $ pf { primFunName = qx }
                addConstant qx $ info { theDef = Primitive { primAbstr    = a
                                                           , primName     = pfname
                                                           , primClauses  = cls
                                                           , primInv      = inv
                                                           , primCompiled = mcc
                                                           , primOpaque   = o
                                                           } }

                -- needed? yes, for checking equations for mul
                bindBuiltinName s v

              Expr
    _ -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> TypeError
    BuiltinMustBeFunction BuiltinId
    s

          BuiltinSort{} -> TCM ()
    forall a. HasCallStack => a
    __IMPOSSIBLE__ -- always a "BuiltinNoDef"

          BuiltinPostulate Relevance
    rel TCM Type
    t -> do
            t' <- TCM Type
    t
            v <- applyRelevanceToContext rel $ checkExpr e t'
            let err = TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> TypeError
    BuiltinMustBePostulate BuiltinId
    s
            case e of
              A.Def QName
    q -> do
                def <- QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    q
                case theDef def of
                  Axiom {} -> do
                    BuiltinId -> QName -> Type -> TCM ()
    builtinSizeHook BuiltinId
    s QName
    q Type
    t'
                    -- And compilation pragmas for base types
                    Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    s BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinLevel)  (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> TCM ()
    setConstTranspAxiom QName
    q TCM () -> TCM () -> TCM ()
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> QName -> [Char] -> TCM ()
    addHaskellPragma QName
    q [Char]
    "= type ()"
                    Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    s BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinChar)   (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> TCM ()
    setConstTranspAxiom QName
    q TCM () -> TCM () -> TCM ()
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> QName -> [Char] -> TCM ()
    addHaskellPragma QName
    q [Char]
    "= type Char"
                    Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    s BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinString) (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> TCM ()
    setConstTranspAxiom QName
    q TCM () -> TCM () -> TCM ()
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> QName -> [Char] -> TCM ()
    addHaskellPragma QName
    q [Char]
    "= type Data.Text.Text"
                    Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    s BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinFloat)  (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> TCM ()
    setConstTranspAxiom QName
    q TCM () -> TCM () -> TCM ()
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> QName -> [Char] -> TCM ()
    addHaskellPragma QName
    q [Char]
    "= type Double"
                    Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    s BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinWord64) (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> TCM ()
    setConstTranspAxiom QName
    q TCM () -> TCM () -> TCM ()
    forall a b. TCMT IO a -> TCMT IO b -> TCMT IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> QName -> [Char] -> TCM ()
    addHaskellPragma QName
    q [Char]
    "= type MAlonzo.RTE.Word64"
                    Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    s BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinPathP)  (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> TCM ()
    builtinPathPHook QName
    q
                    BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    s Term
    v
                  Defn
    _        -> TCM ()
    err
              Expr
    _ -> TCM ()
    err

          BuiltinUnknown Maybe (TCM Type)
    mt Term -> Type -> TCM ()
    f -> do
            (v, t) <- Maybe (TCM Type)
    -> TCM (Term, Type)
    -> (TCM Type -> TCM (Term, Type))
    -> TCM (Term, Type)
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (TCM Type)
    mt (Expr -> TCM (Term, Type)
    inferExpr Expr
    e) ((TCM Type -> TCM (Term, Type)) -> TCM (Term, Type))
    -> (TCM Type -> TCM (Term, Type)) -> TCM (Term, Type)
    forall a b. (a -> b) -> a -> b
    $ \ TCM Type
    tcmt -> do
              t <- TCM Type
    tcmt
              (,t) <$> checkExpr e t
            f v t
            if | s == builtinRewrite -> runMaybeT (getQNameFromTerm v) >>= \case
                  Maybe QName
    Nothing -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    InvalidBuiltin [Char]
    "Invalid rewrite relation"
                  Just QName
    q  -> QName -> TCM ()
    bindBuiltinRewriteRelation QName
    q
               | otherwise           -> bindBuiltinName s v

    setConstTranspAxiom :: QName -> TCM ()
    setConstTranspAxiom :: QName -> TCM ()
    setConstTranspAxiom QName
    q =
      (Signature -> Signature) -> TCM ()
    forall (m :: * -> *).
    MonadTCState m =>
    (Signature -> Signature) -> m ()
    modifySignature ((Signature -> Signature) -> TCM ())
    -> (Signature -> Signature) -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> (Definition -> Definition) -> Signature -> Signature
    updateDefinition QName
    q ((Definition -> Definition) -> Signature -> Signature)
    -> (Definition -> Definition) -> Signature -> Signature
    forall a b. (a -> b) -> a -> b
    $ (Defn -> Defn) -> Definition -> Definition
    updateTheDef (Defn -> Defn -> Defn
    forall a b. a -> b -> a
    const (Defn -> Defn -> Defn) -> Defn -> Defn -> Defn
    forall a b. (a -> b) -> a -> b
    $ Defn
    constTranspAxiom)

    builtinPathPHook :: QName -> TCM ()
    builtinPathPHook :: QName -> TCM ()
    builtinPathPHook QName
    q =
          (Signature -> Signature) -> TCM ()
    forall (m :: * -> *).
    MonadTCState m =>
    (Signature -> Signature) -> m ()
    modifySignature ((Signature -> Signature) -> TCM ())
    -> (Signature -> Signature) -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> (Definition -> Definition) -> Signature -> Signature
    updateDefinition QName
    q
          ((Definition -> Definition) -> Signature -> Signature)
    -> (Definition -> Definition) -> Signature -> Signature
    forall a b. (a -> b) -> a -> b
    $ ([Polarity] -> [Polarity]) -> Definition -> Definition
    updateDefPolarity       [Polarity] -> [Polarity]
    forall a. a -> a
    id
          (Definition -> Definition)
    -> (Definition -> Definition) -> Definition -> Definition
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ([Occurrence] -> [Occurrence]) -> Definition -> Definition
    updateDefArgOccurrences ([Occurrence] -> [Occurrence] -> [Occurrence]
    forall a b. a -> b -> a
    const [Occurrence
    Unused,Occurrence
    StrictPos,Occurrence
    Mixed,Occurrence
    Mixed])

    -- | Bind a builtin thing to an expression.
    bindBuiltin :: BuiltinId -> ResolvedName -> TCM ()
    bindBuiltin :: BuiltinId -> ResolvedName -> TCM ()
    bindBuiltin BuiltinId
    b ResolvedName
    x = do
      TCMT IO Bool -> TCM () -> TCM ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM ((Int
    0 Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) (Int -> Bool) -> TCMT IO Int -> TCMT IO Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Int
    forall (m :: * -> *). MonadTCEnv m => m Int
    getContextSize) (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ do
        -- Andreas, 2017-11-01, issue #2824
        -- Only raise an error if the name for the builtin is defined in a parametrized module.
        let
          failure :: forall m a. MonadTCError m => m a
          failure :: forall (m :: * -> *) a. MonadTCError m => m a
    failure = TypeError -> m a
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> m a) -> TypeError -> m a
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> TypeError
    BuiltinInParameterisedModule BuiltinId
    b
        -- Get the non-empty list of AbstractName for x
        xs <- case ResolvedName
    x of
          VarName{}            -> TCMT IO (NonEmpty AbstractName)
    forall (m :: * -> *) a. MonadTCError m => m a
    failure
          DefinedName Access
    _ AbstractName
    x Suffix
    NoSuffix -> NonEmpty AbstractName -> TCMT IO (NonEmpty AbstractName)
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (NonEmpty AbstractName -> TCMT IO (NonEmpty AbstractName))
    -> NonEmpty AbstractName -> TCMT IO (NonEmpty AbstractName)
    forall a b. (a -> b) -> a -> b
    $ AbstractName
    x AbstractName -> [AbstractName] -> NonEmpty AbstractName
    forall a. a -> [a] -> NonEmpty a
    :| []
          DefinedName Access
    _ AbstractName
    x Suffix{} -> TCMT IO (NonEmpty AbstractName)
    forall (m :: * -> *) a. MonadTCError m => m a
    failure
          FieldName NonEmpty AbstractName
    xs         -> NonEmpty AbstractName -> TCMT IO (NonEmpty AbstractName)
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return NonEmpty AbstractName
    xs
          ConstructorName Set1 Induction
    _ NonEmpty AbstractName
    xs -> NonEmpty AbstractName -> TCMT IO (NonEmpty AbstractName)
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return NonEmpty AbstractName
    xs
          PatternSynResName NonEmpty AbstractName
    xs -> TCMT IO (NonEmpty AbstractName)
    forall (m :: * -> *) a. MonadTCError m => m a
    failure
          ResolvedName
    UnknownName          -> TCMT IO (NonEmpty AbstractName)
    forall (m :: * -> *) a. MonadTCError m => m a
    failure
        -- For ambiguous names, we check all of their definitions:
        unlessM (forallM xs $ null <.> lookupSection . qnameModule . anameName) $
          failure
      -- Since the name was define in a parameter-free context, we can switch to the empty context.
      -- (And we should!)
      TCM () -> TCM ()
    forall (tcm :: * -> *) a.
    (MonadTCEnv tcm, ReadTCState tcm) =>
    tcm a -> tcm a
    inTopContext (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ do
      if | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinRefl  -> Warning -> TCM ()
    forall (m :: * -> *).
    (HasCallStack, MonadWarning m) =>
    Warning -> m ()
    warning (Warning -> TCM ()) -> Warning -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> BuiltinId -> Warning
    OldBuiltin BuiltinId
    b BuiltinId
    builtinEquality
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinZero  -> BuiltinId -> BuiltinId -> TCM ()
    forall {m :: * -> *}.
    MonadWarning m =>
    BuiltinId -> BuiltinId -> m ()
    now BuiltinId
    builtinNat BuiltinId
    b
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinSuc   -> BuiltinId -> BuiltinId -> TCM ()
    forall {m :: * -> *}.
    MonadWarning m =>
    BuiltinId -> BuiltinId -> m ()
    now BuiltinId
    builtinNat BuiltinId
    b
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinNil   -> BuiltinId -> BuiltinId -> TCM ()
    forall {m :: * -> *}.
    MonadWarning m =>
    BuiltinId -> BuiltinId -> m ()
    now BuiltinId
    builtinList BuiltinId
    b
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinCons  -> BuiltinId -> BuiltinId -> TCM ()
    forall {m :: * -> *}.
    MonadWarning m =>
    BuiltinId -> BuiltinId -> m ()
    now BuiltinId
    builtinList BuiltinId
    b
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinInf   -> ResolvedName -> TCM ()
    bindBuiltinInf ResolvedName
    x
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinSharp -> ResolvedName -> TCM ()
    bindBuiltinSharp ResolvedName
    x
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinFlat  -> ResolvedName -> TCM ()
    bindBuiltinFlat ResolvedName
    x
         | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinEquality -> ResolvedName -> TCM ()
    bindBuiltinEquality ResolvedName
    x
         | Just BuiltinInfo
    i <- BuiltinId -> Maybe BuiltinInfo
    findBuiltinInfo BuiltinId
    b -> BuiltinInfo -> Expr -> TCM ()
    bindBuiltinInfo BuiltinInfo
    i (ResolvedName -> Expr
    forall a. NameToExpr a => a -> Expr
    A.nameToExpr ResolvedName
    x)
         | Bool
    otherwise -> TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    NoSuchBuiltinName (BuiltinId -> [Char]
    forall a. IsBuiltin a => a -> [Char]
    getBuiltinId BuiltinId
    b)
      where
        now :: BuiltinId -> BuiltinId -> m ()
    now BuiltinId
    new BuiltinId
    b = Warning -> m ()
    forall (m :: * -> *).
    (HasCallStack, MonadWarning m) =>
    Warning -> m ()
    warning (Warning -> m ()) -> Warning -> m ()
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> BuiltinId -> Warning
    OldBuiltin BuiltinId
    b BuiltinId
    new

    isUntypedBuiltin :: BuiltinId -> Bool
    isUntypedBuiltin :: BuiltinId -> Bool
    isUntypedBuiltin = [BuiltinId] -> BuiltinId -> Bool
    forall a. Ord a => [a] -> a -> Bool
    hasElem [ BuiltinId
    builtinFromNat, BuiltinId
    builtinFromNeg, BuiltinId
    builtinFromString ]

    bindUntypedBuiltin :: BuiltinId -> ResolvedName -> TCM ()
    bindUntypedBuiltin :: BuiltinId -> ResolvedName -> TCM ()
    bindUntypedBuiltin BuiltinId
    b = \case
      DefinedName Access
    _ AbstractName
    x Suffix
    NoSuffix -> AbstractName -> TCM ()
    bind AbstractName
    x
      DefinedName Access
    _ AbstractName
    x Suffix{} -> TCM ()
    wrong
      FieldName (AbstractName
    x :| [])  -> AbstractName -> TCM ()
    bind AbstractName
    x
      FieldName (AbstractName
    x :| [AbstractName]
    _)   -> AbstractName -> TCM ()
    forall {m :: * -> *} {a} {b}.
    (MonadError TCErr m, PrettyTCM a, MonadFresh NameId m,
     MonadInteractionPoints m, MonadStConcreteNames m, PureTCM m,
     IsString (m Doc), Null (m Doc), Semigroup (m Doc)) =>
    a -> m b
    amb AbstractName
    x
      VarName Name
    _x BindingSource
    _bnd      -> TCM ()
    wrong
      ResolvedName
    UnknownName          -> TCM ()
    wrong
      ConstructorName Set1 Induction
    _ NonEmpty AbstractName
    xs -> NonEmpty AbstractName -> TCM ()
    err NonEmpty AbstractName
    xs
      PatternSynResName NonEmpty AbstractName
    xs -> NonEmpty AbstractName -> TCM ()
    err NonEmpty AbstractName
    xs
      where
      bind :: AbstractName -> TCM ()
    bind AbstractName
    x = BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    b (QName -> Elims -> Term
    Def (AbstractName -> QName
    anameName AbstractName
    x) [])
      wrong :: TCM ()
    wrong  = TypeError -> TCM ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM ()) -> TypeError -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ BuiltinId -> TypeError
    BuiltinMustBeDef BuiltinId
    b
      amb :: a -> m b
    amb a
    x  = Doc -> m b
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    Doc -> m a
    genericDocError (Doc -> m b) -> m Doc -> m b
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< do [Char] -> m Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text [Char]
    "Name " m Doc -> m Doc -> m Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> a -> m Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    forall (m :: * -> *). MonadPretty m => a -> m Doc
    prettyTCM a
    x m Doc -> m Doc -> m Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> m Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text [Char]
    " is ambiguous"
      err :: NonEmpty AbstractName -> TCM ()
    err (AbstractName
    x :| [AbstractName]
    xs1)
        | [AbstractName] -> Bool
    forall a. Null a => a -> Bool
    null [AbstractName]
    xs1  = TCM ()
    wrong
        | Bool
    otherwise = AbstractName -> TCM ()
    forall {m :: * -> *} {a} {b}.
    (MonadError TCErr m, PrettyTCM a, MonadFresh NameId m,
     MonadInteractionPoints m, MonadStConcreteNames m, PureTCM m,
     IsString (m Doc), Null (m Doc), Semigroup (m Doc)) =>
    a -> m b
    amb AbstractName
    x

    -- | 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 :: BuiltinId -> A.QName -> TCM ()
    bindBuiltinNoDef :: BuiltinId -> QName -> TCM ()
    bindBuiltinNoDef BuiltinId
    b QName
    q = TCM () -> TCM ()
    forall (tcm :: * -> *) a.
    (MonadTCEnv tcm, ReadTCState tcm) =>
    tcm a -> tcm a
    inTopContext (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ do
      Bool -> TCM () -> TCM ()
    forall b (m :: * -> *). (IsBool b, Monad m) => b -> m () -> m ()
    when (BuiltinId
    b BuiltinId -> [BuiltinId] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [BuiltinId]
    sizeBuiltins) (TCM () -> TCM ()) -> TCM () -> TCM ()
    forall a b. (a -> b) -> a -> b
    $
        [Char] -> TCM ()
    forall (m :: * -> *).
    (HasCallStack, HasOptions m, MonadTCError m) =>
    [Char] -> m ()
    requireOptionSizedTypes ([Char] -> TCM ()) -> [Char] -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "to declare size BUILTIN " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ BuiltinId -> [Char]
    forall a. IsBuiltin a => a -> [Char]
    getBuiltinId BuiltinId
    b
      case BuiltinInfo -> BuiltinDescriptor
    builtinDesc (BuiltinInfo -> BuiltinDescriptor)
    -> Maybe BuiltinInfo -> Maybe BuiltinDescriptor
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BuiltinId -> Maybe BuiltinInfo
    findBuiltinInfo BuiltinId
    b of

        Just (BuiltinPostulate Relevance
    rel TCM Type
    mt) -> do
          -- We start by adding the corresponding postulate
          t   <- TCM Type
    mt
          fun <- emptyFunctionData
          addConstant' q (setRelevance rel defaultArgInfo) t (def fun)
          -- And we then *modify* the definition based on our needs:
          -- We add polarity information for SIZE-related definitions
          builtinSizeHook b q t
          -- Finally, bind the BUILTIN in the environment.
          bindBuiltinName b $ Def q []
          where
            -- Andreas, 2015-02-14
            -- Special treatment of SizeUniv, should maybe be a primitive.
            def :: FunctionData -> Defn
    def FunctionData
    fun
                | BuiltinId
    b BuiltinId -> BuiltinId -> Bool
    forall a. Eq a => a -> a -> Bool
    == BuiltinId
    builtinSizeUniv = FunctionData -> Defn
    FunctionDefn (FunctionData -> Defn) -> FunctionData -> Defn
    forall a b. (a -> b) -> a -> b
    $ FunctionData
    fun
                    { _funClauses    = [ (empty :: Clause) { clauseBody = Just $ Sort sSizeUniv } ]
                    , _funCompiled   = Just (CC.Done [] $ Sort sSizeUniv)
                    , _funMutual     = Just []
                    , _funTerminates = Just True
                    }
                | Bool
    otherwise = Defn
    defaultAxiom

        Just (BuiltinPrim PrimitiveId
    name Term -> TCM ()
    axioms) -> do
          PrimImpl t pf <- PrimitiveId -> TCM PrimitiveImpl
    lookupPrimitiveFunction PrimitiveId
    name
          bindPrimitive name $ pf { primFunName = q }
          let v   = QName -> Elims -> Term
    Def QName
    q []
              def = Primitive { primAbstr :: IsAbstract
    primAbstr    = IsAbstract
    ConcreteDef
                              , primName :: PrimitiveId
    primName     = PrimitiveId
    name
                              , primClauses :: [Clause]
    primClauses  = []
                              , primInv :: FunctionInverse
    primInv      = FunctionInverse
    forall c. FunctionInverse' c
    NotInjective
                              , primCompiled :: Maybe CompiledClauses
    primCompiled = CompiledClauses -> Maybe CompiledClauses
    forall a. a -> Maybe a
    Just ([Arg [Char]] -> Term -> CompiledClauses
    forall a. [Arg [Char]] -> a -> CompiledClauses' a
    CC.Done [] (Term -> CompiledClauses) -> Term -> CompiledClauses
    forall a b. (a -> b) -> a -> b
    $ QName -> Elims -> Term
    Def QName
    q [])
                              , primOpaque :: IsOpaque
    primOpaque   = IsOpaque
    TransparentDef
                              }
          lang <- getLanguage
          addConstant q $
            (defaultDefn defaultArgInfo q t lang def)
              { defArgOccurrences = primFunArgOccurrences pf }
          axioms v
          bindBuiltinName b v

        Just (BuiltinDataCons TCM Type
    mt) -> do
          t       <- TCM Type
    mt
          d       <- return $! getPrimName $ unEl t
          erasure <- optErasure <$> pragmaOptions
          let
            ch = QName -> DataOrRecord -> Induction -> [Arg QName] -> ConHead
    ConHead QName
    q DataOrRecord
    forall p. DataOrRecord' p
    IsData Induction
    Inductive []
            def = Constructor
                  { conPars :: Int
    conPars   = Int
    0   -- Andrea TODO: fix zeros
                  , conArity :: Int
    conArity  = Int
    0
                  , conSrcCon :: ConHead
    conSrcCon = ConHead
    ch
                  , conData :: QName
    conData   = QName
    d
                  , conAbstr :: IsAbstract
    conAbstr  = IsAbstract
    ConcreteDef
                  , conComp :: CompKit
    conComp   = CompKit
    emptyCompKit
                  , conProj :: Maybe [QName]
    conProj   = Maybe [QName]
    forall a. Maybe a
    Nothing
                  , conForced :: [IsForced]
    conForced = []
                  , conErased :: Maybe [Bool]
    conErased = Maybe [Bool]
    forall a. Maybe a
    Nothing
                  , conErasure :: Bool
    conErasure = Bool
    erasure
                  , conInline :: Bool
    conInline  = Bool
    False
                  }
          addConstant' q defaultArgInfo t def
          addDataCons d [q]

          bindBuiltinName b $ Con ch ConOSystem []

        Just (BuiltinData TCM Type
    mt [BuiltinId]
    cs) -> do
          t <- TCM Type
    mt
          addConstant' q defaultArgInfo t (def t)
          bindBuiltinName b $ Def q []
          where
            def :: a -> Defn
    def a
    t = Datatype
                  { dataPars :: Int
    dataPars       = Int
    0
                  , dataIxs :: Int
    dataIxs        = Int
    0
                  , dataClause :: Maybe Clause
    dataClause     = Maybe Clause
    forall a. Maybe a
    Nothing
                  , dataCons :: [QName]
    dataCons       = []     -- Constructors are added later
                  , dataSort :: Sort
    dataSort       = a -> Sort
    forall a. LensSort a => a -> Sort
    getSort a
    t
                  , dataAbstr :: IsAbstract
    dataAbstr      = IsAbstract
    ConcreteDef
                  , dataMutual :: Maybe [QName]
    dataMutual     = Maybe [QName]
    forall a. Maybe a
    Nothing
                  , dataPathCons :: [QName]
    dataPathCons   = []
                  , dataTranspIx :: Maybe QName
    dataTranspIx   = Maybe QName
    forall a. Maybe a
    Nothing -- Id has custom transp def.
                  , dataTransp :: Maybe QName
    dataTransp     = Maybe QName
    forall a. Maybe a
    Nothing
                  }

        Just (BuiltinSort BuiltinSort
    builtinSort) -> do
          let s :: Sort
    s = case BuiltinSort
    builtinSort of
                    SortUniv Univ
    u       -> Univ -> Level -> Sort
    forall t. Univ -> Level' t -> Sort' t
    Univ Univ
    u (Level -> Sort) -> Level -> Sort
    forall a b. (a -> b) -> a -> b
    $ Integer -> Level
    ClosedLevel Integer
    0
                    SortOmega Univ
    u      -> Univ -> Integer -> Sort
    forall t. Univ -> Integer -> Sort' t
    Inf Univ
    u Integer
    0
                    BuiltinSort
    SortIntervalUniv -> Sort
    forall t. Sort' t
    IntervalUniv
                    BuiltinSort
    SortLevelUniv    -> Sort
    forall t. Sort' t
    LevelUniv
              def :: Defn
    def = BuiltinSort -> Sort -> Defn
    PrimitiveSort BuiltinSort
    builtinSort Sort
    s
          -- Check for the cubical flag if the sort requries it
          case BuiltinSort
    builtinSort of
            BuiltinSort
    SortIntervalUniv -> Cubical -> TCM ()
    requireCubical Cubical
    CErased
            BuiltinSort
    _ -> () -> TCM ()
    forall a. a -> TCMT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
          QName -> ArgInfo -> Type -> Defn -> TCM ()
    addConstant' QName
    q ArgInfo
    defaultArgInfo (Sort -> Type
    sort (Sort -> Type) -> Sort -> Type
    forall a b. (a -> b) -> a -> b
    $ Sort -> Sort
    univSort Sort
    s) Defn
    def
          BuiltinId -> Term -> TCM ()
    bindBuiltinName BuiltinId
    b (Term -> TCM ()) -> Term -> TCM ()
    forall a b. (a -> b) -> a -> b
    $ QName -> Elims -> Term
    Def QName
    q []

        Just{}  -> TCM ()
    forall a. HasCallStack => a
    __IMPOSSIBLE__
        Maybe BuiltinDescriptor
    Nothing -> TCM ()
    forall a. HasCallStack => a
    __IMPOSSIBLE__ -- typeError $ NoSuchBuiltinName b

    builtinKindOfName :: BuiltinId -> Maybe KindOfName
    builtinKindOfName :: BuiltinId -> Maybe KindOfName
    builtinKindOfName = BuiltinInfo -> KindOfName
    distinguish (BuiltinInfo -> KindOfName)
    -> (BuiltinId -> Maybe BuiltinInfo)
    -> BuiltinId
    -> Maybe KindOfName
    forall (m :: * -> *) b c a.
    Functor m =>
    (b -> c) -> (a -> m b) -> a -> m c
    <.> BuiltinId -> Maybe BuiltinInfo
    findBuiltinInfo
      where
      distinguish :: BuiltinInfo -> KindOfName
    distinguish BuiltinInfo
    d = case BuiltinInfo -> BuiltinDescriptor
    builtinDesc BuiltinInfo
    d of
        BuiltinDataCons{}  -> KindOfName
    ConName
        BuiltinData{}      -> KindOfName
    DataName       -- Andreas, 2020-04-13: Crude.  Could be @RecName@.
        BuiltinPrim{}      -> KindOfName
    PrimName
        BuiltinPostulate{} -> KindOfName
    AxiomName
        BuiltinSort{}      -> KindOfName
    PrimName
        BuiltinUnknown{}   -> KindOfName
    OtherDefName