-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

-- | Module, providing functions for conversion from
-- instruction and value representation from @Morley.Michelson.Type@ module
-- to strictly-typed GADT-based representation from @Morley.Michelson.Value@ module.
--
-- This conversion is labeled as type check because that's what we are obliged
-- to do on our way.
--
-- Type check algorithm relies on the property of Michelson language that each
-- instruction on a given input stack type produces a definite output stack
-- type.
-- Michelson contract defines concrete types for storage and parameter, from
-- which input stack type is deduced. Then this type is being combined with
-- each subsequent instruction, producing next stack type after each
-- application.
--
-- Function @typeCheck@ takes list of instructions and returns value of type
-- @Instr inp out@ along with @HST inp@ and @HST out@ all wrapped into
-- @SomeInstr@ data type. This wrapping is done to satisfy Haskell type
-- system (which has no support for dependent types).
-- Functions @typeCheckInstr@, @typeCheckValue@ behave similarly.
--
-- When a recursive call is made within @typeCheck@, @typeCheckInstr@ or
-- @typeCheckValue@, result of a call is unwrapped from @SomeInstr@ and type
-- information from @HST inp@ and @HST out@ is being used to assert that
-- recursive call returned instruction of expected type
-- (error is thrown otherwise).
module Morley.Michelson.TypeCheck.Instr
    ( typeCheckContract
    , typeCheckContractAndStorage
    , typeCheckInstr
    , typeCheckList
    , tcList
    , typeCheckListNoExcept
    , typeCheckParameter
    , typeCheckStorage
    , typeCheckTopLevelType
    , typeCheckValue
    , typeCheckValueRunCodeCompat
    , typeVerifyContract
    , typeVerifyParameter
    , typeVerifyStorage
    , typeVerifyTopLevelType
    , typeVerifyView
    ) where

import Prelude hiding (EQ, GT, LT)

import Control.Monad.Except (MonadError, catchError, liftEither, throwError)
import Data.Constraint ((\\))
import Data.Default (def)
import Data.Generics (everything, mkQ)
import Data.Sequence ((|>))
import Data.Sequence qualified as Seq
import Data.Singletons (Sing, SomeSing(..), demote, withSingI, withSomeSing)
import Data.Type.Equality (TestEquality(..))
import Data.Typeable ((:~:)(..))
import Fmt (pretty)

import Morley.Michelson.TypeCheck.Error
import Morley.Michelson.TypeCheck.Ext
import Morley.Michelson.TypeCheck.Helpers
import Morley.Michelson.TypeCheck.TypeCheck
import Morley.Michelson.TypeCheck.TypeCheckedSeq
  (IllTypedInstr(..), TypeCheckedInstr, TypeCheckedOp(..), TypeCheckedSeq(..), someInstrToOp,
  someViewToOp, tcsEither)
import Morley.Michelson.TypeCheck.Types
import Morley.Michelson.TypeCheck.Value
import Morley.Michelson.Typed hiding (Branch(..))
import Morley.Michelson.Typed.Contract (giveNotInView)

import Morley.Util.MismatchError
import Morley.Util.Peano
import Morley.Util.PeanoNatural
import Morley.Util.Sing (SingIOne, withSingIOne)
import Morley.Util.Type (knownListFromSingI, onFirst, type (++))

import Morley.Michelson.Untyped qualified as U
import Morley.Michelson.Untyped.Annotation (VarAnn)
import Morley.Util.Peano qualified as Peano

-- | Type check a contract and verify that the given storage
-- is of the type expected by the contract.
typeCheckContractAndStorage
  :: U.Contract -> U.Value -> TypeCheckResult SomeContractAndStorage
typeCheckContractAndStorage :: Contract -> Value -> TypeCheckResult SomeContractAndStorage
typeCheckContractAndStorage Contract
uContract Value
uStorage = do
  SomeContract (contract :: Contract cp st
contract@Contract{} :: Contract cp st) <- Contract -> TypeCheckResult SomeContract
typeCheckContract Contract
uContract
  Value st
storage <- forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeVerifyStorage @st Value
uStorage
  pure $ Contract cp st -> Value st -> SomeContractAndStorage
forall (cp :: T) (st :: T).
(StorageScope st, ParameterScope cp) =>
Contract cp st -> Value st -> SomeContractAndStorage
SomeContractAndStorage Contract cp st
contract Value st
storage

typeCheckContract
  :: U.Contract
  -> TypeCheckResult SomeContract
typeCheckContract :: Contract -> TypeCheckResult SomeContract
typeCheckContract Contract
c = do
  SomeParamType
paramType <- Either TCError SomeParamType
-> ReaderT
     TypeCheckOptions (ExceptT TCError Identity) SomeParamType
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError SomeParamType
 -> ReaderT
      TypeCheckOptions (ExceptT TCError Identity) SomeParamType)
-> Either TCError SomeParamType
-> ReaderT
     TypeCheckOptions (ExceptT TCError Identity) SomeParamType
forall a b. (a -> b) -> a -> b
$ ParameterType -> Either TCError SomeParamType
mkSomeParamType (Contract -> ParameterType
forall op. Contract' op -> ParameterType
U.contractParameter Contract
c)
  TypeCheckMode
-> TypeCheck SomeContract -> TypeCheckResult SomeContract
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck (SomeParamType -> TypeCheckMode
TypeCheckContract SomeParamType
paramType) (TypeCheck SomeContract -> TypeCheckResult SomeContract)
-> TypeCheck SomeContract -> TypeCheckResult SomeContract
forall a b. (a -> b) -> a -> b
$ Contract -> TypeCheck SomeContract
typeCheckContractImpl Contract
c

typeVerifyContract
  :: forall cp st.
     (SingI cp, SingI st)
  => U.Contract -> TypeCheckResult (Contract cp st)
typeVerifyContract :: forall (cp :: T) (st :: T).
(SingI cp, SingI st) =>
Contract -> TypeCheckResult (Contract cp st)
typeVerifyContract Contract
uContract = do
  SomeContract tContract :: Contract cp st
tContract@(Contract{} :: Contract cp' st') <-
    Contract -> TypeCheckResult SomeContract
typeCheckContract Contract
uContract
  cp :~: cp
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @cp' @cp (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
  st :~: st
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @st' @st (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltStorageType)
  Contract cp st
-> ReaderT
     TypeCheckOptions (ExceptT TCError Identity) (Contract cp st)
forall (m :: * -> *) a. Monad m => a -> m a
return Contract cp st
tContract
  where
    mkErr :: TopLevelType -> MismatchError T -> TypeCheckResult any
    mkErr :: forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
tyDesc MismatchError T
merr =
      TCError -> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT TypeCheckOptions (ExceptT TCError Identity) any)
-> TCError
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"error in contract type" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$
          TopLevelType -> MismatchError T -> TCTypeError
UnexpectedTopLevelType TopLevelType
tyDesc MismatchError T
merr

withWTP :: forall t a. SingI t => (WellTyped t => TypeCheck a) -> TypeCheck a
withWTP :: forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP WellTyped t => TypeCheck a
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
  Right Dict (WellTyped t)
Dict -> TypeCheck a
WellTyped t => TypeCheck a
fn
  Left NotWellTyped
err -> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      a)
-> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError (NotWellTyped -> Text
forall a b. (Buildable a, FromBuilder b) => a -> b
pretty NotWellTyped
err) Maybe TCTypeError
forall a. Maybe a
Nothing

withWTPInstr_ :: forall t a. SingI t => U.ExpandedInstr -> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ :: forall (t :: T) a.
SingI t =>
ExpandedInstr
-> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ ExpandedInstr
v SomeHST
t WellTyped t => TypeCheckInstr a
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
  Right Dict (WellTyped t)
Dict -> TypeCheckInstr a
WellTyped t => TypeCheckInstr a
fn
  Left (NotWellTyped T
badType BadTypeForScope
cause) -> do
    ErrorSrcPos
loc <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
    TCError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      a)
-> TCError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     a
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
v SomeHST
t ErrorSrcPos
loc Maybe TypeContext
forall a. Maybe a
Nothing (TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope T
badType BadTypeForScope
cause)

withWTPInstr'_
  :: forall t inp. SingI t
  => U.ExpandedInstr
  -> SomeHST
  -> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
  -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ :: forall (t :: T) (inp :: [T]).
SingI t =>
ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ ExpandedInstr
v SomeHST
t WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp)
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
  Right Dict (WellTyped t)
Dict -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp)
fn
  Left (NotWellTyped T
badType BadTypeForScope
cause) -> do
    ErrorSrcPos
loc <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
    let err :: TCError
err = ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
v SomeHST
t ErrorSrcPos
loc Maybe TypeContext
forall a. Maybe a
Nothing
              (TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope T
badType BadTypeForScope
cause)
    TypeCheckedSeq inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq inp))
-> TypeCheckedSeq inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq TCError
err [ExpandedOp -> IllTypedInstr
NonTypedInstr (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> ExpandedOp
U.PrimEx ExpandedInstr
v]

typeCheckContractImpl
  :: U.Contract
  -> TypeCheck SomeContract
typeCheckContractImpl :: Contract -> TypeCheck SomeContract
typeCheckContractImpl uContract :: Contract
uContract@(U.Contract wholeParam :: ParameterType
wholeParam@(U.ParameterType Ty
mParam RootAnn
rootAnn) Ty
mStorage [ExpandedOp]
pCode EntriesOrder
entriesOrder [View' ExpandedOp]
uViews) = do
  NonEmpty ExpandedOp
_ <- ReaderT
  TypeCheckEnv
  (ReaderT TypeCheckOptions (ExceptT TCError Identity))
  (NonEmpty ExpandedOp)
-> (NonEmpty ExpandedOp
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (NonEmpty ExpandedOp))
-> Maybe (NonEmpty ExpandedOp)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (NonEmpty ExpandedOp)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (NonEmpty ExpandedOp)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (NonEmpty ExpandedOp))
-> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (NonEmpty ExpandedOp)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"no instructions in contract code" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
EmptyCode)
                NonEmpty ExpandedOp
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (NonEmpty ExpandedOp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ExpandedOp] -> Maybe (NonEmpty ExpandedOp)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty [ExpandedOp]
pCode)
  Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mParam ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckEnv
       (ReaderT TypeCheckOptions (ExceptT TCError Identity))
       SomeContract)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      SomeContract)
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
paramNote :: Notes param) ->
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mStorage ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckEnv
       (ReaderT TypeCheckOptions (ExceptT TCError Identity))
       SomeContract)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      SomeContract)
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
storageNote :: Notes st) -> do
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @st ((WellTyped t => TypeCheck SomeContract) -> TypeCheck SomeContract)
-> (WellTyped t => TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @param ((WellTyped t => TypeCheck SomeContract) -> TypeCheck SomeContract)
-> (WellTyped t => TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
          Dict (ParameterScope t)
Dict <- (BadTypeForScope
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Dict (ParameterScope t)))
-> (Dict (ParameterScope t)
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ParameterScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @param Text
"parameter") Dict (ParameterScope t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ParameterScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either BadTypeForScope (Dict (ParameterScope t))
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ParameterScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope param)
          Dict (StorageScope t)
Dict <- (BadTypeForScope
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Dict (StorageScope t)))
-> (Dict (StorageScope t)
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (StorageScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @st Text
"storage") Dict (StorageScope t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (StorageScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either BadTypeForScope (Dict (StorageScope t))
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (StorageScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(StorageScope st)
          let inp :: HST '[ 'TPair t t]
inp = (forall {k} (a :: k). SingI a => Sing a
forall (a :: T). SingI a => Sing a
sing @('TPair param st), Dict (WellTyped ('TPair t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair t t), Dict (WellTyped ('TPair t t)))
-> HST '[] -> HST '[ 'TPair t t]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil

          -- typecheck contract code
          TypeCheckedSeq '[ 'TPair t t]
codeRes <-
            TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TypeCheckedSeq '[ 'TPair t t])
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (TypeCheckedSeq '[ 'TPair t t])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (TypeCheckedSeq '[ 'TPair t t])
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (TypeCheckedSeq '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TypeCheckedSeq '[ 'TPair t t])
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (TypeCheckedSeq '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
            ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq '[ 'TPair t t])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
     (ExceptT TCError Identity)
     (TypeCheckedSeq '[ 'TPair t t])
forall (m :: * -> *) e a.
MonadMultiReaderT m Identity =>
m a -> ChangeMultiReaderBase m (Except e) a
liftNoExcept (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq '[ 'TPair t t])
 -> ChangeMultiReaderBase
      (ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
      (ExceptT TCError Identity)
      (TypeCheckedSeq '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[ 'TPair t t])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
     (ExceptT TCError Identity)
     (TypeCheckedSeq '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
            TcInstrHandler
-> [ExpandedOp]
-> HST '[ 'TPair t t]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t t])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl
              ((IsNotInView =>
 ExpandedInstr
 -> HST inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  ExpandedInstr
  -> HST inp
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
       (TypeCheckedSeq inp))
 -> ExpandedInstr
 -> HST inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq inp))
-> (IsNotInView =>
    ExpandedInstr
    -> HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter
  TypeCheckInstrEnv
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
  (Maybe (Dict IsNotInView))
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  TypeCheckInstrEnv
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
  (Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView (Maybe (Dict IsNotInView)
 -> TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall a b. (a -> b) -> a -> b
$ Dict IsNotInView -> Maybe (Dict IsNotInView)
forall a. a -> Maybe a
Just Dict IsNotInView
forall (a :: Constraint). a => Dict a
Dict) (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq inp))
-> (ExpandedInstr
    -> HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall a b c. SuperComposition a b c => a -> b -> c
... ExpandedInstr
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
TcInstrHandler
typeCheckInstr)
              [ExpandedOp]
pCode
              HST '[ 'TPair t t]
inp
          instr :: SomeInstr '[ 'TPair t t]
instr@(HST '[ 'TPair t t]
_ :/ SomeInstrOut '[ 'TPair t t]
instrOut) <-
            ([TypeCheckedOp]
 -> TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (SomeInstr '[ 'TPair t t]))
-> (SomeInstr '[ 'TPair t t]
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (SomeInstr '[ 'TPair t t]))
-> TypeCheckedSeq '[ 'TPair t t]
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr '[ 'TPair t t])
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither [TypeCheckedOp]
-> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr '[ 'TPair t t])
forall a. [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedCodeTypeCheck SomeInstr '[ 'TPair t t]
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr '[ 'TPair t t])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq '[ 'TPair t t]
codeRes

          -- typecheck views
          [SomeView t]
views <- Contract' TypeCheckedOp
-> Notes t -> [View' ExpandedOp] -> TypeCheck [SomeView t]
forall (st :: T).
WellTyped st =>
Contract' TypeCheckedOp
-> Notes st -> [View' ExpandedOp] -> TypeCheck [SomeView st]
typeCheckViewsImpl
            Contract
uContract{ contractCode :: [TypeCheckedOp]
U.contractCode = [SomeInstr '[ 'TPair t t] -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr '[ 'TPair t t]
instr], contractViews :: [View' TypeCheckedOp]
U.contractViews = [] }
            Notes t
storageNote [View' ExpandedOp]
uViews

          (TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall e (m :: * -> *) a.
MonadError e m =>
(e -> m a) -> m a -> m a
handleError ([TypeCheckedOp]
-> [View' TypeCheckedOp] -> TCError -> TypeCheck SomeContract
forall a.
[TypeCheckedOp] -> [View' TypeCheckedOp] -> TCError -> TypeCheck a
onFailedFullTypeCheck [SomeInstr '[ 'TPair t t] -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr '[ 'TPair t t]
instr] ((View' ExpandedOp -> SomeView t -> View' TypeCheckedOp)
-> [View' ExpandedOp] -> [SomeView t] -> [View' TypeCheckedOp]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith View' ExpandedOp -> SomeView t -> View' TypeCheckedOp
forall op (st :: T). View' op -> SomeView st -> View' TypeCheckedOp
someViewToOp [View' ExpandedOp]
uViews [SomeView t]
views)) (ReaderT
   TypeCheckEnv
   (ReaderT TypeCheckOptions (ExceptT TCError Identity))
   SomeContract
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ do
            -- match contract code with contract signature, construct contract
            let cStoreNotes :: Notes t
cStoreNotes = Notes t
storageNote
            ParamNotes t
cParamNotes <-
              Either TCError (ParamNotes t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (ParamNotes t)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError (ParamNotes t)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (ParamNotes t))
-> Either TCError (ParamNotes t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (ParamNotes t)
forall a b. (a -> b) -> a -> b
$
              Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)
forall (t :: T).
Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)
mkParamNotes Notes t
paramNote RootAnn
rootAnn Either ParamEpError (ParamNotes t)
-> (ParamEpError -> TCError) -> Either TCError (ParamNotes t)
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst`
                  (Text -> Maybe TCTypeError -> TCError
TCContractError Text
"invalid parameter declaration: " (Maybe TCTypeError -> TCError)
-> (ParamEpError -> Maybe TCTypeError) -> ParamEpError -> TCError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> (ParamEpError -> TCTypeError)
-> ParamEpError
-> Maybe TCTypeError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParamEpError -> TCTypeError
IllegalParamDecl)
            let cEntriesOrder :: EntriesOrder
cEntriesOrder = EntriesOrder
entriesOrder
            ViewsSet' Instr t
cViews <- Either TCError (ViewsSet' Instr t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (ViewsSet' Instr t)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError (ViewsSet' Instr t)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (ViewsSet' Instr t))
-> Either TCError (ViewsSet' Instr t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (ViewsSet' Instr t)
forall a b. (a -> b) -> a -> b
$
              [SomeView t] -> Either ViewsSetError (ViewsSet' Instr t)
forall (instr :: [T] -> [T] -> *) (st :: T).
[SomeView' instr st] -> Either ViewsSetError (ViewsSet' instr st)
mkViewsSet [SomeView t]
views Either ViewsSetError (ViewsSet' Instr t)
-> (ViewsSetError -> TCError) -> Either TCError (ViewsSet' Instr t)
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` \ViewsSetError
e -> Text -> Maybe TCTypeError -> TCError
TCContractError (ViewsSetError -> Text
forall a b. (Buildable a, FromBuilder b) => a -> b
pretty ViewsSetError
e) Maybe TCTypeError
forall a. Maybe a
Nothing
            case SomeInstrOut '[ 'TPair t t]
instrOut of
              Instr '[ 'TPair t t] out
instr' ::: HST out
out -> Either TCError SomeContract
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError SomeContract
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      SomeContract)
-> Either TCError SomeContract
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ do
                case forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @('TPair ('TList 'TOperation) st) HST out
out of
                  Right out :~: '[ 'TPair ('TList 'TOperation) t]
Refl ->
                    SomeContract -> Either TCError SomeContract
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeContract -> Either TCError SomeContract)
-> SomeContract -> Either TCError SomeContract
forall a b. (a -> b) -> a -> b
$ Contract t t -> SomeContract
forall (cp :: T) (st :: T). Contract cp st -> SomeContract
SomeContract Contract :: forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode' instr cp st
-> ParamNotes cp
-> Notes st
-> ViewsSet' instr st
-> EntriesOrder
-> Contract' instr cp st
Contract{ cCode :: ContractCode' Instr t t
cCode = Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
-> ContractCode' Instr t t
forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
instr (ContractInp cp st) (ContractOut st)
-> ContractCode' instr cp st
ContractCode Instr '[ 'TPair t t] out
Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
instr', EntriesOrder
Notes t
ViewsSet' Instr t
ParamNotes t
cEntriesOrder :: EntriesOrder
cViews :: ViewsSet' Instr t
cStoreNotes :: Notes t
cParamNotes :: ParamNotes t
cViews :: ViewsSet' Instr t
cEntriesOrder :: EntriesOrder
cParamNotes :: ParamNotes t
cStoreNotes :: Notes t
.. }
                  Left TCTypeError
err ->
                    TCError -> Either TCError SomeContract
forall a b. a -> Either a b
Left (TCError -> Either TCError SomeContract)
-> TCError -> Either TCError SomeContract
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"contract output type violates convention:" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
err
              AnyOutInstr forall (out :: [T]). Instr '[ 'TPair t t] out
instr' ->
                SomeContract
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeContract
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      SomeContract)
-> SomeContract
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ Contract t t -> SomeContract
forall (cp :: T) (st :: T). Contract cp st -> SomeContract
SomeContract Contract :: forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode' instr cp st
-> ParamNotes cp
-> Notes st
-> ViewsSet' instr st
-> EntriesOrder
-> Contract' instr cp st
Contract{ cCode :: ContractCode' Instr t t
cCode = Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
-> ContractCode' Instr t t
forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
instr (ContractInp cp st) (ContractOut st)
-> ContractCode' instr cp st
ContractCode Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
forall (out :: [T]). Instr '[ 'TPair t t] out
instr', EntriesOrder
Notes t
ViewsSet' Instr t
ParamNotes t
cEntriesOrder :: EntriesOrder
cViews :: ViewsSet' Instr t
cStoreNotes :: Notes t
cParamNotes :: ParamNotes t
cViews :: ViewsSet' Instr t
cEntriesOrder :: EntriesOrder
cParamNotes :: ParamNotes t
cStoreNotes :: Notes t
.. }

  where
    hasTypeError :: forall (t :: T) a. SingI t => Text -> BadTypeForScope -> TypeCheck a
    hasTypeError :: forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError Text
name BadTypeForScope
reason = TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      a)
-> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall a b. (a -> b) -> a -> b
$
      Text -> Maybe TCTypeError -> TCError
TCContractError (Text
"contract " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
name Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" type error") (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$
      TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope (forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) BadTypeForScope
reason

    onFailedCodeTypeCheck :: [TypeCheckedOp] -> TCError -> TypeCheck a
    onFailedCodeTypeCheck :: forall a. [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedCodeTypeCheck [TypeCheckedOp]
ops TCError
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TCError -> Contract' TypeCheckedOp -> TCError
TCIncompletelyTyped TCError
err Contract :: forall op.
ParameterType
-> Ty -> [op] -> EntriesOrder -> [View' op] -> Contract' op
U.Contract
             { contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
             , contractStorage :: Ty
contractStorage = Ty
mStorage
             , contractCode :: [TypeCheckedOp]
contractCode = [TypeCheckedOp]
ops
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             , contractViews :: [View' TypeCheckedOp]
contractViews = []
             }
        else TCError
err

    onFailedFullTypeCheck :: [TypeCheckedOp] -> [U.View' TypeCheckedOp] -> TCError -> TypeCheck a
    onFailedFullTypeCheck :: forall a.
[TypeCheckedOp] -> [View' TypeCheckedOp] -> TCError -> TypeCheck a
onFailedFullTypeCheck [TypeCheckedOp]
ops [View' TypeCheckedOp]
views TCError
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TCError -> Contract' TypeCheckedOp -> TCError
TCIncompletelyTyped TCError
err Contract :: forall op.
ParameterType
-> Ty -> [op] -> EntriesOrder -> [View' op] -> Contract' op
U.Contract
             { contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
             , contractStorage :: Ty
contractStorage = Ty
mStorage
             , contractCode :: [TypeCheckedOp]
contractCode = [TypeCheckedOp]
ops
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             , contractViews :: [View' TypeCheckedOp]
contractViews = [View' TypeCheckedOp]
views
             }
        else TCError
err

typeVerifyView
  :: forall arg ret st.
     (SingI arg, SingI ret, WellTyped st)
  => Notes st -> U.View -> TypeCheckResult (View arg st ret)
typeVerifyView :: forall (arg :: T) (ret :: T) (st :: T).
(SingI arg, SingI ret, WellTyped st) =>
Notes st -> View' ExpandedOp -> TypeCheckResult (View arg st ret)
typeVerifyView Notes st
notes View' ExpandedOp
v = do
  SomeView (tcView :: View' Instr arg st ret
tcView@View{} :: View arg' st' ret') <-
    TypeCheckMode
-> TypeCheck (SomeView' Instr st)
-> TypeCheckResult (SomeView' Instr st)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck TypeCheckMode
TypeCheckTest (TypeCheck (SomeView' Instr st)
 -> TypeCheckResult (SomeView' Instr st))
-> TypeCheck (SomeView' Instr st)
-> TypeCheckResult (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ Notes st -> View' ExpandedOp -> TypeCheck (SomeView' Instr st)
forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
notes View' ExpandedOp
v
  arg :~: arg
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @arg' @arg (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
  st :~: st
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @st' @st (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltStorageType)
  ret :~: ret
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @ret' @ret (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
  View' Instr arg st ret
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError Identity)
     (View' Instr arg st ret)
forall (m :: * -> *) a. Monad m => a -> m a
return View' Instr arg st ret
tcView
  where
    mkErr :: TopLevelType -> MismatchError T -> TypeCheckResult any
    mkErr :: forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
tyDesc MismatchError T
merr =
      TCError -> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT TypeCheckOptions (ExceptT TCError Identity) any)
-> TCError
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"error in view type" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$
          TopLevelType -> MismatchError T -> TCTypeError
UnexpectedTopLevelType TopLevelType
tyDesc MismatchError T
merr

typeCheckViewImpl :: WellTyped st => Notes st -> U.View -> TypeCheck (SomeView st)
typeCheckViewImpl :: forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
storageNote
  uView :: View' ExpandedOp
uView@U.View
  { viewArgument :: forall op. View' op -> Ty
U.viewArgument = AsUType (Notes t
argNote :: Notes param)
  , viewReturn :: forall op. View' op -> Ty
U.viewReturn = AsUType (Notes t
returnNote :: Notes ret)
  , viewCode :: forall op. View' op -> [op]
U.viewCode = [ExpandedOp]
uInstr
  , viewName :: forall op. View' op -> ViewName
U.viewName = ViewName
viewName
  }
  = forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @param ((WellTyped t =>
  MultiReaderT
    '[TypeCheckEnv, TypeCheckOptions]
    (ExceptT TCError Identity)
    (SomeView' Instr st))
 -> MultiReaderT
      '[TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      (SomeView' Instr st))
-> (WellTyped t =>
    MultiReaderT
      '[TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      (SomeView' Instr st))
-> MultiReaderT
     '[TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @ret ((WellTyped t =>
  MultiReaderT
    '[TypeCheckEnv, TypeCheckOptions]
    (ExceptT TCError Identity)
    (SomeView' Instr st))
 -> MultiReaderT
      '[TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      (SomeView' Instr st))
-> (WellTyped t =>
    MultiReaderT
      '[TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      (SomeView' Instr st))
-> MultiReaderT
     '[TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ do
    let inp :: HST '[ 'TPair t st]
inp = (Sing t -> Sing st -> SingT ('TPair t st)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
argNote) (Notes st -> Sing st
forall (t :: T). Notes t -> Sing t
notesSing Notes st
storageNote), Dict (WellTyped ('TPair t st))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair t st), Dict (WellTyped ('TPair t st)))
-> HST '[] -> HST '[ 'TPair t st]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil
    Dict (ViewableScope t)
Dict <-
      forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope param)
      Either BadTypeForScope (Dict (ViewableScope t))
-> (Either BadTypeForScope (Dict (ViewableScope t))
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Dict (ViewableScope t)))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Dict (ViewableScope t)))
-> (Dict (ViewableScope t)
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @param Text
"parameter") Dict (ViewableScope t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    Dict (ViewableScope t)
Dict <-
      forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope ret)
      Either BadTypeForScope (Dict (ViewableScope t))
-> (Either BadTypeForScope (Dict (ViewableScope t))
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Dict (ViewableScope t)))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Dict (ViewableScope t)))
-> (Dict (ViewableScope t)
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @ret Text
"return") Dict (ViewableScope t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    TypeCheckedSeq '[ 'TPair t st]
codeRes <-
      TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (TypeCheckedSeq '[ 'TPair t st])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (TypeCheckedSeq '[ 'TPair t st])
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (TypeCheckedSeq '[ 'TPair t st]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (TypeCheckedSeq '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
      ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq '[ 'TPair t st])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
     (ExceptT TCError Identity)
     (TypeCheckedSeq '[ 'TPair t st])
forall (m :: * -> *) e a.
MonadMultiReaderT m Identity =>
m a -> ChangeMultiReaderBase m (Except e) a
liftNoExcept (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq '[ 'TPair t st])
 -> ChangeMultiReaderBase
      (ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
      (ExceptT TCError Identity)
      (TypeCheckedSeq '[ 'TPair t st]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[ 'TPair t st])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
     (ExceptT TCError Identity)
     (TypeCheckedSeq '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
      TcInstrHandler
-> [ExpandedOp]
-> HST '[ 'TPair t st]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t st])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr [ExpandedOp]
uInstr HST '[ 'TPair t st]
inp
    HST '[ 'TPair t st]
_ :/ SomeInstrOut '[ 'TPair t st]
instrOut <-
      ([TypeCheckedOp]
 -> TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (SomeInstr '[ 'TPair t st]))
-> (SomeInstr '[ 'TPair t st]
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (SomeInstr '[ 'TPair t st]))
-> TypeCheckedSeq '[ 'TPair t st]
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr '[ 'TPair t st])
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither (View' ExpandedOp
-> [TypeCheckedOp]
-> TCError
-> TypeCheck (SomeInstr '[ 'TPair t st])
forall a.
View' ExpandedOp -> [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedViewsTypeCheck View' ExpandedOp
uView) SomeInstr '[ 'TPair t st]
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr '[ 'TPair t st])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq '[ 'TPair t st]
codeRes

    let vName :: ViewName
vName = ViewName
viewName
        vArgument :: Notes t
vArgument = Notes t
argNote
        vReturn :: Notes t
vReturn = Notes t
returnNote
    case SomeInstrOut '[ 'TPair t st]
instrOut of
      Instr '[ 'TPair t st] out
instr ::: HST out
out -> Either TCError (SomeView' Instr st)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeView' Instr st)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither do
        out :~: '[t]
Refl <- forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @ret HST out
out
          Either TCTypeError (out :~: '[t])
-> (TCTypeError -> TCError) -> Either TCError (out :~: '[t])
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` (Text -> ViewName -> Maybe TCTypeError -> TCError
TCViewError Text
"view return type mismatch:" ViewName
viewName (Maybe TCTypeError -> TCError)
-> (TCTypeError -> Maybe TCTypeError) -> TCTypeError -> TCError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just)
        SomeView' Instr st -> Either TCError (SomeView' Instr st)
forall (m :: * -> *) a. Monad m => a -> m a
return (SomeView' Instr st -> Either TCError (SomeView' Instr st))
-> SomeView' Instr st -> Either TCError (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ View' Instr t st t -> SomeView' Instr st
forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> SomeView' instr st
SomeView View :: forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
(ViewableScope arg, SingI st, ViewableScope ret) =>
ViewName
-> Notes arg
-> Notes ret
-> ViewCode' instr arg st ret
-> View' instr arg st ret
View{ vCode :: ViewCode' Instr t st t
vCode = Instr '[ 'TPair t st] out
ViewCode' Instr t st t
instr, ViewName
Notes t
Notes t
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
.. }
      AnyOutInstr forall (out :: [T]). Instr '[ 'TPair t st] out
instr ->
        SomeView' Instr st
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeView' Instr st)
forall (m :: * -> *) a. Monad m => a -> m a
return (SomeView' Instr st
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (SomeView' Instr st))
-> SomeView' Instr st
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ View' Instr t st t -> SomeView' Instr st
forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> SomeView' instr st
SomeView View :: forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
(ViewableScope arg, SingI st, ViewableScope ret) =>
ViewName
-> Notes arg
-> Notes ret
-> ViewCode' instr arg st ret
-> View' instr arg st ret
View{ vCode :: ViewCode' Instr t st t
vCode = ViewCode' Instr t st t
forall (out :: [T]). Instr '[ 'TPair t st] out
instr, ViewName
Notes t
Notes t
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
.. }

  where
    onFailedViewsTypeCheck
      :: U.View -> [TypeCheckedOp] -> TCError -> TypeCheck a
    onFailedViewsTypeCheck :: forall a.
View' ExpandedOp -> [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedViewsTypeCheck View' ExpandedOp
v [TypeCheckedOp]
viewOps TCError
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TCError -> View' TypeCheckedOp -> TCError
TCIncompletelyTypedView TCError
err View' ExpandedOp
v{ viewCode :: [TypeCheckedOp]
U.viewCode = [TypeCheckedOp]
viewOps }
        else TCError
err

    hasTypeError :: forall (t :: T) a. SingI t => Text -> BadTypeForScope -> TypeCheck a
    hasTypeError :: forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError Text
desc BadTypeForScope
reason = TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      a)
-> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall a b. (a -> b) -> a -> b
$
      Text -> ViewName -> Maybe TCTypeError -> TCError
TCViewError (Text
desc Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" type error in view") ViewName
viewName (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$
      TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope (forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) BadTypeForScope
reason

typeCheckViewsImpl
  :: (WellTyped st)
  => U.Contract' TypeCheckedOp -> Notes st -> [U.View] -> TypeCheck [SomeView st]
typeCheckViewsImpl :: forall (st :: T).
WellTyped st =>
Contract' TypeCheckedOp
-> Notes st -> [View' ExpandedOp] -> TypeCheck [SomeView st]
typeCheckViewsImpl Contract' TypeCheckedOp
tcCotract Notes st
storageNote [View' ExpandedOp]
cViews =
  let myfoldM :: t a -> b -> (b -> a -> m b) -> m b
myfoldM t a
l b
acc b -> a -> m b
f = (b -> a -> m b) -> b -> t a -> m b
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM b -> a -> m b
f b
acc t a
l in
  (Seq (View' ExpandedOp, SomeView st) -> [SomeView st])
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Seq (View' ExpandedOp, SomeView st))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     [SomeView st]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((View' ExpandedOp, SomeView st) -> SomeView st)
-> [(View' ExpandedOp, SomeView st)] -> [SomeView st]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (View' ExpandedOp, SomeView st) -> SomeView st
forall a b. (a, b) -> b
snd ([(View' ExpandedOp, SomeView st)] -> [SomeView st])
-> (Seq (View' ExpandedOp, SomeView st)
    -> [(View' ExpandedOp, SomeView st)])
-> Seq (View' ExpandedOp, SomeView st)
-> [SomeView st]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq (View' ExpandedOp, SomeView st)
-> [(View' ExpandedOp, SomeView st)]
forall t. Container t => t -> [Element t]
toList) (ReaderT
   TypeCheckEnv
   (ReaderT TypeCheckOptions (ExceptT TCError Identity))
   (Seq (View' ExpandedOp, SomeView st))
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      [SomeView st])
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Seq (View' ExpandedOp, SomeView st))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     [SomeView st]
forall a b. (a -> b) -> a -> b
$ [View' ExpandedOp]
-> Seq (View' ExpandedOp, SomeView st)
-> (Seq (View' ExpandedOp, SomeView st)
    -> View' ExpandedOp
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Seq (View' ExpandedOp, SomeView st)))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Seq (View' ExpandedOp, SomeView st))
forall {t :: * -> *} {m :: * -> *} {a} {b}.
(Foldable t, Monad m) =>
t a -> b -> (b -> a -> m b) -> m b
myfoldM [View' ExpandedOp]
cViews (forall a. Seq a
forall {st :: T}. Seq (View' ExpandedOp, SomeView st)
Seq.Empty :: Seq (U.View, SomeView st))
    \Seq (View' ExpandedOp, SomeView st)
processedViews View' ExpandedOp
uView -> do
      SomeView st
resView <- Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
storageNote View' ExpandedOp
uView
      pure $ Seq (View' ExpandedOp, SomeView st)
processedViews Seq (View' ExpandedOp, SomeView st)
-> (View' ExpandedOp, SomeView st)
-> Seq (View' ExpandedOp, SomeView st)
forall a. Seq a -> a -> Seq a
|> (View' ExpandedOp
uView, SomeView st
resView)
      ReaderT
  TypeCheckEnv
  (ReaderT TypeCheckOptions (ExceptT TCError Identity))
  (Seq (View' ExpandedOp, SomeView st))
-> (TCError
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions (ExceptT TCError Identity))
         (Seq (View' ExpandedOp, SomeView st)))
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Seq (View' ExpandedOp, SomeView st))
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` \case
        TCIncompletelyTypedView TCError
err View' TypeCheckedOp
view' ->
          let tcViews :: Seq (View' TypeCheckedOp)
tcViews = ((View' ExpandedOp, SomeView st) -> View' TypeCheckedOp)
-> Seq (View' ExpandedOp, SomeView st) -> Seq (View' TypeCheckedOp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map ((View' ExpandedOp -> SomeView st -> View' TypeCheckedOp)
-> (View' ExpandedOp, SomeView st) -> View' TypeCheckedOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry View' ExpandedOp -> SomeView st -> View' TypeCheckedOp
forall op (st :: T). View' op -> SomeView st -> View' TypeCheckedOp
someViewToOp) Seq (View' ExpandedOp, SomeView st)
processedViews
          in Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp
-> TCError
-> TypeCheck (Seq (View' ExpandedOp, SomeView st))
forall a.
Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp -> TCError -> TypeCheck a
onFailedViewsTypeCheck Seq (View' TypeCheckedOp)
tcViews View' TypeCheckedOp
view' TCError
err
        TCError
err -> TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Seq (View' ExpandedOp, SomeView st))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError TCError
err
  where
    onFailedViewsTypeCheck
      :: Seq (U.View' TypeCheckedOp) -> U.View' TypeCheckedOp -> TCError -> TypeCheck a
    onFailedViewsTypeCheck :: forall a.
Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp -> TCError -> TypeCheck a
onFailedViewsTypeCheck Seq (View' TypeCheckedOp)
processedViews View' TypeCheckedOp
v TCError
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TCError
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TCError -> Contract' TypeCheckedOp -> TCError
TCIncompletelyTyped TCError
err Contract' TypeCheckedOp
tcCotract
             { contractViews :: [View' TypeCheckedOp]
U.contractViews = Seq (View' TypeCheckedOp) -> [Element (Seq (View' TypeCheckedOp))]
forall t. Container t => t -> [Element t]
toList (Seq (View' TypeCheckedOp)
processedViews Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp -> Seq (View' TypeCheckedOp)
forall a. Seq a -> a -> Seq a
|> View' TypeCheckedOp
v)
             }
        else TCError
err

-- | Function @typeCheckList@ converts list of Michelson instructions
-- given in representation from @Morley.Michelson.Type@ module to representation
-- in strictly typed GADT.
--
-- Types are checked along the way which is necessary to construct a
-- strictly typed value.
--
-- As a second argument, @typeCheckList@ accepts input stack type representation.
typeCheckList
  :: (SingI inp)
  => [U.ExpandedOp]
  -> HST inp
  -> TypeCheck (SomeInstr inp)
typeCheckList :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheck (SomeInstr inp)
typeCheckList = ReaderT
  TypeCheckEnv
  (ReaderT TypeCheckOptions Identity)
  (TypeCheckedSeq inp)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr inp)
forall (m :: * -> *) (m' :: * -> *) (inp :: [T]).
(MonadMultiReaderT m Identity,
 m' ~ ChangeMultiReaderBase m (ExceptT TCError Identity),
 MonadError TCError m') =>
m (TypeCheckedSeq inp) -> m' (SomeInstr inp)
throwingTCError (ReaderT
   TypeCheckEnv
   (ReaderT TypeCheckOptions Identity)
   (TypeCheckedSeq inp)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (SomeInstr inp))
-> ([ExpandedOp]
    -> HST inp
    -> ReaderT
         TypeCheckEnv
         (ReaderT TypeCheckOptions Identity)
         (TypeCheckedSeq inp))
-> [ExpandedOp]
-> HST inp
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (SomeInstr inp)
forall a b c. SuperComposition a b c => a -> b -> c
... [ExpandedOp]
-> HST inp
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions Identity)
     (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept

-- | Function @typeCheckListNoExcept@ converts list of Michelson instructions
-- given in representation from @Morley.Michelson.Type@ module to representation in a
-- partially typed tree. See @TypeCheckedSeq@ and @TypeCheckedOp@.
--
-- Types are checked along the way. It is necessary to embed well typed node as
-- well as type checking errors into the tree.
typeCheckListNoExcept
  :: (SingI inp)
  => [U.ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept = TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions Identity)
     (TypeCheckedSeq inp)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq inp)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions Identity)
      (TypeCheckedSeq inp))
-> ([ExpandedOp]
    -> HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq inp))
-> [ExpandedOp]
-> HST inp
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions Identity)
     (TypeCheckedSeq inp)
forall a b c. SuperComposition a b c => a -> b -> c
... TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr

-- | Function @typeCheckValue@ converts a single Michelson value
-- given in representation from @Morley.Michelson.Untyped@ module hierarchy to
-- representation in strictly typed GADT.
--
-- @typeCheckValue@ is polymorphic in the expected type of value.
--
-- Type checking algorithm pattern-matches on parse value representation,
-- expected type @t@ and constructs @Value t@ value.
--
-- If there was no match on a given pair of value and expected type,
-- that is interpreted as input of wrong type and type check finishes with
-- error.
typeCheckValue
  :: forall t. SingI t
  => U.Value
  -> TypeCheckResult (Value t)
typeCheckValue :: forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeCheckValue Value
value = do
  TypeCheckMode -> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
value, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) Maybe BigMapFinder
forall a. Maybe a
Nothing) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (Value t)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Value t)
forall a b. (a -> b) -> a -> b
$
      Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr Value
value

-- | Simulates the typechecking behavior of the RPC's @/run_code@ endpoint.
--
-- If an integer is found where a big_map is expected,
-- we check if a big_map exists with that ID.
-- If it does, and if the big_map's value and key have the expected types, we replace the
-- big_map ID with the corresponding big_map value.
typeCheckValueRunCodeCompat :: forall t. SingI t => BigMapFinder -> U.Value -> TypeCheckResult (Value t)
typeCheckValueRunCodeCompat :: forall (t :: T).
SingI t =>
BigMapFinder -> Value -> TypeCheckResult (Value t)
typeCheckValueRunCodeCompat BigMapFinder
bigMapFinder Value
val =
  TypeCheckMode -> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
val, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) (BigMapFinder -> Maybe BigMapFinder
forall a. a -> Maybe a
Just BigMapFinder
bigMapFinder)) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (Value t)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Value t)
forall a b. (a -> b) -> a -> b
$
      Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr Value
val

typeVerifyParameter
  :: SingI t
  => TcOriginatedContracts -> U.Value -> TypeCheckResult (Value t)
typeVerifyParameter :: forall (t :: T).
SingI t =>
TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyParameter TcOriginatedContracts
originatedContracts = Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType (TcOriginatedContracts -> Maybe TcOriginatedContracts
forall a. a -> Maybe a
Just TcOriginatedContracts
originatedContracts)

typeVerifyStorage
  :: SingI t
  => U.Value -> TypeCheckResult (Value t)
typeVerifyStorage :: forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeVerifyStorage = Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType Maybe TcOriginatedContracts
forall a. Maybe a
Nothing

typeVerifyTopLevelType
  :: forall t. SingI t
  => Maybe TcOriginatedContracts -> U.Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType :: forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType Maybe TcOriginatedContracts
mOriginatedContracts Value
valueU =
  TypeCheckMode -> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
valueU, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) Maybe BigMapFinder
forall a. Maybe a
Nothing) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$ TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (Value t)
 -> ReaderT
      TypeCheckEnv
      (ReaderT TypeCheckOptions (ExceptT TCError Identity))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     (Value t)
forall a b. (a -> b) -> a -> b
$
    Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
mOriginatedContracts TcInstrHandler
typeCheckInstr Value
valueU

-- | Like 'typeCheckValue', but for values to be used as parameter.
--
-- Also accepts a 'TcOriginatedContracts' in order to be able to type-check
-- @contract p@ values (which can only be part of a parameter).
typeCheckParameter
  :: TcOriginatedContracts -> U.Ty -> U.Value -> TypeCheckResult SomeValue
typeCheckParameter :: TcOriginatedContracts -> Ty -> Value -> TypeCheckResult SomeValue
typeCheckParameter TcOriginatedContracts
originatedContracts = Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult SomeValue
typeCheckTopLevelType (TcOriginatedContracts -> Maybe TcOriginatedContracts
forall a. a -> Maybe a
Just TcOriginatedContracts
originatedContracts)

-- | Like 'typeCheckValue', but for values to be used as storage.
typeCheckStorage
  :: U.Ty -> U.Value -> TypeCheckResult SomeValue
typeCheckStorage :: Ty -> Value -> TypeCheckResult SomeValue
typeCheckStorage = Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult SomeValue
typeCheckTopLevelType Maybe TcOriginatedContracts
forall a. Maybe a
Nothing

typeCheckTopLevelType
  :: Maybe TcOriginatedContracts -> U.Ty -> U.Value -> TypeCheckResult SomeValue
typeCheckTopLevelType :: Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult SomeValue
typeCheckTopLevelType Maybe TcOriginatedContracts
mOriginatedContracts Ty
typeU Value
valueU =
  Demote T
-> (forall (a :: T). Sing a -> TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall k r.
SingKind k =>
Demote k -> (forall (a :: k). Sing a -> r) -> r
withSomeSing (Ty -> T
fromUType Ty
typeU) ((forall (a :: T). Sing a -> TypeCheckResult SomeValue)
 -> TypeCheckResult SomeValue)
-> (forall (a :: T). Sing a -> TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall a b. (a -> b) -> a -> b
$ \(Sing a
s :: Sing t) ->
    Sing a
-> (SingI a => TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a => TypeCheckResult SomeValue)
 -> TypeCheckResult SomeValue)
-> (SingI a => TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall a b. (a -> b) -> a -> b
$ Value a -> SomeValue
forall (t :: T). SingI t => Value t -> SomeValue
SomeValue (Value a -> SomeValue)
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) (Value a)
-> TypeCheckResult SomeValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType @t Maybe TcOriginatedContracts
mOriginatedContracts Value
valueU

-- | Helper data type we use to typecheck DUPN.
data TCDupNHelper inp where
  TCDupNHelper ::
    forall (n :: Peano) inp out a.
    (SingI out, ConstraintDUPN n inp out a, DupableScope a) =>
    PeanoNatural n -> HST out -> TCDupNHelper inp

-- | Helper data type we use to typecheck DROPN.
data TCDropHelper inp where
  TCDropHelper ::
    forall (n :: Peano) inp out.
    (SingI out, LongerOrSameLength inp n, Drop n inp ~ out) =>
    PeanoNatural n -> HST out -> TCDropHelper inp

-- | Helper data type we use to typecheck DIG.
data TCDigHelper inp where
  TCDigHelper ::
    forall (n :: Peano) inp out a.
    (SingI out, ConstraintDIG n inp out a) =>
    PeanoNatural n -> HST out -> TCDigHelper inp

-- | Helper data type we use to typecheck DUG.
data TCDugHelper inp where
  TCDugHelper ::
    forall (n :: Peano) inp out a.
    (SingI out, ConstraintDUG n inp out a) =>
    PeanoNatural n -> HST out -> TCDugHelper inp

-- | Helper data type we use to typecheck PAIRN.
--
-- It holds all the necessary data to construct a typed PAIRN
-- instruction once we're done traversing the stack.
data TCPairNHelper inp where
  TCPairNHelper ::
    forall (n :: Peano) (inp :: [T]).
    (SingI (PairN n inp), ConstraintPairN n inp) =>
    PeanoNatural n -> HST (PairN n inp) -> TCPairNHelper inp

-- | Helper data type we use to typecheck UNPAIRN.
--
-- It holds all the necessary data to construct a typed UNPAIRN
-- instruction once we're done traversing the pair.
data TCUnpairNHelper (inp :: [T]) where
  TCUnpairNHelper ::
    forall (n :: Peano) (a :: T) (b :: T) (rest :: [T]).
    (SingI (UnpairN n ('TPair a b) ++ rest), ConstraintUnpairN n ('TPair a b)) =>
    PeanoNatural n -> HST (UnpairN n ('TPair a b) ++ rest) -> TCUnpairNHelper ('TPair a b : rest)

-- | Helper data type we use to typecheck GETN.
--
-- It holds all the necessary data to construct a typed GETN
-- instruction once we're done traversing the pair.
data TCGetNHelper (inp :: [T]) where
  TCGetNHelper ::
    forall (ix :: Peano) (pair :: T) (rest :: [T]).
    (SingI (GetN ix pair ': rest), ConstraintGetN ix pair) =>
    PeanoNatural ix -> HST (GetN ix pair ': rest) -> TCGetNHelper (pair : rest)

-- | Helper data type we use to typecheck UPDATEN.
--
-- It holds all the necessary data to construct a typed UPDATEN
-- instruction once we're done traversing the pair.
data TCUpdateNHelper (inp :: [T]) where
  TCUpdateNHelper ::
    forall (ix :: Peano) (val :: T) (pair :: T) (rest :: [T]).
    (SingI (UpdateN ix val pair ': rest), ConstraintUpdateN ix pair) =>
    PeanoNatural ix -> HST (UpdateN ix val pair ': rest) -> TCUpdateNHelper (val : pair : rest)

-- | Helper function to convert a simple throwing typechecking action into a
-- non-throwing one, embedding possible errors into the type checking tree.
workOnInstr
  :: U.ExpandedInstr
  -> TypeCheckInstr (SomeInstr s)
  -> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr :: forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
instr = (TCError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
      Identity
      (TypeCheckedSeq s))
-> (SomeInstr s
    -> MultiReaderT
         '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
         Identity
         (TypeCheckedSeq s))
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (SomeInstr s)
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     Identity
     (TypeCheckedSeq s)
forall a b.
(TCError -> TypeCheckInstrNoExcept a)
-> (b -> TypeCheckInstrNoExcept a)
-> TypeCheckInstr b
-> TypeCheckInstrNoExcept a
tcEither
  (\TCError
err -> TypeCheckedSeq s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq s
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq s))
-> TypeCheckedSeq s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq s)
forall a b. (a -> b) -> a -> b
$ TCError -> [IllTypedInstr] -> TypeCheckedSeq s
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq TCError
err [ExpandedOp -> IllTypedInstr
NonTypedInstr (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> ExpandedOp
U.PrimEx ExpandedInstr
instr])
  (TypeCheckedSeq s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq s
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq s))
-> (SomeInstr s -> TypeCheckedSeq s)
-> SomeInstr s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeInstr s -> TypeCheckedSeq s
forall (inp :: [T]). SomeInstr inp -> TypeCheckedSeq inp
WellTypedSeq)

-- | Less verbose version of `typeCheckImpl typeCheckInstr`.
tcList
  :: (SingI inp)
  => [U.ExpandedOp] -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList = TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr

-- | Function @typeCheckInstr@ converts a single Michelson instruction
-- given in representation from @Morley.Michelson.Type@ module to representation
-- in strictly typed GADT.
--
-- As a second argument, @typeCheckInstr@ accepts input stack type representation.
--
-- Type checking algorithm pattern-matches on given instruction, input stack
-- type and constructs strictly typed GADT value, checking necessary type
-- equalities when necessary.
--
-- If there was no match on a given pair of instruction and input stack,
-- that is interpreted as input of wrong type and type check finishes with
-- error.
typeCheckInstr :: TcInstrHandler
typeCheckInstr :: TcInstrHandler
typeCheckInstr ExpandedInstr
uInstr HST inp
inp = case (ExpandedInstr
uInstr, HST inp
inp) of
  (U.EXT ExtInstrAbstract ExpandedOp
ext, HST inp
si) ->
    TcInstrHandler
-> ExtInstrAbstract ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
SingI s =>
TcInstrHandler
-> ExtInstrAbstract ExpandedOp
-> HST s
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
typeCheckExt TcInstrHandler
typeCheckInstr ExtInstrAbstract ExpandedOp
ext HST inp
si

  (ExpandedInstr
U.DROP, (SingT x, Dict (WellTyped x))
_ ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (x : xs) xs
forall (a :: T) (out :: [T]). Instr (a : out) out
DROP Instr (x : xs) xs -> HST xs -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs

  (ExpandedInstr
U.DROP, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.DROPN Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDropHelper inp)
-> (TCDropHelper inp -> SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCDropHelper PeanoNatural n
s HST out
out -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp (Drop n inp)
forall (n :: Nat) (inp :: [T]).
RequireLongerOrSameLength inp n =>
PeanoNatural n -> Instr inp (Drop n inp)
DROPN PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDropHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCDropHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDropHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
0, HST inp
i) -> TCDropHelper inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDropHelper inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDropHelper inp
forall (n :: Nat) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp n, Drop n inp ~ out) =>
PeanoNatural n -> HST out -> TCDropHelper inp
TCDropHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)

        (Word
_, HST inp
SNil) -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDropHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

        (Word
n, ((SingT x, Dict (WellTyped x))
_ ::& HST xs
iTail)) -> do
          Word -> HST xs -> TypeCheckInstr (TCDropHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDropHelper xs)
-> (TCDropHelper xs -> TCDropHelper inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDropHelper inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDropHelper PeanoNatural n
s HST out
out) -> PeanoNatural ('S n) -> HST out -> TCDropHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp n, Drop n inp ~ out) =>
PeanoNatural n -> HST out -> TCDropHelper inp
TCDropHelper (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) HST out
out

  (U.DUP VarAnn
vn1, a :: (SingT x, Dict (WellTyped x))
a@(SingT x
n :: SingT t, Dict (WellTyped x)
d) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Dict (DupableScope x)
Dict <-
      forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (DupableScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
      forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope t)
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : xs) (x : x : xs)
forall (a :: T) (s :: [T]).
DupableScope a =>
AnnVar -> Instr (a : s) (a : a : s)
AnnDUP (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn1) Instr (x : xs) (x : x : xs)
-> HST (x : x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x
n, Dict (WellTyped x)
d) (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))

  (U.DUP VarAnn
_vn, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.DUPN VarAnn
vn Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDupNHelper inp)
-> (TCDupNHelper inp -> SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural n -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (a :: T).
(ConstraintDUPN n inp out a, DupableScope a) =>
AnnVar -> PeanoNatural n -> Instr inp out
AnnDUPN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDupNHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCDupNHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDupNHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
_, HST inp
SNil) -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDupNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

        (Word
0, HST inp
_) ->
          ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDupNHelper inp)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"'DUP n' expects n > 0")

        -- Don't bind whatever variable annotation is here because DUP n doesn't
        -- duplicate variable annotations. This is consistent with tezos-client.
        (Word
1, i :: HST inp
i@((SingT x
an :: SingT a, Dict (WellTyped x)
dict) ::& HST xs
_)) -> do
          Dict (DupableScope x)
Dict <-
            forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (DupableScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
            forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope a)
          TCDupNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDupNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural ('S 'Z) -> HST (x : inp) -> TCDupNHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUPN n inp out s, DupableScope s) =>
PeanoNatural n -> HST out -> TCDupNHelper inp
TCDupNHelper PeanoNatural ('S 'Z)
forall (n :: Nat). (n ~ 'S 'Z) => PeanoNatural n
One ((SingT x
an, Dict (WellTyped x)
dict) (SingT x, Dict (WellTyped x)) -> HST inp -> HST (x : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i))

        (Word
n, ((SingT x, Dict (WellTyped x))
b ::& HST xs
iTail)) ->
          Word -> HST xs -> TypeCheckInstr (TCDupNHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDupNHelper xs)
-> (TCDupNHelper xs -> TCDupNHelper inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDupNHelper inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper s :: PeanoNatural n
s@(Succ PeanoNatural m
_) ((SingT x, Dict (WellTyped x))
a ::& HST xs
resTail)) ->
            PeanoNatural ('S ('S (Decrement n)))
-> HST (x : x : xs) -> TCDupNHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUPN n inp out s, DupableScope s) =>
PeanoNatural n -> HST out -> TCDupNHelper inp
TCDupNHelper (PeanoNatural n -> PeanoNatural ('S ('S (Decrement n)))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
resTail)

  (ExpandedInstr
U.SWAP, (SingT x, Dict (WellTyped x))
a ::& (SingT x, Dict (WellTyped x))
b ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (x : x : xs) (x : x : xs)
forall (a :: T) (b :: T) (s :: [T]). Instr (a : b : s) (b : a : s)
SWAP Instr (x : x : xs) (x : x : xs)
-> HST (x : x : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))

  (ExpandedInstr
U.SWAP, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.DIG Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDigHelper inp)
-> (TCDigHelper inp -> SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDigHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (a :: T).
ConstraintDIG n inp out a =>
PeanoNatural n -> Instr inp out
DIG PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDigHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCDigHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDigHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        -- Even 'DIG 0' is invalid on empty stack (so it is not strictly `Nop`).
        (Word
_, HST inp
SNil) -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDigHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

        (Word
0, i :: HST inp
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_)) -> TCDigHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDigHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDigHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDIG n inp out s) =>
PeanoNatural n -> HST out -> TCDigHelper inp
TCDigHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i (KnownList (x : xs) => TCDigHelper (x : xs))
-> Dict (KnownList inp) -> TCDigHelper (x : xs)
forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
\\ forall (xs :: [T]). SingI xs => Dict (KnownList xs)
forall {k} (xs :: [k]). SingI xs => Dict (KnownList xs)
knownListFromSingI @inp)

        (Word
n, ((SingT x, Dict (WellTyped x))
b ::& HST xs
iTail)) ->
          Word -> HST xs -> TypeCheckInstr (TCDigHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDigHelper xs)
-> (TCDigHelper xs -> TCDigHelper (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDigHelper (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDigHelper PeanoNatural n
s ((SingT x, Dict (WellTyped x))
a ::& HST xs
resTail)) ->
            PeanoNatural ('S n) -> HST (x : x : xs) -> TCDigHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDIG n inp out s) =>
PeanoNatural n -> HST out -> TCDigHelper inp
TCDigHelper (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
resTail)

  (U.DUG Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDugHelper inp)
-> (TCDugHelper inp -> SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDugHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (a :: T).
ConstraintDUG n inp out a =>
PeanoNatural n -> Instr inp out
DUG PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDugHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCDugHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDugHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
0, i :: HST inp
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_)) -> TCDugHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDugHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDugHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUG n inp out s) =>
PeanoNatural n -> HST out -> TCDugHelper inp
TCDugHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)

        (Word
n, ((SingT x, Dict (WellTyped x))
a ::& (SingT x, Dict (WellTyped x))
b ::& HST xs
iTail)) ->
          Word -> HST (x : xs) -> TypeCheckInstr (TCDugHelper (x : xs))
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
iTail) ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDugHelper (x : xs))
-> (TCDugHelper (x : xs) -> TCDugHelper (x : x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCDugHelper (x : x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDugHelper PeanoNatural n
s HST out
resTail) ->
            PeanoNatural ('S n) -> HST (x : out) -> TCDugHelper (x : x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUG n inp out s) =>
PeanoNatural n -> HST out -> TCDugHelper inp
TCDugHelper (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) ((SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST out
resTail)

        -- Two cases:
        -- 1. Input stack is empty.
        -- 2. n > 0 and input stack has exactly 1 item.
        (Word, HST inp)
_ -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCDugHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

  (U.PUSH VarAnn
vn Ty
mt Value
mval, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
nt :: Notes t) -> do
      -- Locally switch 'TypeCheckMode' to 'TypeCheckValue'.
      Value t
val <- (TypeCheckEnv -> TypeCheckEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
forall (n :: Nat) r (m :: * -> *) a.
MultiReader n r m =>
(r -> r) -> m a -> m a
local' ((TypeCheckMode -> Identity TypeCheckMode)
-> TypeCheckEnv -> Identity TypeCheckEnv
Iso' TypeCheckEnv TypeCheckMode
tcModeL ((TypeCheckMode -> Identity TypeCheckMode)
 -> TypeCheckEnv -> Identity TypeCheckEnv)
-> TypeCheckMode -> TypeCheckEnv -> TypeCheckEnv
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
mval, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) Maybe BigMapFinder
forall a. Maybe a
Nothing) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (Value t)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Value t)
forall a b. (a -> b) -> a -> b
$
        forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl @t Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr Value
mval

      Dict (ConstantScope t)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
i) Maybe TypeContext
forall a. Maybe a
Nothing
        (Either BadTypeForScope (Dict (ConstantScope t))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ConstantScope t)))
-> Either BadTypeForScope (Dict (ConstantScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ConstantScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope t)
      case Dict (ConstantScope t)
proofScope of
        Dict (ConstantScope t)
Dict -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped t => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
          HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t] -> Value t -> Instr inp (t : inp)
forall (t :: T) (inp :: [T]).
ConstantScope t =>
Anns '[VarAnn, Notes t] -> Value' Instr t -> Instr inp (t : inp)
AnnPUSH (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
nt) Value t
val Instr inp (t : inp) -> HST (t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
nt, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict) (SingT t, Dict (WellTyped t)) -> HST inp -> HST (t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.SOME TypeAnn
tn VarAnn
vn, (SingT x
an, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn] -> Instr (x : xs) ('TOption x : xs)
forall (a :: T) (s :: [T]).
Anns '[TypeAnn, VarAnn] -> Instr (a : s) ('TOption a : s)
AnnSOME (TypeAnn -> VarAnn -> Anns '[TypeAnn, VarAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 TypeAnn
tn VarAnn
vn) Instr (x : xs) ('TOption x : xs)
-> HST ('TOption x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing x -> SingT ('TOption x)
forall (n :: T). Sing n -> SingT ('TOption n)
STOption Sing x
SingT x
an, Dict (WellTyped ('TOption x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption x), Dict (WellTyped ('TOption x)))
-> HST xs -> HST ('TOption x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))

  (U.SOME TypeAnn
_ VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.NONE TypeAnn
tn VarAnn
vn Ty
elMt, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
elMt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
elNotes :: Notes t) ->
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped t => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t] -> Instr inp ('TOption t : inp)
forall (a :: T) (inp :: [T]).
SingI a =>
Anns '[TypeAnn, VarAnn, Notes a] -> Instr inp ('TOption a : inp)
AnnNONE (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
elNotes) Instr inp ('TOption t : inp)
-> HST ('TOption t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TOption t)
forall (n :: T). Sing n -> SingT ('TOption n)
STOption (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
elNotes), Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption t), Dict (WellTyped ('TOption t)))
-> HST inp -> HST ('TOption t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.UNIT TypeAnn
tn VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn] -> Instr inp ('TUnit : inp)
forall (inp :: [T]).
Anns '[TypeAnn, VarAnn] -> Instr inp ('TUnit : inp)
AnnUNIT (TypeAnn -> VarAnn -> Anns '[TypeAnn, VarAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 TypeAnn
tn VarAnn
vn) Instr inp ('TUnit : inp) -> HST ('TUnit : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TUnit
STUnit, Dict (WellTyped 'TUnit)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TUnit, Dict (WellTyped 'TUnit))
-> HST inp -> HST ('TUnit : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.MIN_BLOCK_TIME [AnyAnn]
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ [AnyAnn] -> Instr inp ('TNat : inp)
forall (inp :: [T]). [AnyAnn] -> Instr inp ('TNat : inp)
AnnMIN_BLOCK_TIME [AnyAnn]
vn Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
STNat, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat))
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.IF_NONE [ExpandedOp]
mp [ExpandedOp]
mq, (STOption (SingT n
asing :: SingT a), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @a ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$
      (forall (s' :: [T]).
 Instr xs s' -> Instr (n : xs) s' -> Instr ('TOption n : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST xs
-> HST (n : xs)
-> HST ('TOption n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
 Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr xs s' -> Instr (n : xs) s' -> Instr ('TOption n : xs) s'
forall (s :: [T]) (out :: [T]) (a :: T).
Instr s out -> Instr (a : s) out -> Instr ('TOption a : s) out
IF_NONE forall op. [op] -> [op] -> InstrAbstract op
U.IF_NONE [ExpandedOp]
mp [ExpandedOp]
mq HST xs
rs ((SingT n
asing, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict) (SingT n, Dict (WellTyped n)) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs) HST inp
HST ('TOption n : xs)
inp

  (U.IF_NONE [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"option 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.IF_NONE [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.PAIR TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn, (SingT x
an :: SingT a, Dict (WellTyped x)
_) ::& (SingT x
bn :: SingT b, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
  TypeCheckInstr (SomeInstr (x : x : xs)))
 -> TypeCheckInstr (SomeInstr (x : x : xs)))
-> (WellTyped ('TPair x x) =>
    TypeCheckInstr (SomeInstr (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, RootAnn, RootAnn]
-> Instr (x : x : xs) ('TPair x x : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[TypeAnn, VarAnn, RootAnn, RootAnn]
-> Instr (a : b : s) ('TPair a b : s)
AnnPAIR (TypeAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Anns '[TypeAnn, VarAnn, RootAnn, RootAnn]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k).
Each '[Typeable] '[a, b, c, d] =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Anns '[Annotation a, Annotation b, Annotation c, Annotation d]
Anns4 TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn) Instr (x : x : xs) ('TPair x x : xs)
-> HST ('TPair x x : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing x -> Sing x -> SingT ('TPair x x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing x
SingT x
an Sing x
SingT x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x x), Dict (WellTyped ('TPair x x)))
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))

  (U.PAIR {}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
  (U.UNPAIR VarAnn
instrVn1 VarAnn
instrVn2 RootAnn
instrFn1 RootAnn
instrFn2, (STPair Sing n1
n1 Sing n2
n2, Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
        HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, VarAnn, RootAnn, RootAnn]
-> Instr ('TPair n1 n2 : xs) (n1 : n2 : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[VarAnn, VarAnn, RootAnn, RootAnn]
-> Instr ('TPair a b : s) (a : b : s)
AnnUNPAIR (VarAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Anns '[VarAnn, VarAnn, RootAnn, RootAnn]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k).
Each '[Typeable] '[a, b, c, d] =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Anns '[Annotation a, Annotation b, Annotation c, Annotation d]
Anns4 VarAnn
instrVn1 VarAnn
instrVn2 RootAnn
instrFn1 RootAnn
instrFn2) Instr ('TPair n1 n2 : xs) (n1 : n2 : xs)
-> HST (n1 : n2 : xs) -> SomeInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
:::
          ( (Sing n1
SingT n1
n1, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1))
-> HST (n2 : xs) -> HST (n1 : n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::&
            (Sing n2
SingT n2
n2, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::&
            HST xs
rs
          )

  (U.UNPAIR {}, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.UNPAIR {}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
  (U.PAIRN VarAnn
varAnn Word
nTotal, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
    Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go Word
nTotal HST inp
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCPairNHelper inp)
-> (TCPairNHelper inp -> SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCPairNHelper PeanoNatural n
s HST (PairN n inp)
out -> HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural n -> Instr inp (PairN n inp)
forall (n :: Nat) (inp :: [T]).
ConstraintPairN n inp =>
AnnVar
-> PeanoNatural n
-> Instr inp (RightComb (Take n inp) : Drop n inp)
AnnPAIRN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
varAnn) PeanoNatural n
s Instr inp (PairN n inp) -> HST (PairN n inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (PairN n inp)
out
    where
      go :: forall inp. Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
      go :: forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go Word
n HST inp
hst
        | Word
n Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
2 =
            ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCPairNHelper inp)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
              (ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"'PAIR n' expects n ≥ 2")
        | Word
n Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
2 =
            case HST inp
hst of
              (SingT x
an :: SingT a, Dict (WellTyped x)
_) ::& (SingT x
bn :: SingT b, Dict (WellTyped x)
_) ::& HST xs
hstTail -> do
                forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
  TypeCheckInstr (TCPairNHelper (x : x : xs)))
 -> TypeCheckInstr (TCPairNHelper (x : x : xs)))
-> (WellTyped ('TPair x x) =>
    TypeCheckInstr (TCPairNHelper (x : x : xs)))
-> TypeCheckInstr (TCPairNHelper (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
                  TCPairNHelper (x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCPairNHelper (x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCPairNHelper (x : x : xs)))
-> TCPairNHelper (x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCPairNHelper (x : x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S 'Z))
-> HST (PairN ('S ('S 'Z)) (x : x : xs))
-> TCPairNHelper (x : x : xs)
forall (n :: Nat) (inp :: [T]).
(SingI (PairN n inp), ConstraintPairN n inp) =>
PeanoNatural n -> HST (PairN n inp) -> TCPairNHelper inp
TCPairNHelper PeanoNatural ('S ('S 'Z))
forall (n :: Nat). (n ~ 'S ('S 'Z)) => PeanoNatural n
Two (HST (PairN ('S ('S 'Z)) (x : x : xs))
 -> TCPairNHelper (x : x : xs))
-> HST (PairN ('S ('S 'Z)) (x : x : xs))
-> TCPairNHelper (x : x : xs)
forall a b. (a -> b) -> a -> b
$
                    (Sing x -> Sing x -> SingT ('TPair x x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing x
SingT x
an Sing x
SingT x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x x), Dict (WellTyped ('TPair x x)))
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hstTail
              HST inp
_ -> MultiReaderT
  '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
  (ExceptT TCError Identity)
  (TCPairNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
        | Bool
otherwise =
            case HST inp
hst of
              (SingT x
an :: SingT a, Dict (WellTyped x)
_) ::& hstTail :: HST xs
hstTail@((SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> do
                Word -> HST xs -> TypeCheckInstr (TCPairNHelper xs)
forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
hstTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCPairNHelper (x : x : xs))
-> (TCPairNHelper (x : x : xs)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (TCPairNHelper (x : x : x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCPairNHelper (x : x : x : xs))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                  TCPairNHelper nSing :: PeanoNatural n
nSing@(Succ (Succ PeanoNatural m
_)) ((SingT x
bn :: SingT b, Dict (WellTyped x)
_) ::& HST xs
hstTail') -> do
                    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
  TypeCheckInstr (TCPairNHelper (x : x : x : xs)))
 -> TypeCheckInstr (TCPairNHelper (x : x : x : xs)))
-> (WellTyped ('TPair x x) =>
    TypeCheckInstr (TCPairNHelper (x : x : x : xs)))
-> TypeCheckInstr (TCPairNHelper (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
                      TCPairNHelper (x : x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCPairNHelper (x : x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCPairNHelper (x : x : x : xs)))
-> TCPairNHelper (x : x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCPairNHelper (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S ('S m)))
-> HST (PairN ('S ('S ('S m))) (x : x : x : xs))
-> TCPairNHelper (x : x : x : xs)
forall (n :: Nat) (inp :: [T]).
(SingI (PairN n inp), ConstraintPairN n inp) =>
PeanoNatural n -> HST (PairN n inp) -> TCPairNHelper inp
TCPairNHelper (PeanoNatural n -> PeanoNatural ('S ('S ('S m)))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
nSing) (HST (PairN ('S ('S ('S m))) (x : x : x : xs))
 -> TCPairNHelper (x : x : x : xs))
-> HST (PairN ('S ('S ('S m))) (x : x : x : xs))
-> TCPairNHelper (x : x : x : xs)
forall a b. (a -> b) -> a -> b
$
                        (Sing x
-> Sing (RightComb (Take n (x : x : xs)))
-> SingT ('TPair x (RightComb (Take n (x : x : xs))))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing x
SingT x
an Sing (RightComb (Take n (x : x : xs)))
SingT x
bn, Dict (WellTyped ('TPair x (RightComb (Take n (x : x : xs)))))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x (RightComb (Take n (x : x : xs)))),
 Dict (WellTyped ('TPair x (RightComb (Take n (x : x : xs))))))
-> HST xs -> HST ('TPair x (RightComb (Take n (x : x : xs))) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hstTail'
              HST inp
_ -> MultiReaderT
  '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
  (ExceptT TCError Identity)
  (TCPairNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

  (U.UNPAIRN Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
  (U.UNPAIRN Word
nTotal, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go Word
nTotal HST inp
HST (x : xs)
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCUnpairNHelper (x : xs))
-> (TCUnpairNHelper (x : xs) -> SomeInstr (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCUnpairNHelper PeanoNatural n
s HST (UnpairN n ('TPair a b) ++ rest)
out ->
        HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n
-> Instr ('TPair a b : xs) (UnpairN n ('TPair a b) ++ xs)
forall (n :: Nat) (pair :: T) (s :: [T]).
ConstraintUnpairN n pair =>
PeanoNatural n -> Instr (pair : s) (UnpairN n pair ++ s)
UNPAIRN PeanoNatural n
s Instr ('TPair a b : xs) (UnpairN n ('TPair a b) ++ xs)
-> HST (UnpairN n ('TPair a b) ++ xs)
-> SomeInstrOut ('TPair a b : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (UnpairN n ('TPair a b) ++ xs)
HST (UnpairN n ('TPair a b) ++ rest)
out
    where
      go :: forall x xs. Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
      go :: forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go Word
n HST (x : xs)
hst
        | Word
n Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
2 =
            ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUnpairNHelper (x : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
              (ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"UNPAIR expects an argument of at least 2.")
        | Word
n Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
2 =
            case HST (x : xs)
hst of
              (STPair Sing n1
aT Sing n2
bT, Dict (WellTyped x)
Dict) ::& HST xs
rest -> do
                TCUnpairNHelper ('TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUnpairNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair n1 n2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCUnpairNHelper ('TPair n1 n2 : xs)))
-> TCUnpairNHelper ('TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUnpairNHelper ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S 'Z))
-> HST (UnpairN ('S ('S 'Z)) ('TPair n1 n2) ++ xs)
-> TCUnpairNHelper ('TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UnpairN n ('TPair out s) ++ s'),
 ConstraintUnpairN n ('TPair out s)) =>
PeanoNatural n
-> HST (UnpairN n ('TPair out s) ++ s')
-> TCUnpairNHelper ('TPair out s : s')
TCUnpairNHelper PeanoNatural ('S ('S 'Z))
forall (n :: Nat). (n ~ 'S ('S 'Z)) => PeanoNatural n
Two (HST (UnpairN ('S ('S 'Z)) ('TPair n1 n2) ++ xs)
 -> TCUnpairNHelper ('TPair n1 n2 : xs))
-> HST (UnpairN ('S ('S 'Z)) ('TPair n1 n2) ++ xs)
-> TCUnpairNHelper ('TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$
                  (Sing n1
SingT n1
aT, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict)
                  (SingT n1, Dict (WellTyped n1))
-> HST (n2 : xs) -> HST (n1 : n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (Sing n2
SingT n2
bT, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict)
                  (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
              HST (x : xs)
_ -> MultiReaderT
  '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
  (ExceptT TCError Identity)
  (TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr a
unexpectedType
        | Bool
otherwise =
            case HST (x : xs)
hst of
              (STPair Sing n1
aT Sing n2
bT, Dict (WellTyped x)
Dict) ::& HST xs
rest -> do
                Word -> HST (n2 : xs) -> TypeCheckInstr (TCUnpairNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) ((Sing n2
SingT n2
bT, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCUnpairNHelper (n2 : xs))
-> (TCUnpairNHelper (n2 : xs)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (TCUnpairNHelper ('TPair n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUnpairNHelper ('TPair n1 n2 : xs))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                  TCUnpairNHelper nSing :: PeanoNatural n
nSing@(Succ (Succ PeanoNatural m
_)) HST (UnpairN n ('TPair a b) ++ rest)
out -> do
                    TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUnpairNHelper ('TPair n1 ('TPair a b) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)))
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUnpairNHelper ('TPair n1 ('TPair a b) : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S ('S m)))
-> HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UnpairN n ('TPair out s) ++ s'),
 ConstraintUnpairN n ('TPair out s)) =>
PeanoNatural n
-> HST (UnpairN n ('TPair out s) ++ s')
-> TCUnpairNHelper ('TPair out s : s')
TCUnpairNHelper (PeanoNatural n -> PeanoNatural ('S ('S ('S m)))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
nSing) (HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
 -> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs))
-> HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
forall a b. (a -> b) -> a -> b
$
                      (Sing n1
SingT n1
aT, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1))
-> HST (UnpairN n ('TPair a b) ++ xs)
-> HST (n1 : (UnpairN n ('TPair a b) ++ xs))
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST (UnpairN n ('TPair a b) ++ xs)
HST (UnpairN n ('TPair a b) ++ rest)
out
              HST (x : xs)
_ -> MultiReaderT
  '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
  (ExceptT TCError Identity)
  (TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr a
unexpectedType

      unexpectedType :: TypeCheckInstr a
      unexpectedType :: forall a. TypeCheckInstr a
unexpectedType = TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     a
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      a)
-> TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     a
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Word -> Text
pairWithElems Word
nTotal Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.CAR VarAnn
vn RootAnn
fn, (STPair Sing n1
lt Sing n2
_, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, RootAnn] -> Instr ('TPair n1 n2 : xs) (n1 : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[VarAnn, RootAnn] -> Instr ('TPair a b : s) (a : s)
AnnCAR (VarAnn -> RootAnn -> Anns '[VarAnn, RootAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 VarAnn
vn RootAnn
fn) Instr ('TPair n1 n2 : xs) (n1 : xs)
-> HST (n1 : xs) -> SomeInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing n1
SingT n1
lt, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CAR VarAnn
_ RootAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.CAR VarAnn
_ RootAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.CDR VarAnn
vn RootAnn
fn, (STPair Sing n1
_ Sing n2
rt, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, RootAnn] -> Instr ('TPair n1 n2 : xs) (n2 : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[VarAnn, RootAnn] -> Instr ('TPair a b : s) (b : s)
AnnCDR (VarAnn -> RootAnn -> Anns '[VarAnn, RootAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 VarAnn
vn RootAnn
fn) Instr ('TPair n1 n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing n2
SingT n2
rt, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CDR VarAnn
_ RootAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.CDR VarAnn
_ RootAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LEFT TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Ty
bMt, (SingT x
an :: SingT l, Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
bMt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
       (TypeCheckedSeq (x : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
bn :: Notes r) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @r ((WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
 -> TypeCheckInstr (SomeInstr (x : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
forall a b. (a -> b) -> a -> b
$ do
        let ns :: SingT ('TOr x t)
ns = Sing x -> Sing t -> SingT ('TOr x t)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TOr n1 n2)
STOr Sing x
SingT x
an (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
bn)
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
-> Instr (x : xs) ('TOr x t : xs)
forall (b :: T) (a :: T) (s :: [T]).
SingI b =>
Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes b]
-> Instr (a : s) ('TOr a b : s)
AnnLEFT (TypeAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Notes t
-> Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k) (t :: T).
(Each '[Typeable] '[a, b, c, d], SingI t) =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Notes t
-> Anns
     '[Annotation a, Annotation b, Annotation c, Annotation d, Notes t]
Anns5' TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Notes t
bn) Instr (x : xs) ('TOr x t : xs)
-> HST ('TOr x t : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOr x t)
ns, Dict (WellTyped ('TOr x t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOr x t), Dict (WellTyped ('TOr x t)))
-> HST xs -> HST ('TOr x t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))

  (U.LEFT {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.RIGHT TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Ty
aMt, (SingT x
bn :: SingT r, Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
aMt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
       (TypeCheckedSeq (x : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
an :: Notes l) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @l ((WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
 -> TypeCheckInstr (SomeInstr (x : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
forall a b. (a -> b) -> a -> b
$ do
        let ns :: SingT ('TOr t x)
ns = Sing t -> Sing x -> SingT ('TOr t x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TOr n1 n2)
STOr (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
an) Sing x
SingT x
bn
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
-> Instr (x : xs) ('TOr t x : xs)
forall (a :: T) (b :: T) (s :: [T]).
SingI a =>
Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes a]
-> Instr (b : s) ('TOr a b : s)
AnnRIGHT (TypeAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Notes t
-> Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k) (t :: T).
(Each '[Typeable] '[a, b, c, d], SingI t) =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Notes t
-> Anns
     '[Annotation a, Annotation b, Annotation c, Annotation d, Notes t]
Anns5' TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Notes t
an) Instr (x : xs) ('TOr t x : xs)
-> HST ('TOr t x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOr t x)
ns, Dict (WellTyped ('TOr t x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOr t x), Dict (WellTyped ('TOr t x)))
-> HST xs -> HST ('TOr t x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))

  (U.RIGHT {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.IF_LEFT [ExpandedOp]
mp [ExpandedOp]
mq, (STOr (SingT n1
lt :: SingT l) (SingT n2
rt :: SingT r), Dict (WellTyped x)
_) ::& HST xs
rs) -> do
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TOr n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
lt ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TOr n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TOr n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
rt ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TOr n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @l ((WellTyped n1 =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n1 =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
        forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @r ((WellTyped n2 =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
          let
            ait :: HST (n1 : xs)
ait = (SingT n1
lt, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
            bit :: HST (n2 : xs)
bit = (SingT n2
rt, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
          (forall (s' :: [T]).
 Instr (n1 : xs) s'
 -> Instr (n2 : xs) s' -> Instr ('TOr n1 n2 : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST (n1 : xs)
-> HST (n2 : xs)
-> HST ('TOr n1 n2 : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
 Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr (n1 : xs) s'
-> Instr (n2 : xs) s' -> Instr ('TOr n1 n2 : xs) s'
forall (a :: T) (s :: [T]) (out :: [T]) (b :: T).
Instr (a : s) out -> Instr (b : s) out -> Instr ('TOr a b : s) out
IF_LEFT forall op. [op] -> [op] -> InstrAbstract op
U.IF_LEFT [ExpandedOp]
mp [ExpandedOp]
mq HST (n1 : xs)
ait HST (n2 : xs)
bit HST inp
HST ('TOr n1 n2 : xs)
inp

  (U.IF_LEFT [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"or 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.IF_LEFT [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.NIL TypeAnn
tn VarAnn
vn Ty
elMt, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
elMt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
elNotes :: Notes t) ->
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TList t) ((WellTyped ('TList t) => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TList t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t] -> Instr inp ('TList t : inp)
forall (p :: T) (inp :: [T]).
SingI p =>
Anns '[TypeAnn, VarAnn, Notes p] -> Instr inp ('TList p : inp)
AnnNIL (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
elNotes) Instr inp ('TList t : inp)
-> HST ('TList t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TList t)
forall (n :: T). Sing n -> SingT ('TList n)
STList (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
elNotes), Dict (WellTyped ('TList t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TList t), Dict (WellTyped ('TList t)))
-> HST inp -> HST ('TList t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.CONS VarAnn
vn, ((SingT x
_ :: SingT a), Dict (WellTyped x)
_) ::& ((SingT x
ln :: SingT l), Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr
    case forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @('TList a) @l of
      Right 'TList x :~: x
Refl -> do
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TList l) ((WellTyped ('TList x) =>
  TypeCheckInstr (SomeInstr (x : 'TList x : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TList x : xs)))
-> (WellTyped ('TList x) =>
    TypeCheckInstr (SomeInstr (x : 'TList x : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TList x : xs))
forall a b. (a -> b) -> a -> b
$
          SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : 'TList x : xs) ('TList x : xs)
forall (a :: T) (s :: [T]).
AnnVar -> Instr (a : 'TList a : s) ('TList a : s)
AnnCONS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TList x : xs) ('TList x : xs)
-> HST ('TList x : xs) -> SomeInstrOut (x : 'TList x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x
ln, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
      Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : x : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ConsArgument) TCTypeError
m

  (U.CONS VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.IF_CONS [ExpandedOp]
mp [ExpandedOp]
mq, (ns :: SingT x
ns@(STList (SingT n
an :: SingT t1)), Dict (WellTyped x)
Dict) ::& HST xs
rs) -> do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
      let ait :: HST (n : x : xs)
ait = (SingT n
an, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict) (SingT n, Dict (WellTyped n)) -> HST (x : xs) -> HST (n : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x
ns, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
      (forall (s' :: [T]).
 Instr (n : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST (n : x : xs)
-> HST xs
-> HST ('TList n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
 Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr (n : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s'
forall (a :: T) (s :: [T]) (out :: [T]).
Instr (a : 'TList a : s) out
-> Instr s out -> Instr ('TList a : s) out
IF_CONS forall op. [op] -> [op] -> InstrAbstract op
U.IF_CONS [ExpandedOp]
mp [ExpandedOp]
mq HST (n : x : xs)
ait HST xs
rs HST inp
HST ('TList n : xs)
inp

  (U.IF_CONS [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.IF_CONS [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil)-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SIZE VarAnn
vn, (STList{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TList n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TList n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstr (SomeInstr ('TList n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STSet{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TSet n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> TypeCheckInstr (SomeInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STMap{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TString : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TString : xs)))
-> TypeCheckInstr (SomeInstr ('TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"set 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"map 'k 'v" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"string" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      ]

  (U.SIZE VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.EMPTY_SET TypeAnn
tn VarAnn
vn Ty
mv, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v) ->
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TSet v) ((WellTyped ('TSet t) => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TSet t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
        Sing t
-> ExpandedInstr
-> HST inp
-> (Comparable t => SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns) ExpandedInstr
uInstr HST inp
inp ((Comparable t => SomeInstr inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (Comparable t => SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
          HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t] -> Instr inp ('TSet t : inp)
forall (e :: T) (inp :: [T]).
(SingI e, Comparable e) =>
Anns '[TypeAnn, VarAnn, Notes e] -> Instr inp ('TSet e : inp)
AnnEMPTY_SET (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
vns) Instr inp ('TSet t : inp)
-> HST ('TSet t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TSet t)
forall (n :: T). Sing n -> SingT ('TSet n)
STSet (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns), Dict (WellTyped ('TSet t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TSet t), Dict (WellTyped ('TSet t)))
-> HST inp -> HST ('TSet t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.EMPTY_MAP TypeAnn
tn VarAnn
vn Ty
mk Ty
mv, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v)  ->
      Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mk ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
ktn :: Notes k) ->
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TMap k v) ((WellTyped ('TMap t t) => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TMap t t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
          Sing t
-> ExpandedInstr
-> HST inp
-> (Comparable t => SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) ExpandedInstr
uInstr HST inp
inp ((Comparable t => SomeInstr inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (Comparable t => SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
            HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t, Notes t]
-> Instr inp ('TMap t t : inp)
forall (a :: T) (b :: T) (inp :: [T]).
(SingI a, SingI b, Comparable a) =>
Anns '[TypeAnn, VarAnn, Notes a, Notes b]
-> Instr inp ('TMap a b : inp)
AnnEMPTY_MAP (TypeAnn
-> VarAnn
-> Notes t
-> Notes t
-> Anns '[TypeAnn, VarAnn, Notes t, Notes t]
forall {k} (a :: k) (b :: k) (t :: T) (u :: T).
(Each '[Typeable] '[a, b], SingI t, SingI u) =>
Annotation a
-> Annotation b
-> Notes t
-> Notes u
-> Anns '[Annotation a, Annotation b, Notes t, Notes u]
Anns4'' TypeAnn
tn VarAnn
vn Notes t
ktn Notes t
vns) Instr inp ('TMap t t : inp)
-> HST ('TMap t t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> Sing t -> SingT ('TMap t t)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TMap n1 n2)
STMap (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns), Dict (WellTyped ('TMap t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TMap t t), Dict (WellTyped ('TMap t t)))
-> HST inp -> HST ('TMap t t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.EMPTY_BIG_MAP TypeAnn
tn VarAnn
vn Ty
mk Ty
mv, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v)  ->
      Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mk ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
ktn :: Notes k) ->
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TBigMap k v) ((WellTyped ('TBigMap t t) => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TBigMap t t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
          Sing t
-> ExpandedInstr
-> HST inp
-> (Comparable t => SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) ExpandedInstr
uInstr HST inp
inp ((Comparable t => SomeInstr inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (Comparable t => SomeInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
            HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t, Notes t]
-> Instr inp ('TBigMap t t : inp)
forall (a :: T) (b :: T) (inp :: [T]).
(SingI a, SingI b, Comparable a, HasNoBigMap b) =>
Anns '[TypeAnn, VarAnn, Notes a, Notes b]
-> Instr inp ('TBigMap a b : inp)
AnnEMPTY_BIG_MAP (TypeAnn
-> VarAnn
-> Notes t
-> Notes t
-> Anns '[TypeAnn, VarAnn, Notes t, Notes t]
forall {k} (a :: k) (b :: k) (t :: T) (u :: T).
(Each '[Typeable] '[a, b], SingI t, SingI u) =>
Annotation a
-> Annotation b
-> Notes t
-> Notes u
-> Anns '[Annotation a, Annotation b, Notes t, Notes u]
Anns4'' TypeAnn
tn VarAnn
vn Notes t
ktn Notes t
vns) Instr inp ('TBigMap t t : inp)
-> HST ('TBigMap t t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> Sing t -> SingT ('TBigMap t t)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TBigMap n1 n2)
STBigMap (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns), Dict (WellTyped ('TBigMap t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TBigMap t t), Dict (WellTyped ('TBigMap t t)))
-> HST inp -> HST ('TBigMap t t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.MAP VarAnn
vn [ExpandedOp]
mp, (STList (SingT n
vns :: SingT t1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TList n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TList n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
SingT n
vns ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TList n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TList n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TList n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$
      ([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp ('TList n))
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TList n : xs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v'
    -> HST xs -> TypeCheckInstr (HST (MapOpRes ('TList n) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl (VarAnn -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) SingT n
SingT (MapOpInp ('TList n))
vns VarAnn
vn ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TList n : xs)
inp
        (\(SingT v'
rn :: SingT t) HST xs
hst -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped v' => TypeCheckInstr (HST ('TList v' : xs)))
 -> TypeCheckInstr (HST ('TList v' : xs)))
-> (WellTyped v' => TypeCheckInstr (HST ('TList v' : xs)))
-> TypeCheckInstr (HST ('TList v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TList v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (HST ('TList v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TList v' : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (HST ('TList v' : xs)))
-> HST ('TList v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (HST ('TList v' : xs))
forall a b. (a -> b) -> a -> b
$ (Sing v' -> SingT ('TList v')
forall (n :: T). Sing n -> SingT ('TList n)
STList Sing v'
SingT v'
rn, Dict (WellTyped ('TList v'))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TList v'), Dict (WellTyped ('TList v')))
-> HST xs -> HST ('TList v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hst)

  (U.MAP VarAnn
vn [ExpandedOp]
mp, (STOption (SingT n
vns :: SingT t1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOption n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TOption n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
SingT n
vns ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TOption n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOption n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TOption n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$
      ([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp ('TOption n))
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TOption n : xs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v'
    -> HST xs -> TypeCheckInstr (HST (MapOpRes ('TOption n) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl (VarAnn -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) SingT n
SingT (MapOpInp ('TOption n))
vns VarAnn
vn ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TOption n : xs)
inp
        (\(SingT v'
rn :: SingT t) HST xs
hst -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped v' => TypeCheckInstr (HST ('TOption v' : xs)))
 -> TypeCheckInstr (HST ('TOption v' : xs)))
-> (WellTyped v' => TypeCheckInstr (HST ('TOption v' : xs)))
-> TypeCheckInstr (HST ('TOption v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TOption v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (HST ('TOption v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TOption v' : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (HST ('TOption v' : xs)))
-> HST ('TOption v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (HST ('TOption v' : xs))
forall a b. (a -> b) -> a -> b
$ (Sing v' -> SingT ('TOption v')
forall (n :: T). Sing n -> SingT ('TOption n)
STOption Sing v'
SingT v'
rn, Dict (WellTyped ('TOption v'))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption v'), Dict (WellTyped ('TOption v')))
-> HST xs -> HST ('TOption v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hst)

  (U.MAP VarAnn
vn [ExpandedOp]
mp, (STMap (SingT n1
k :: SingT k) (SingT n2
v :: SingT v1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @('TPair k v1) ((WellTyped ('TPair n1 n2) =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (WellTyped ('TPair n1 n2) =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      ([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp ('TMap n1 n2))
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TMap n1 n2 : xs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v'
    -> HST xs -> TypeCheckInstr (HST (MapOpRes ('TMap n1 n2) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl (VarAnn -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) (Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
SingT n1
k Sing n2
SingT n2
v) VarAnn
vn ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TMap n1 n2 : xs)
inp
          (\(SingT v'
rn :: SingT v) HST xs
hst -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TMap k v) ((WellTyped ('TMap n1 v') =>
  TypeCheckInstr (HST ('TMap n1 v' : xs)))
 -> TypeCheckInstr (HST ('TMap n1 v' : xs)))
-> (WellTyped ('TMap n1 v') =>
    TypeCheckInstr (HST ('TMap n1 v' : xs)))
-> TypeCheckInstr (HST ('TMap n1 v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TMap n1 v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (HST ('TMap n1 v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TMap n1 v' : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (HST ('TMap n1 v' : xs)))
-> HST ('TMap n1 v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (HST ('TMap n1 v' : xs))
forall a b. (a -> b) -> a -> b
$ (Sing n1 -> Sing v' -> SingT ('TMap n1 v')
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TMap n1 n2)
STMap Sing n1
SingT n1
k Sing v'
SingT v'
rn, Dict (WellTyped ('TMap n1 v'))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TMap n1 v'), Dict (WellTyped ('TMap n1 v')))
-> HST xs -> HST ('TMap n1 v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hst)

  (U.MAP VarAnn
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"map 'k 'v" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"option 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      ]

  (U.MAP VarAnn
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.ITER [ExpandedOp]
is, (STSet (Sing n
s :: Sing t1), Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TSet n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TSet n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TSet n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$
      SingT (IterOpEl ('TSet n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TSet n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Sing n
SingT (IterOpEl ('TSet n))
s ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TSet n : xs)
inp

  (U.ITER [ExpandedOp]
is, (STList (Sing n
l :: Sing t1), Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TList n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TList n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
l ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TList n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TList n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TList n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$
      SingT (IterOpEl ('TList n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TList n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Sing n
SingT (IterOpEl ('TList n))
l ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TList n : xs)
inp

  (U.ITER [ExpandedOp]
is, (STMap (SingT n1
k :: SingT a) (SingT n2
v :: SingT b), Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @('TPair a b) ((WellTyped ('TPair n1 n2) =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (WellTyped ('TPair n1 n2) =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ SingT (IterOpEl ('TMap n1 n2))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TMap n1 n2 : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl (Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
SingT n1
k Sing n2
SingT n2
v) ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TMap n1 n2 : xs)
inp

  (U.ITER [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"set 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"map 'k 'v" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      ]

  (U.ITER [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.MEM VarAnn
varNotes,
   (SingT x, Dict (WellTyped x))
_ ::& (STSet Sing n
s, Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TSet n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TSet n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TSet n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TSet n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TSet n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TSet n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$
    HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *).
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
memImpl HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
varNotes,
   (SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *).
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
memImpl HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
varNotes,
   (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *).
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
memImpl HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"set 'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"map 'k 'v"])
      , (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"big_map 'k 'v"])
      ]

  (U.MEM VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.GET VarAnn
varNotes,
   (SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
-> SingT (GetOpVal ('TMap n1 n2))
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (getKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *).
(GetOp c, SingI (GetOpKey c), WellTyped (GetOpVal c),
 inp ~ (getKey : c : rs), SingI rs, MonadReader TypeCheckInstrEnv m,
 MonadError TCError m) =>
HST inp -> SingT (GetOpVal c) -> VarAnn -> m (SomeInstr inp)
getImpl HST inp
inp SingT n2
SingT (GetOpVal ('TMap n1 n2))
v VarAnn
varNotes
  (U.GET VarAnn
varNotes,
   (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
-> SingT (GetOpVal ('TBigMap n1 n2))
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (getKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *).
(GetOp c, SingI (GetOpKey c), WellTyped (GetOpVal c),
 inp ~ (getKey : c : rs), SingI rs, MonadReader TypeCheckInstrEnv m,
 MonadError TCError m) =>
HST inp -> SingT (GetOpVal c) -> VarAnn -> m (SomeInstr inp)
getImpl HST inp
inp SingT n2
SingT (GetOpVal ('TBigMap n1 n2))
v VarAnn
varNotes

  (U.GET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"map 'k 'v"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"big_map 'k 'v"])
      ]

  (U.GET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.GETN VarAnn
_ Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
  (U.GETN VarAnn
getNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
ix0 HST inp
HST (x : xs)
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCGetNHelper (x : xs))
-> (TCGetNHelper (x : xs) -> SomeInstr (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCGetNHelper PeanoNatural ix
s HST (GetN ix pair : rest)
out ->
        HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural ix -> Instr (x : xs) (GetN ix x : xs)
forall (ix :: Nat) (pair :: T) (s :: [T]).
ConstraintGetN ix pair =>
AnnVar -> PeanoNatural ix -> Instr (pair : s) (GetN ix pair : s)
AnnGETN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
getNVarAnn) PeanoNatural ix
s Instr (x : xs) (GetN ix x : xs)
-> HST (GetN ix x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (GetN ix x : xs)
HST (GetN ix pair : rest)
out
    where
      go :: forall x xs. Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
      go :: forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
0 ((SingT x
a, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z -> HST (GetN 'Z x : xs) -> TCGetNHelper (x : xs)
forall (n :: Nat) (out :: T) (s :: [T]).
(SingI (GetN n out : s), ConstraintGetN n out) =>
PeanoNatural n -> HST (GetN n out : s) -> TCGetNHelper (out : s)
TCGetNHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero ((SingT x
a, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest)
      go Word
1 ((STPair Sing n1
leftNotes Sing n2
_, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCGetNHelper ('TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCGetNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper ('TPair n1 n2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCGetNHelper ('TPair n1 n2 : xs)))
-> TCGetNHelper ('TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCGetNHelper ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (GetN ('S 'Z) ('TPair n1 n2) : xs)
-> TCGetNHelper ('TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: [T]).
(SingI (GetN n out : s), ConstraintGetN n out) =>
PeanoNatural n -> HST (GetN n out : s) -> TCGetNHelper (out : s)
TCGetNHelper PeanoNatural ('S 'Z)
forall (n :: Nat). (n ~ 'S 'Z) => PeanoNatural n
One (HST (GetN ('S 'Z) ('TPair n1 n2) : xs)
 -> TCGetNHelper ('TPair n1 n2 : xs))
-> HST (GetN ('S 'Z) ('TPair n1 n2) : xs)
-> TCGetNHelper ('TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$ (Sing n1
SingT n1
leftNotes, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
      go Word
ix ((STPair Sing n1
_ Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        Word -> HST (n2 : xs) -> TypeCheckInstr (TCGetNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go (Word
ix Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
2) ((Sing n2
SingT n2
rightNotes, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCGetNHelper (n2 : xs))
-> (TCGetNHelper (n2 : xs) -> TCGetNHelper ('TPair n1 n2 : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCGetNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCGetNHelper PeanoNatural ix
ixSing HST (GetN ix pair : rest)
out) ->
          PeanoNatural ('S ('S ix))
-> HST (GetN ('S ('S ix)) ('TPair n1 n2) : rest)
-> TCGetNHelper ('TPair n1 n2 : rest)
forall (n :: Nat) (out :: T) (s :: [T]).
(SingI (GetN n out : s), ConstraintGetN n out) =>
PeanoNatural n -> HST (GetN n out : s) -> TCGetNHelper (out : s)
TCGetNHelper (PeanoNatural ('S ix) -> PeanoNatural ('S ('S ix))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ (PeanoNatural ix -> PeanoNatural ('S ix)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural ix
ixSing)) HST (GetN ix pair : rest)
HST (GetN ('S ('S ix)) ('TPair n1 n2) : rest)
out
      go Word
_ HST (x : xs)
_ = TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (TCGetNHelper (x : xs))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      (TCGetNHelper (x : xs)))
-> TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Word -> Text
pairWithNodeIndex Word
ix0 Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
  (U.UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
  (U.UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STSet Sing n
s, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TSet n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TSet n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TSet n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TSet n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TSet n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TSet n : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn

  (U.UPDATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool", Text
"set 'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"map 'k 'v"])
      , (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"big_map 'k 'v"])
      ]

  (U.UPDATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.UPDATEN VarAnn
updateNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Word
-> HST (x : x : xs)
-> TypeCheckInstr (TCUpdateNHelper (x : x : xs))
forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go Word
ix0 HST inp
HST (x : x : xs)
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCUpdateNHelper (x : x : xs))
-> (TCUpdateNHelper (x : x : xs) -> SomeInstr (x : x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCUpdateNHelper PeanoNatural ix
s HST (UpdateN ix val pair : rest)
out ->
        HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> PeanoNatural ix -> Instr (x : x : xs) (UpdateN ix x x : xs)
forall (ix :: Nat) (val :: T) (pair :: T) (s :: [T]).
ConstraintUpdateN ix pair =>
AnnVar
-> PeanoNatural ix
-> Instr (val : pair : s) (UpdateN ix val pair : s)
AnnUPDATEN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
updateNVarAnn) PeanoNatural ix
s Instr (x : x : xs) (UpdateN ix x x : xs)
-> HST (UpdateN ix x x : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (UpdateN ix x x : xs)
HST (UpdateN ix val pair : rest)
out
    where
      go :: forall val pair rest. Word -> HST (val : pair : rest) -> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
      go :: forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go Word
0 ((SingT x
valNotes, Dict (WellTyped x)
Dict) ::& (SingT x
_, Dict (WellTyped x)
_) ::& HST xs
rest) =
        TCUpdateNHelper (val : pair : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUpdateNHelper (val : pair : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCUpdateNHelper (val : pair : xs)))
-> TCUpdateNHelper (val : pair : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUpdateNHelper (val : pair : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z
-> HST (UpdateN 'Z val pair : xs)
-> TCUpdateNHelper (val : pair : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UpdateN n out s : s'), ConstraintUpdateN n s) =>
PeanoNatural n
-> HST (UpdateN n out s : s') -> TCUpdateNHelper (out : s : s')
TCUpdateNHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero (HST (UpdateN 'Z val pair : xs)
 -> TCUpdateNHelper (val : pair : xs))
-> HST (UpdateN 'Z val pair : xs)
-> TCUpdateNHelper (val : pair : xs)
forall a b. (a -> b) -> a -> b
$
          (SingT x
valNotes, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
      go Word
1 ((SingT x
valNotes, Dict (WellTyped x)
Dict) ::& (STPair Sing n1
_ Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCUpdateNHelper (val : 'TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUpdateNHelper (val : 'TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : 'TPair n1 n2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (TCUpdateNHelper (val : 'TPair n1 n2 : xs)))
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUpdateNHelper (val : 'TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (UpdateN ('S 'Z) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UpdateN n out s : s'), ConstraintUpdateN n s) =>
PeanoNatural n
-> HST (UpdateN n out s : s') -> TCUpdateNHelper (out : s : s')
TCUpdateNHelper PeanoNatural ('S 'Z)
forall (n :: Nat). (n ~ 'S 'Z) => PeanoNatural n
One (HST (UpdateN ('S 'Z) val ('TPair n1 n2) : xs)
 -> TCUpdateNHelper (val : 'TPair n1 n2 : xs))
-> HST (UpdateN ('S 'Z) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$
          (Sing val -> Sing n2 -> SingT ('TPair val n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing val
SingT x
valNotes Sing n2
rightNotes, Dict (WellTyped ('TPair val n2))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair val n2), Dict (WellTyped ('TPair val n2)))
-> HST xs -> HST ('TPair val n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
      go Word
ix ((SingT x, Dict (WellTyped x))
val ::& (STPair Sing n1
leftNotes Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        Word
-> HST (x : n2 : xs)
-> TypeCheckInstr (TCUpdateNHelper (x : n2 : xs))
forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go (Word
ix Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
2) ((SingT x, Dict (WellTyped x))
val (SingT x, Dict (WellTyped x)) -> HST (n2 : xs) -> HST (x : n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (Sing n2
SingT n2
rightNotes, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (TCUpdateNHelper (val : n2 : rest))
-> (TCUpdateNHelper (val : n2 : rest)
    -> TCUpdateNHelper (val : 'TPair n1 n2 : rest))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (TCUpdateNHelper (val : 'TPair n1 n2 : rest))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&>
          \(TCUpdateNHelper PeanoNatural ix
ixSing ((SingT x
updatedRightNotes, Dict (WellTyped x)
Dict) ::& HST xs
outRest)) ->
            PeanoNatural ('S ('S ix))
-> HST (UpdateN ('S ('S ix)) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UpdateN n out s : s'), ConstraintUpdateN n s) =>
PeanoNatural n
-> HST (UpdateN n out s : s') -> TCUpdateNHelper (out : s : s')
TCUpdateNHelper (PeanoNatural ('S ix) -> PeanoNatural ('S ('S ix))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ (PeanoNatural ix -> PeanoNatural ('S ix)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural ix
ixSing)) (HST (UpdateN ('S ('S ix)) val ('TPair n1 n2) : xs)
 -> TCUpdateNHelper (val : 'TPair n1 n2 : xs))
-> HST (UpdateN ('S ('S ix)) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$
              (Sing n1
-> Sing (UpdateN ix val n2)
-> SingT ('TPair n1 (UpdateN ix val n2))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
leftNotes Sing (UpdateN ix val n2)
SingT x
updatedRightNotes, Dict (WellTyped ('TPair n1 (UpdateN ix val n2)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair n1 (UpdateN ix val n2)),
 Dict (WellTyped ('TPair n1 (UpdateN ix val n2))))
-> HST xs -> HST ('TPair n1 (UpdateN ix val n2) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
outRest
      go Word
_ HST (val : pair : rest)
_ = TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
      (ExceptT TCError Identity)
      (TCUpdateNHelper (val : pair : rest)))
-> TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'val" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Word -> Text
pairWithNodeIndex Word
ix0]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.UPDATEN VarAnn
_ Word
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.GET_AND_UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs)))
 -> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
        HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, GetOp c, SingI (UpdOpKey c), SingI (GetOpVal c),
 inp ~ (updKey : updParams : c : rs), SingI rs,
 GetOpKey c ~ UpdOpKey c, UpdOpParams c ~ 'TOption (GetOpVal c),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
getUpdImpl HST inp
inp VarAnn
varAnn
  (U.GET_AND_UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs)))
 -> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
        HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, GetOp c, SingI (UpdOpKey c), SingI (GetOpVal c),
 inp ~ (updKey : updParams : c : rs), SingI rs,
 GetOpKey c ~ UpdOpKey c, UpdOpParams c ~ 'TOption (GetOpVal c),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
getUpdImpl HST inp
inp VarAnn
varAnn
  (U.GET_AND_UPDATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"map 'k 'v"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"big_map 'k 'v"])
      ]
  (U.GET_AND_UPDATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.IF [ExpandedOp]
mp [ExpandedOp]
mq, (STBool{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    (forall (s' :: [T]).
 Instr xs s' -> Instr xs s' -> Instr ('TBool : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST xs
-> HST xs
-> HST ('TBool : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
 Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr xs s' -> Instr xs s' -> Instr ('TBool : xs) s'
forall (s :: [T]) (out :: [T]).
Instr s out -> Instr s out -> Instr ('TBool : s) out
IF forall op. [op] -> [op] -> InstrAbstract op
U.IF [ExpandedOp]
mp [ExpandedOp]
mq HST xs
rs HST xs
rs HST inp
HST ('TBool : xs)
inp

  (U.IF [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.IF [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LOOP [ExpandedOp]
is, (STBool{}, Dict (WellTyped x)
_) ::& (HST xs
rs :: HST rs)) -> do
    TypeCheckInstrNoExcept (TypeCheckedSeq xs)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr xs -> TypeCheckInstr (SomeInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST xs -> TypeCheckInstrNoExcept (TypeCheckedSeq xs)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is HST xs
rs) [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.LOOP ((SomeInstr xs -> TypeCheckInstr (SomeInstr ('TBool : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs)))
-> (SomeInstr xs -> TypeCheckInstr (SomeInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall a b. (a -> b) -> a -> b
$ \(HST xs
_ :/ SomeInstrOut xs
tp) ->
      case SomeInstrOut xs
tp of
        Instr xs out
subI ::: (HST out
o :: HST o) -> do
          case HST out
-> HST ('TBool : xs) -> Either TCTypeError (out :~: ('TBool : xs))
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o (forall {k} (a :: k). SingI a => Sing a
forall (a :: T). SingI a => Sing a
sing @'TBool Sing 'TBool -> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(WellTyped x, SingI xs) =>
Sing x -> HST xs -> HST (x : xs)
-:& HST xs
rs) of
            Right out :~: ('TBool : xs)
Refl -> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr xs ('TBool : xs) -> Instr ('TBool : xs) xs
forall (out :: [T]).
Instr out ('TBool : out) -> Instr ('TBool : out) out
LOOP Instr xs out
Instr xs ('TBool : xs)
subI Instr ('TBool : xs) xs -> HST xs -> SomeInstrOut ('TBool : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs
            Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBool : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
m
        AnyOutInstr forall (out :: [T]). Instr xs out
subI ->
          SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr xs ('TBool : xs) -> Instr ('TBool : xs) xs
forall (out :: [T]).
Instr out ('TBool : out) -> Instr ('TBool : out) out
LOOP Instr xs ('TBool : xs)
forall (out :: [T]). Instr xs out
subI Instr ('TBool : xs) xs -> HST xs -> SomeInstrOut ('TBool : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs

  (U.LOOP [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.LOOP [ExpandedOp]
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LOOP_LEFT [ExpandedOp]
is, (os :: SingT x
os@(STOr (SingT n1
an :: SingT t) (SingT n2
bn :: SingT b)), Dict (WellTyped x)
Dict) ::& HST xs
rs) -> do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t ((WellTyped n1 =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n1 =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @b ((WellTyped n2 =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
      let ait :: HST (n1 : xs)
ait = (SingT n1
an, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
      TypeCheckInstrNoExcept (TypeCheckedSeq (n1 : xs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (n1 : xs)
    -> TypeCheckInstr (SomeInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST (n1 : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (n1 : xs))
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is HST (n1 : xs)
ait) [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.LOOP_LEFT ((SomeInstr (n1 : xs)
  -> TypeCheckInstr (SomeInstr ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (SomeInstr (n1 : xs)
    -> TypeCheckInstr (SomeInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ \(HST (n1 : xs)
_ :/ SomeInstrOut (n1 : xs)
tp) ->
        case SomeInstrOut (n1 : xs)
tp of
          Instr (n1 : xs) out
subI ::: HST out
o -> do
            case (HST out
-> HST ('TOr n1 n2 : xs)
-> Either TCTypeError (out :~: ('TOr n1 n2 : xs))
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o (Sing ('TOr n1 n2)
SingT x
os Sing ('TOr n1 n2) -> HST xs -> HST ('TOr n1 n2 : xs)
forall (x :: T) (xs :: [T]).
(WellTyped x, SingI xs) =>
Sing x -> HST xs -> HST (x : xs)
-:& HST xs
rs), HST out
o) of
              (Right out :~: ('TOr n1 n2 : xs)
Refl, (SingT x
_, Dict (WellTyped x)
Dict) ::& HST xs
rs') ->
                  SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (n1 : xs) ('TOr n1 n2 : xs)
-> Instr ('TOr n1 n2 : xs) (n2 : xs)
forall (a :: T) (s :: [T]) (b :: T).
Instr (a : s) ('TOr a b : s) -> Instr ('TOr a b : s) (b : s)
LOOP_LEFT Instr (n1 : xs) out
Instr (n1 : xs) ('TOr n1 n2 : xs)
subI Instr ('TOr n1 n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut ('TOr n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT n2
bn, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs')
              (Left TCTypeError
m, HST out
_) -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TOr n1 n2 : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
m
          AnyOutInstr forall (out :: [T]). Instr (n1 : xs) out
subI -> do
            let br :: (SingT n2, Dict (WellTyped n2))
br = (SingT n2
bn, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict)
            SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (n1 : xs) ('TOr n1 n2 : xs)
-> Instr ('TOr n1 n2 : xs) (n2 : xs)
forall (a :: T) (s :: [T]) (b :: T).
Instr (a : s) ('TOr a b : s) -> Instr ('TOr a b : s) (b : s)
LOOP_LEFT Instr (n1 : xs) ('TOr n1 n2 : xs)
forall (out :: [T]). Instr (n1 : xs) out
subI Instr ('TOr n1 n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut ('TOr n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT n2, Dict (WellTyped n2))
br (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.LOOP_LEFT [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"or 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.LOOP_LEFT [ExpandedOp]
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LAMBDA VarAnn
vn p1 :: Ty
p1@(AsUType (Notes t
ins :: Notes t)) p2 :: Ty
p2@(AsUType (Notes t
ons :: Notes u)) [ExpandedOp]
is, HST inp
i) -> do
    -- further processing is extracted into another function just not to
    -- litter our main typechecking logic
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t ((WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @u ((WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
        ([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes t, Notes t]
-> ExpandedInstr
-> [ExpandedOp]
-> SingT t
-> SingT t
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (it :: T) (ot :: T) (ts :: [T]).
(WellTyped it, WellTyped ot, SingI ts) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes it, Notes ot]
-> ExpandedInstr
-> [ExpandedOp]
-> SingT it
-> SingT ot
-> HST ts
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl (VarAnn -> Ty -> Ty -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> Ty -> Ty -> [op] -> InstrAbstract op
U.LAMBDA VarAnn
vn Ty
p1 Ty
p2) (VarAnn -> Notes t -> Notes t -> Anns '[VarAnn, Notes t, Notes t]
forall {k} (a :: k) (t :: T) (u :: T).
(Typeable a, SingI t, SingI u) =>
Annotation a
-> Notes t -> Notes u -> Anns '[Annotation a, Notes t, Notes u]
Anns3'' VarAnn
vn Notes t
ins Notes t
ons) ExpandedInstr
uInstr [ExpandedOp]
is (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ins) (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ons) HST inp
i

  (U.EXEC VarAnn
vn, ((SingT x
_ :: SingT t1), Dict (WellTyped x)
_)
                              ::& ( STLambda (SingT n1
v :: SingT t1') (SingT n2
b :: SingT t2'), Dict (WellTyped x)
_)
                              ::& HST xs
rs) -> Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
v ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
b ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TLambda n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    x :~: n1
Refl <- Either TCTypeError (x :~: n1)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (x :~: n1)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (x :~: n1)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (x :~: n1))
-> Either TCTypeError (x :~: n1)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (x :~: n1)
forall a b. (a -> b) -> a -> b
$ forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t1'
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t2' ((WellTyped n2 =>
  TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs))
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : 'TLambda x n2 : xs) (n2 : xs)
forall (t1 :: T) (t2 :: T) (s :: [T]).
AnnVar -> Instr (t1 : 'TLambda t1 t2 : s) (t2 : s)
AnnEXEC (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TLambda x n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut (x : 'TLambda x n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT n2
b, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
      where
        errM :: (MonadReader TypeCheckInstrEnv m, MonadError TCError m) => Either TCTypeError a -> m a
        errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaArgument)

  (U.EXEC VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"lambda 'a 'b"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.EXEC VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.APPLY VarAnn
vn, ((SingT x
_ :: SingT a'), Dict (WellTyped x)
_)
            ::& ( STLambda (STPair (SingT n1
lt :: SingT a) (SingT n2
rt :: SingT b) :: SingT t1) (SingT n2
b :: SingT t2), Dict (WellTyped x)
_)
            ::& HST xs
rs) -> Sing n1
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
lt ((SingI n1 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
rt ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
b ((SingI n2 =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TLambda t1 t2) ((WellTyped ('TLambda n1 n2) =>
  TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> TypeCheckInstr
      (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (WellTyped ('TLambda n1 n2) =>
    TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
      x :~: n1
proofArgEq <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (x :~: n1)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (x :~: n1)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaArgument)
                    (forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @a' @a)
      Dict (ConstantScope n1)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaArgument)
        (Either BadTypeForScope (Dict (ConstantScope n1))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ConstantScope n1)))
-> Either BadTypeForScope (Dict (ConstantScope n1))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ConstantScope n1))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope a)
      case (x :~: n1
proofArgEq, Dict (ConstantScope n1)
proofScope) of
        (x :~: n1
Refl, Dict (ConstantScope n1)
Dict) ->
          SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ forall (a :: T) (b :: T) (c :: T) (s :: [T]).
(ConstantScope a, SingI b) =>
AnnVar
-> Instr (a : 'TLambda ('TPair a b) c : s) ('TLambda b c : s)
AnnAPPLY @a (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (n1 : 'TLambda ('TPair n1 n2) n2 : xs) ('TLambda n2 n2 : xs)
-> HST ('TLambda n2 n2 : xs)
-> SomeInstrOut (n1 : 'TLambda ('TPair n1 n2) n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing n2 -> Sing n2 -> SingT ('TLambda n2 n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TLambda n1 n2)
STLambda Sing n2
SingT n2
rt Sing n2
SingT n2
b, Dict (WellTyped ('TLambda n2 n2))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TLambda n2 n2), Dict (WellTyped ('TLambda n2 n2)))
-> HST xs -> HST ('TLambda n2 n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.APPLY VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"lambda (pair 'a 'b) 'c"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.APPLY VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.DIP [ExpandedOp]
is, (SingT x, Dict (WellTyped x))
a ::& HST xs
s) -> do
    ([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST xs
-> (TCError -> [IllTypedInstr] -> TypeCheckedSeq (x : xs))
-> (forall (out :: [T]).
    SingI out =>
    Instr xs out -> HST out -> TypeCheckedSeq (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (inp :: [T]) r.
SingI inp =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.DIP ExpandedInstr
uInstr [ExpandedOp]
is HST xs
s
      (TCError -> [IllTypedInstr] -> TypeCheckedSeq (x : xs)
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq)
      (\Instr xs out
subI HST out
t -> SomeInstr inp -> TypeCheckedSeq inp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedSeq inp
WellTypedSeq (SomeInstr inp -> TypeCheckedSeq inp)
-> SomeInstr inp -> TypeCheckedSeq inp
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr xs out -> Instr (x : xs) (x : out)
forall (a :: [T]) (c :: [T]) (b :: T).
Instr a c -> Instr (b : a) (b : c)
DIP Instr xs out
subI Instr (x : xs) (x : out) -> HST (x : out) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST out
t))

  (U.DIP [ExpandedOp]
_is, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.DIPN Word
nTotal [ExpandedOp]
instructions, HST inp
inputHST) ->
    Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
  (TCDipHelper inp)
-> (TCDipHelper inp -> TypeCheckedSeq inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCDipHelperErr TCError
err [IllTypedInstr]
rest -> TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq TCError
err [IllTypedInstr]
rest
      TCDipHelperOk PeanoNatural n
s Instr s s'
subI HST out
out -> SomeInstr inp -> TypeCheckedSeq inp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedSeq inp
WellTypedSeq (SomeInstr inp -> TypeCheckedSeq inp)
-> SomeInstr inp -> TypeCheckedSeq inp
forall a b. (a -> b) -> a -> b
$ HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr s s' -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T]).
ConstraintDIPN n inp out s s' =>
PeanoNatural n -> Instr s s' -> Instr inp out
DIPN PeanoNatural n
s Instr s s'
subI Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstrNoExcept (TCDipHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
go Word
n HST inp
curHST = case (Word
n, HST inp
curHST) of
        (Word
0, HST inp
_) -> ([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> TCDipHelper inp)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> TCDipHelper inp)
-> TypeCheckInstrNoExcept (TCDipHelper inp)
forall (inp :: [T]) r.
SingI inp =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody (Word -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. Word -> [op] -> InstrAbstract op
U.DIPN Word
nTotal) ExpandedInstr
uInstr [ExpandedOp]
instructions HST inp
curHST
          (TCError -> [IllTypedInstr] -> TCDipHelper inp
forall (inp :: [T]). TCError -> [IllTypedInstr] -> TCDipHelper inp
TCDipHelperErr)
          (PeanoNatural 'Z -> Instr inp out -> HST out -> TCDipHelper inp
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T]).
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper inp
TCDipHelperOk PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero)
        (Word
_, HST inp
SNil) -> do
          ErrorSrcPos
pos <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
          let err :: TCError
err = ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) ErrorSrcPos
pos Maybe TypeContext
forall a. Maybe a
Nothing (TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
NotEnoughItemsOnStack)
          TCDipHelper '[]
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TCDipHelper '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCDipHelper '[]
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TCDipHelper '[]))
-> TCDipHelper '[]
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TCDipHelper '[])
forall a b. (a -> b) -> a -> b
$ TCError -> [IllTypedInstr] -> TCDipHelper '[]
forall (inp :: [T]). TCError -> [IllTypedInstr] -> TCDipHelper inp
TCDipHelperErr TCError
err [ExpandedOp -> IllTypedInstr
NonTypedInstr (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> ExpandedOp
U.PrimEx ExpandedInstr
uInstr]
        (Word
_, (SingT x, Dict (WellTyped x))
hstHead ::& HST xs
hstTail) ->
          Word -> HST xs -> TypeCheckInstrNoExcept (TCDipHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
hstTail ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
  (TCDipHelper xs)
-> (TCDipHelper xs -> TCDipHelper (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TCDipHelper (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
          TCDipHelperOk PeanoNatural n
s Instr s s'
subI HST out
out -> PeanoNatural ('S n)
-> Instr s s' -> HST (x : out) -> TCDipHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T]).
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper inp
TCDipHelperOk (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) Instr s s'
subI ((SingT x, Dict (WellTyped x))
hstHead (SingT x, Dict (WellTyped x)) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST out
out)
          TCDipHelperErr TCError
err [IllTypedInstr]
rest -> TCError -> [IllTypedInstr] -> TCDipHelper (x : xs)
forall (inp :: [T]). TCError -> [IllTypedInstr] -> TCDipHelper inp
TCDipHelperErr TCError
err [IllTypedInstr]
rest

  (ExpandedInstr
U.FAILWITH, ((SingT x
_ :: SingT a, Dict (WellTyped x)
_) ::& HST xs
_)) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Dict (ConstantScope x)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
FailwithArgument)
      (Either BadTypeForScope (Dict (ConstantScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ConstantScope x)))
-> Either BadTypeForScope (Dict (ConstantScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ConstantScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope a)
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ (forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
AnyOutInstr forall (out :: [T]). Instr inp out
forall (a :: T) (s :: [T]) (out :: [T]).
(SingI a, ConstantScope a) =>
Instr (a : s) out
FAILWITH

  (ExpandedInstr
U.FAILWITH, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.CAST VarAnn
vn (AsUType (Notes t
castToNotes :: Notes t)), (SingT x
_ :: SingT t1, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
      t :~: x
Refl <- Either TCTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (t :~: x)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (t :~: x)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (t :~: x))
-> Either TCTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (t :~: x)
forall a b. (a -> b) -> a -> b
$ forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t @t1
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr (t : xs)))
 -> TypeCheckInstr (SomeInstr (t : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (t : xs)))
-> TypeCheckInstr (SomeInstr (t : xs))
forall a b. (a -> b) -> a -> b
$
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t] -> Instr (t : xs) (t : xs)
forall (a :: T) (s :: [T]).
SingI a =>
Anns '[VarAnn, Notes a] -> Instr (a : s) (a : s)
AnnCAST (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
castToNotes) Instr (t : xs) (t : xs) -> HST (t : xs) -> SomeInstrOut (t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
castToNotes, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict) (SingT t, Dict (WellTyped t)) -> HST xs -> HST (t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    where
      errM :: (MonadReader TypeCheckInstrEnv m, MonadError TCError m) => Either TCTypeError a -> m a
      errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Cast)

  (U.CAST VarAnn
_ Ty
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.RENAME VarAnn
vn, (SingT x
an, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : xs) (x : xs)
forall (a :: T) (s :: [T]). AnnVar -> Instr (a : s) (a : s)
AnnRENAME (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : xs) (x : xs) -> HST (x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x
an, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.RENAME VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.UNPACK TypeAnn
tn VarAnn
vn Ty
mt, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr ('TBytes : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBytes : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr ('TBytes : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TBytes : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr ('TBytes : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
tns :: Notes tn) -> do
      case TypeAnn -> Notes t -> Notes ('TOption t)
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TOption t1)
NTOption TypeAnn
tn Notes t
tns of
        (Notes ('TOption t)
ns :: Notes ('TOption t1)) -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TOption t1) ((WellTyped ('TOption t) =>
  TypeCheckInstr (SomeInstr ('TBytes : xs)))
 -> TypeCheckInstr (SomeInstr ('TBytes : xs)))
-> (WellTyped ('TOption t) =>
    TypeCheckInstr (SomeInstr ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ do
          Dict (UnpackedValScope t)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @tn ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
            (Either BadTypeForScope (Dict (UnpackedValScope t))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (UnpackedValScope t)))
-> Either BadTypeForScope (Dict (UnpackedValScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (UnpackedValScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(UnpackedValScope tn)
          SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t]
-> Instr ('TBytes : xs) ('TOption t : xs)
forall (a :: T) (s :: [T]).
(UnpackedValScope a, SingI a) =>
Anns '[TypeAnn, VarAnn, Notes a]
-> Instr ('TBytes : s) ('TOption a : s)
AnnUNPACK (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
tns) Instr ('TBytes : xs) ('TOption t : xs)
-> HST ('TOption t : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TOption t) -> Sing ('TOption t)
forall (t :: T). Notes t -> Sing t
notesSing Notes ('TOption t)
ns, Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption t), Dict (WellTyped ('TOption t)))
-> HST xs -> HST ('TOption t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.UNPACK {}, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.UNPACK {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.PACK VarAnn
vn, (SingT x
_ :: SingT a, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Dict (PackedValScope x)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
      (Either BadTypeForScope (Dict (PackedValScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (PackedValScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(PackedValScope a)
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : xs) ('TBytes : xs)
forall (a :: T) (s :: [T]).
PackedValScope a =>
AnnVar -> Instr (a : s) ('TBytes : s)
AnnPACK (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.PACK VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.CONCAT VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TBytes : 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, inp ~ (c : c : rs), WellTyped c,
 MonadReader TypeCheckInstrEnv m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
vn, (STString{}, Dict (WellTyped x)
_) ::& (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TString : 'TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TString : 'TString : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TString : 'TString : xs)))
-> TypeCheckInstr (SomeInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TString : 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, inp ~ (c : c : rs), WellTyped c,
 MonadReader TypeCheckInstrEnv m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
vn, (STList Sing n
SingT n
STBytes, Dict (WellTyped x)
_) ::& HST xs
_) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TList 'TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, WellTyped c, inp ~ ('TList c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl' HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
vn, (STList Sing n
SingT n
STString, Dict (WellTyped x)
_) ::& HST xs
_) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TList 'TString : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TString : xs)))
-> TypeCheckInstr (SomeInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, WellTyped c, inp ~ ('TList c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl' HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"string" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"string"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bytes"])
      , (Text
"list string" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"list string"])
      , (Text
"list bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"list bytes"])
      ]
  (U.CONCAT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SLICE VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::&
               (STNat{}, Dict (WellTyped x)
_) ::&
               (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TNat : 'TNat : 'TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TString : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TNat : 'TNat : 'TString : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TNat : 'TNat : 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SliceOp c, inp ~ ('TNat : 'TNat : c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sliceImpl HST inp
inp VarAnn
vn
  (U.SLICE VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::&
               (STNat{}, Dict (WellTyped x)
_) ::&
               (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TNat : 'TNat : 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TNat : 'TNat : 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TNat : 'TNat : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SliceOp c, inp ~ ('TNat : 'TNat : c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sliceImpl HST inp
inp VarAnn
vn

  (U.SLICE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat", Text
"string"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat", Text
"bytes"])
      ]
  (U.SLICE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.ISNAT VarAnn
vn', (STInt{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TInt : xs) ('TOption 'TNat : xs)
forall (s :: [T]). AnnVar -> Instr ('TInt : s) ('TOption 'TNat : s)
AnnISNAT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn') Instr ('TInt : xs) ('TOption 'TNat : xs)
-> HST ('TOption 'TNat : xs) -> SomeInstrOut ('TInt : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOption 'TNat)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TOption 'TNat))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption 'TNat), Dict (WellTyped ('TOption 'TNat)))
-> HST xs -> HST ('TOption 'TNat : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.ISNAT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.ISNAT VarAnn
_, HST inp
SNil)-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  -- Type checking is already done inside `addImpl`.
  (U.ADD VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
addImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr

  (U.ADD VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SUB VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
subImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr

  (U.SUB VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SUB_MUTEZ VarAnn
vn, (SingT x
STMutez, Dict (WellTyped x)
_) ::& (SingT x
STMutez, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMutez : 'TMutez : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TMutez : 'TMutez : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TMutez : 'TMutez : xs)))
-> TypeCheckInstr (SomeInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMutez : 'TMutez : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @SubMutez AnnVar
-> Instr
     ('TMutez : 'TMutez : xs) (ArithRes SubMutez 'TMutez 'TMutez : xs)
forall (s :: [T]).
AnnVar -> Instr ('TMutez : 'TMutez : s) ('TOption 'TMutez : s)
AnnSUB_MUTEZ HST inp
HST ('TMutez : 'TMutez : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.SUB_MUTEZ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"mutez" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"mutez"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.SUB_MUTEZ VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.MUL VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
mulImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr

  (U.MUL VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.EDIV VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SingI rs, Each '[SingI] '[a, b], inp ~ (a : b : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
edivImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr

  (U.EDIV VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.ABS VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Abs (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Abs 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Abs n =>
AnnVar -> Instr (n : s) (UnaryArithRes Abs n : s)
AnnABS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.ABS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.ABS VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.NEG VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Neg 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.NEG VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TNat : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TNat : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TNat : xs)))
-> SomeInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TNat : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Neg (AnnVar -> Instr ('TNat : xs) (UnaryArithRes Neg 'TNat : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TNat : xs)
inp VarAnn
vn
  (U.NEG VarAnn
vn, (SingT x
STBls12381Fr, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TBls12381Fr : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBls12381Fr : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBls12381Fr : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TBls12381Fr : xs)))
-> SomeInstr ('TBls12381Fr : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar
-> Instr ('TBls12381Fr : xs) (UnaryArithRes Neg 'TBls12381Fr : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBls12381Fr : xs)
inp VarAnn
vn
  (U.NEG VarAnn
vn, (SingT x
STBls12381G1, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TBls12381G1 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBls12381G1 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBls12381G1 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TBls12381G1 : xs)))
-> SomeInstr ('TBls12381G1 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBls12381G1 : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar
-> Instr ('TBls12381G1 : xs) (UnaryArithRes Neg 'TBls12381G1 : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBls12381G1 : xs)
inp VarAnn
vn
  (U.NEG VarAnn
vn, (SingT x
STBls12381G2, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TBls12381G2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBls12381G2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBls12381G2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TBls12381G2 : xs)))
-> SomeInstr ('TBls12381G2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBls12381G2 : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar
-> Instr ('TBls12381G2 : xs) (UnaryArithRes Neg 'TBls12381G2 : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBls12381G2 : xs)
inp VarAnn
vn
  (U.NEG VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"bls12_381_fr" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"bls12_381_g1" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"bls12_381_g2" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      ]
  (U.NEG VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LSL VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Lsl AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes Lsl 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Lsl n m =>
AnnVar -> Instr (n : m : s) (ArithRes Lsl n m : s)
AnnLSL HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.LSL VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.LSL VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LSR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Lsr AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes Lsr 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Lsr n m =>
AnnVar -> Instr (n : m : s) (ArithRes Lsr n m : s)
AnnLSR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.LSR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.LSR VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.OR VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
            (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Or AnnVar
-> Instr ('TBool : 'TBool : xs) (ArithRes Or 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Or n m =>
AnnVar -> Instr (n : m : s) (ArithRes Or n m : s)
AnnOR HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.OR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
            (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Or AnnVar -> Instr ('TNat : 'TNat : xs) (ArithRes Or 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Or n m =>
AnnVar -> Instr (n : m : s) (ArithRes Or n m : s)
AnnOR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.OR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])
      ]
  (U.OR VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.AND VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And AnnVar
-> Instr ('TInt : 'TNat : xs) (ArithRes And 'TInt 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
AnnVar -> Instr (n : m : s) (ArithRes And n m : s)
AnnAND HST inp
HST ('TInt : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.AND VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes And 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
AnnVar -> Instr (n : m : s) (ArithRes And n m : s)
AnnAND HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.AND VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
             (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And AnnVar
-> Instr ('TBool : 'TBool : xs) (ArithRes And 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
AnnVar -> Instr (n : m : s) (ArithRes And n m : s)
AnnAND HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.AND VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])
      , (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool"])
      ]
  (U.AND VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.XOR VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
             (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Xor AnnVar
-> Instr ('TBool : 'TBool : xs) (ArithRes Xor 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Xor n m =>
AnnVar -> Instr (n : m : s) (ArithRes Xor n m : s)
AnnXOR HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.XOR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Xor AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes Xor 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Xor n m =>
AnnVar -> Instr (n : m : s) (ArithRes Xor n m : s)
AnnXOR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
  (U.XOR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])
      ]
  (U.XOR VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.NOT VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TNat : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TNat : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TNat : xs)))
-> SomeInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TNat : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Not (AnnVar -> Instr ('TNat : xs) (UnaryArithRes Not 'TNat : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Not n =>
AnnVar -> Instr (n : s) (UnaryArithRes Not n : s)
AnnNOT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TNat : xs)
inp VarAnn
vn
  (U.NOT VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TBool : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBool : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBool : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TBool : xs)))
-> SomeInstr ('TBool : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TBool : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Not (AnnVar -> Instr ('TBool : xs) (UnaryArithRes Not 'TBool : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Not n =>
AnnVar -> Instr (n : s) (UnaryArithRes Not n : s)
AnnNOT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBool : xs)
inp VarAnn
vn
  (U.NOT VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
 n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Not (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Not 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Not n =>
AnnVar -> Instr (n : s) (UnaryArithRes Not n : s)
AnnNOT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.NOT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
      (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
      [ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      , (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      ]
  (U.NOT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.COMPARE VarAnn
vn,
        (SingT x
_ :: SingT aT, Dict (WellTyped x)
_)
    ::& (SingT x
_ :: SingT bT, Dict (WellTyped x)
_)
    ::& HST xs
rs
    )
    -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
    case forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @aT @bT of
      Right x :~: x
Refl -> do
        Dict (ComparabilityScope x)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @aT (VarAnn -> ExpandedInstr
forall op. VarAnn -> InstrAbstract op
U.COMPARE VarAnn
vn) (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ComparisonArguments)
          (Either BadTypeForScope (Dict (ComparabilityScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ComparabilityScope x)))
-> Either BadTypeForScope (Dict (ComparabilityScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ComparabilityScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ComparabilityScope aT)
        case Dict (ComparabilityScope x)
proofScope of
          Dict (ComparabilityScope x)
Dict ->
            SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : x : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
(Comparable n, SingI n) =>
AnnVar -> Instr (n : n : s) ('TInt : s)
AnnCOMPARE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : x : xs) ('TInt : xs)
-> HST ('TInt : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TInt
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TInt, Dict (WellTyped 'TInt)) -> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

      Left TCTypeError
err -> do
        ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : x : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ComparisonArguments) TCTypeError
err

  (U.COMPARE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.EQ VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Eq' (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Eq' 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Eq' n =>
AnnVar -> Instr (n : s) (UnaryArithRes Eq' n : s)
AnnEQ (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.EQ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.EQ VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.NEQ VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Neq (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Neq 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neq n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neq n : s)
AnnNEQ (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.NEQ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.NEQ VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LT VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Lt (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Lt 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Lt n =>
AnnVar -> Instr (n : s) (UnaryArithRes Lt n : s)
AnnLT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.LT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.LT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.GT VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Gt (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Gt 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Gt n =>
AnnVar -> Instr (n : s) (UnaryArithRes Gt n : s)
AnnGT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.GT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.GT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.LE VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Le (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Le 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Le n =>
AnnVar -> Instr (n : s) (UnaryArithRes Le n : s)
AnnLE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.LE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.LE VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.GE VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
       (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Ge (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Ge 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Ge n =>
AnnVar -> Instr (n : s) (UnaryArithRes Ge n : s)
AnnGE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
  (U.GE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.GE VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.INT VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TNat : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
ToIntArithOp n =>
AnnVar -> Instr (n : s) ('TInt : s)
AnnINT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TNat : xs) ('TInt : xs)
-> HST ('TInt : xs) -> SomeInstrOut ('TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TInt
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TInt, Dict (WellTyped 'TInt)) -> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.INT VarAnn
vn, (STBls12381Fr{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBls12381Fr : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
ToIntArithOp n =>
AnnVar -> Instr (n : s) ('TInt : s)
AnnINT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBls12381Fr : xs) ('TInt : xs)
-> HST ('TInt : xs) -> SomeInstrOut ('TBls12381Fr : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TInt
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TInt, Dict (WellTyped 'TInt)) -> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.INT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| [Text
"bls12_381_fr" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []]
  (U.INT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.VIEW VarAnn
vn ViewName
name (AsUType (Notes t
retNotes :: Notes ret)), (SingT x, Dict (WellTyped x))
_ ::& (STAddress{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TAddress : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TAddress : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TAddress : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @ret ((WellTyped t => TypeCheckInstr (SomeInstr (x : 'TAddress : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TAddress : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (x : 'TAddress : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
forall a b. (a -> b) -> a -> b
$ do
        Dict (ViewableScope t)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @ret ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
              (Either BadTypeForScope (Dict (ViewableScope t))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ViewableScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope ret)
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t]
-> ViewName -> Instr (x : 'TAddress : xs) ('TOption t : xs)
forall (arg :: T) (ret :: T) (s :: [T]).
(SingI arg, ViewableScope ret) =>
Anns '[VarAnn, Notes ret]
-> ViewName -> Instr (arg : 'TAddress : s) ('TOption ret : s)
AnnVIEW (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
retNotes) ViewName
name Instr (x : 'TAddress : xs) ('TOption t : xs)
-> HST ('TOption t : xs) -> SomeInstrOut (x : 'TAddress : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TOption t)
forall (n :: T). Sing n -> SingT ('TOption n)
STOption (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
retNotes), Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption t), Dict (WellTyped ('TOption t)))
-> HST xs -> HST ('TOption t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.VIEW{}, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'arg" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"address"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.VIEW{}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SELF VarAnn
vn RootAnn
fn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> (IsNotInView => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
    TypeCheckMode
mode <- (TypeCheckEnv -> TypeCheckMode)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     TypeCheckMode
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckEnv -> TypeCheckMode
tcMode
    case TypeCheckMode
mode of
      TypeCheckValue (Value
value, T
ty) Maybe BigMapFinder
_ ->
        Value
-> T -> Text -> Maybe TCTypeError -> TypeCheckInstr (SomeInstr inp)
forall a.
Value -> T -> Text -> Maybe TCTypeError -> TypeCheckInstr a
tcFailedOnValue Value
value T
ty Text
"The SELF instruction cannot appear in a lambda" Maybe TCTypeError
forall a. Maybe a
Nothing
      TypeCheckContract (SomeParamType ParamNotes t
notescp) -> do
        let epName :: EpName
epName = RootAnn -> EpName
U.epNameFromSelfAnn RootAnn
fn
        MkEntrypointCallRes (Notes arg
argNotes :: Notes arg) EntrypointCallT t arg
epc <-
          EpName -> ParamNotes t -> Maybe (MkEntrypointCallRes t)
forall (param :: T).
ParameterScope param =>
EpName -> ParamNotes param -> Maybe (MkEntrypointCallRes param)
mkEntrypointCall EpName
epName ParamNotes t
notescp
            Maybe (MkEntrypointCallRes t)
-> (Maybe (MkEntrypointCallRes t)
    -> Either TCTypeError (MkEntrypointCallRes t))
-> Either TCTypeError (MkEntrypointCallRes t)
forall a b. a -> (a -> b) -> b
& TCTypeError
-> Maybe (MkEntrypointCallRes t)
-> Either TCTypeError (MkEntrypointCallRes t)
forall l r. l -> Maybe r -> Either l r
maybeToRight (EpName -> TCTypeError
EntrypointNotFound EpName
epName)
            Either TCTypeError (MkEntrypointCallRes t)
-> (Either TCTypeError (MkEntrypointCallRes t)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (MkEntrypointCallRes t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (MkEntrypointCallRes t)
forall a b. a -> (a -> b) -> b
& ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (MkEntrypointCallRes t)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (MkEntrypointCallRes t)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing

        case TypeAnn -> Notes arg -> Notes ('TContract arg)
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TContract t1)
NTContract TypeAnn
forall {k} (a :: k). Annotation a
U.noAnn Notes arg
argNotes of
                (Notes ('TContract arg)
ntRes :: Notes ('TContract t1)) ->
                  forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TContract t1) ((WellTyped ('TContract arg) => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TContract arg) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
                    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ forall (arg :: T) (inp :: [T]).
(ParameterScope arg, IsNotInView) =>
AnnVar
-> SomeEntrypointCallT arg -> Instr inp ('TContract arg : inp)
AnnSELF @arg (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) (EntrypointCallT t arg -> SomeEntrypointCallT arg
forall (arg :: T) (param :: T).
ParameterScope param =>
EntrypointCallT param arg -> SomeEntrypointCallT arg
SomeEpc EntrypointCallT t arg
epc) Instr inp ('TContract arg : inp)
-> HST ('TContract arg : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TContract arg) -> Sing ('TContract arg)
forall (t :: T). Notes t -> Sing t
notesSing Notes ('TContract arg)
ntRes, Dict (WellTyped ('TContract arg))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TContract arg), Dict (WellTyped ('TContract arg)))
-> HST inp -> HST ('TContract arg : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
      TypeCheckMode
TypeCheckTest ->
        TCTypeError -> TypeCheckInstr (SomeInstr inp)
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr (SomeInstr inp))
-> TCTypeError -> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"'SELF' appears in test typechecking"
  (U.CONTRACT VarAnn
vn RootAnn
fn Ty
mt, (STAddress{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TAddress : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TAddress : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TAddress : xs)))
-> TypeCheckInstr (SomeInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr ('TAddress : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TAddress : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
  SingI t =>
  Notes t
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       (SomeInstr ('TAddress : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ('TAddress : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr ('TAddress : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
tns :: Notes t) -> do
      Dict (ParameterScope t)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractParameter)
        (Either BadTypeForScope (Dict (ParameterScope t))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ParameterScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope t)
      let ns :: Notes ('TOption ('TContract t))
ns = TypeAnn -> Notes ('TContract t) -> Notes ('TOption ('TContract t))
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TOption t1)
NTOption TypeAnn
forall a. Default a => a
def (Notes ('TContract t) -> Notes ('TOption ('TContract t)))
-> Notes ('TContract t) -> Notes ('TOption ('TContract t))
forall a b. (a -> b) -> a -> b
$ TypeAnn -> Notes t -> Notes ('TContract t)
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TContract t1)
NTContract TypeAnn
forall a. Default a => a
def Notes t
tns
      EpName
epName <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError EpName
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     EpName
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
        (Either TCTypeError EpName
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      EpName)
-> Either TCTypeError EpName
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     EpName
forall a b. (a -> b) -> a -> b
$ RootAnn -> Either EpNameFromRefAnnError EpName
epNameFromRefAnn RootAnn
fn Either EpNameFromRefAnnError EpName
-> (EpNameFromRefAnnError -> TCTypeError)
-> Either TCTypeError EpName
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` EpNameFromRefAnnError -> TCTypeError
IllegalEntrypoint
      case Dict (ParameterScope t)
proofScope of
        Dict (ParameterScope t)
Dict ->
          forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr ('TAddress : xs)))
 -> TypeCheckInstr (SomeInstr ('TAddress : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr ('TAddress : xs)))
-> TypeCheckInstr (SomeInstr ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t]
-> EpName -> Instr ('TAddress : xs) ('TOption ('TContract t) : xs)
forall (p :: T) (s :: [T]).
ParameterScope p =>
Anns '[VarAnn, Notes p]
-> EpName -> Instr ('TAddress : s) ('TOption ('TContract p) : s)
AnnCONTRACT (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
tns) EpName
epName Instr ('TAddress : xs) ('TOption ('TContract t) : xs)
-> HST ('TOption ('TContract t) : xs)
-> SomeInstrOut ('TAddress : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TOption ('TContract t)) -> Sing ('TOption ('TContract t))
forall (t :: T). Notes t -> Sing t
notesSing Notes ('TOption ('TContract t))
ns, Dict (WellTyped ('TOption ('TContract t)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TContract t)),
 Dict (WellTyped ('TOption ('TContract t))))
-> HST xs -> HST ('TOption ('TContract t) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CONTRACT {}, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"address" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.CONTRACT {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.TRANSFER_TOKENS VarAnn
vn, ((SingT x
_ :: SingT p'), Dict (WellTyped x)
_)
    ::& (STMutez{}, Dict (WellTyped x)
_)
    ::& (STContract (Sing n
s :: Sing p), Dict (WellTyped x)
_) ::& HST xs
rs) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall a b. (a -> b) -> a -> b
$
      ExpandedInstr
-> (IsNotInView =>
    TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
        Dict (ParameterScope n)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @p ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractParameter)
          (Either BadTypeForScope (Dict (ParameterScope n))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (ParameterScope n)))
-> Either BadTypeForScope (Dict (ParameterScope n))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (ParameterScope n))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope p)
        case (forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @p @p', Dict (ParameterScope n)
proofScope) of
          (Right n :~: x
Refl, Dict (ParameterScope x)
Dict (ParameterScope n)
Dict) ->
            SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr (x : 'TMutez : 'TContract x : xs) ('TOperation : xs)
forall (p :: T) (s :: [T]).
(ParameterScope p, IsNotInView) =>
AnnVar -> Instr (p : 'TMutez : 'TContract p : s) ('TOperation : s)
AnnTRANSFER_TOKENS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TMutez : 'TContract x : xs) ('TOperation : xs)
-> HST ('TOperation : xs)
-> SomeInstrOut (x : 'TMutez : 'TContract x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
          (Left TCTypeError
m, Dict (ParameterScope n)
_) ->
            ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : 'TMutez : 'TContract n : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractParameter) TCTypeError
m

  (U.TRANSFER_TOKENS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'p" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"mutez", Text
"contract 'p"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.TRANSFER_TOKENS VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SET_DELEGATE VarAnn
vn,
    (STOption Sing n
SingT n
STKeyHash, Dict (WellTyped x)
_)
    ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TOption 'TKeyHash : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TOption 'TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TOption 'TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> (IsNotInView =>
    TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TOption 'TKeyHash : xs) ('TOperation : xs)
forall (s :: [T]).
IsNotInView =>
AnnVar -> Instr ('TOption 'TKeyHash : s) ('TOperation : s)
AnnSET_DELEGATE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TOption 'TKeyHash : xs) ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeInstrOut ('TOption 'TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.SET_DELEGATE VarAnn
_,  (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"option key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.SET_DELEGATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.CREATE_CONTRACT VarAnn
ovn VarAnn
avn Contract
contract,
    (STOption Sing n
SingT n
STKeyHash, Dict (WellTyped x)
_)
    ::& (STMutez{}, Dict (WellTyped x)
_)
    ::& (SingT x
_ :: SingT g, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr
     (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TOption 'TKeyHash : 'TMutez : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> TypeCheckInstr
     (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TOption 'TKeyHash : 'TMutez : x : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> (IsNotInView =>
    TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> TypeCheckInstr
     (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
      (SomeContract contr :: Contract cp st
contr@(Contract ContractCode' Instr cp st
_ ParamNotes cp
_ (Notes st
_ :: Notes st) ViewsSet' Instr st
_ EntriesOrder
_))
        <- ReaderT
  TypeCheckEnv
  (ReaderT TypeCheckOptions (ExceptT TCError Identity))
  SomeContract
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     SomeContract
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT
   TypeCheckEnv
   (ReaderT TypeCheckOptions (ExceptT TCError Identity))
   SomeContract
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      SomeContract)
-> ReaderT
     TypeCheckEnv
     (ReaderT TypeCheckOptions (ExceptT TCError Identity))
     SomeContract
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     SomeContract
forall a b. (a -> b) -> a -> b
$ Contract -> TypeCheck SomeContract
typeCheckContractImpl Contract
contract
      x :~: st
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (x :~: st)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (x :~: st)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractStorage) (Either TCTypeError (x :~: st)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (x :~: st))
-> Either TCTypeError (x :~: st)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (x :~: st)
forall a b. (a -> b) -> a -> b
$
        forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @g @st
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure
        (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, VarAnn]
-> Contract cp st
-> Instr
     ('TOption 'TKeyHash : 'TMutez : st : xs)
     ('TOperation : 'TAddress : xs)
forall (p :: T) (g :: T) (s :: [T]).
(ParameterScope p, StorageScope g, IsNotInView) =>
Anns '[VarAnn, VarAnn]
-> Contract' Instr p g
-> Instr
     ('TOption 'TKeyHash : 'TMutez : g : s)
     ('TOperation : 'TAddress : s)
AnnCREATE_CONTRACT (VarAnn -> VarAnn -> Anns '[VarAnn, VarAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 VarAnn
ovn VarAnn
avn) Contract cp st
contr
        Instr
  ('TOption 'TKeyHash : 'TMutez : st : xs)
  ('TOperation : 'TAddress : xs)
-> HST ('TOperation : 'TAddress : xs)
-> SomeInstrOut ('TOption 'TKeyHash : 'TMutez : st : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST ('TAddress : xs) -> HST ('TOperation : 'TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST xs -> HST ('TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CREATE_CONTRACT {}, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"option key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"mutez", Text
"'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

  (U.CREATE_CONTRACT {},  HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.IMPLICIT_ACCOUNT VarAnn
vn, (STKeyHash{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKeyHash : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKeyHash : xs) ('TContract 'TUnit : xs)
forall (s :: [T]).
AnnVar -> Instr ('TKeyHash : s) ('TContract 'TUnit : s)
AnnIMPLICIT_ACCOUNT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKeyHash : xs) ('TContract 'TUnit : xs)
-> HST ('TContract 'TUnit : xs) -> SomeInstrOut ('TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TContract 'TUnit)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TContract 'TUnit))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TContract 'TUnit), Dict (WellTyped ('TContract 'TUnit)))
-> HST xs -> HST ('TContract 'TUnit : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.IMPLICIT_ACCOUNT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.IMPLICIT_ACCOUNT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.NOW VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TTimestamp : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TTimestamp : inp)
AnnNOW (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TTimestamp : inp)
-> HST ('TTimestamp : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TTimestamp
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TTimestamp)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TTimestamp, Dict (WellTyped 'TTimestamp))
-> HST inp -> HST ('TTimestamp : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.AMOUNT VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TMutez : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TMutez : inp)
AnnAMOUNT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TMutez : inp)
-> HST ('TMutez : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TMutez
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TMutez)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TMutez, Dict (WellTyped 'TMutez))
-> HST inp -> HST ('TMutez : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.BALANCE VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TMutez : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TMutez : inp)
AnnBALANCE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TMutez : inp)
-> HST ('TMutez : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TMutez
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TMutez)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TMutez, Dict (WellTyped 'TMutez))
-> HST inp -> HST ('TMutez : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.VOTING_POWER VarAnn
vn, (STKeyHash{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKeyHash : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKeyHash : xs) ('TNat : xs)
forall (s :: [T]). AnnVar -> Instr ('TKeyHash : s) ('TNat : s)
AnnVOTING_POWER (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKeyHash : xs) ('TNat : xs)
-> HST ('TNat : xs) -> SomeInstrOut ('TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat)) -> HST xs -> HST ('TNat : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.VOTING_POWER VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.VOTING_POWER VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.TOTAL_VOTING_POWER VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TNat : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TNat : inp)
AnnTOTAL_VOTING_POWER (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat))
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.CHECK_SIGNATURE VarAnn
vn,
             (STKey{}, Dict (WellTyped x)
_)
             ::& (STSignature{}, Dict (WellTyped x)
_) ::& (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TKey : 'TSignature : 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKey : 'TSignature : 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TKey : 'TSignature : 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TKey : 'TSignature : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKey : 'TSignature : 'TBytes : xs) ('TBool : xs)
forall (s :: [T]).
AnnVar -> Instr ('TKey : 'TSignature : 'TBytes : s) ('TBool : s)
AnnCHECK_SIGNATURE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKey : 'TSignature : 'TBytes : xs) ('TBool : xs)
-> HST ('TBool : xs)
-> SomeInstrOut ('TKey : 'TSignature : 'TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBool
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBool)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBool, Dict (WellTyped 'TBool))
-> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CHECK_SIGNATURE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"signature", Text
"bytes"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.CHECK_SIGNATURE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SHA256 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnSHA256 (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.SHA256 VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.SHA256 VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SHA512 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnSHA512 (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.SHA512 VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.SHA512 VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.BLAKE2B VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnBLAKE2B (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.BLAKE2B VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.BLAKE2B VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SHA3 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnSHA3 (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.SHA3 VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.SHA3 VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.KECCAK VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnKECCAK (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.KECCAK VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.KECCAK VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.HASH_KEY VarAnn
vn, (STKey{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKey : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKey : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKey : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKey : xs)))
-> TypeCheckInstr (SomeInstr ('TKey : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKey : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKey : xs) ('TKeyHash : xs)
forall (s :: [T]). AnnVar -> Instr ('TKey : s) ('TKeyHash : s)
AnnHASH_KEY (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKey : xs) ('TKeyHash : xs)
-> HST ('TKeyHash : xs) -> SomeInstrOut ('TKey : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TKeyHash
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TKeyHash)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TKeyHash, Dict (WellTyped 'TKeyHash))
-> HST xs -> HST ('TKeyHash : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.HASH_KEY VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.HASH_KEY VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.PAIRING_CHECK VarAnn
vn, (STList (STPair Sing n1
SingT n1
STBls12381G1 Sing n2
SingT n2
STBls12381G2), Dict (WellTyped x)
_) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr
     (SomeInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr
   (SomeInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs)))
-> TypeCheckInstr
     (SomeInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
     ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs) ('TBool : xs)
forall (s :: [T]).
AnnVar
-> Instr
     ('TList ('TPair 'TBls12381G1 'TBls12381G2) : s) ('TBool : s)
AnnPAIRING_CHECK (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
  ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs) ('TBool : xs)
-> HST ('TBool : xs)
-> SomeInstrOut ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBool
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBool)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBool, Dict (WellTyped 'TBool))
-> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.PAIRING_CHECK VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list (pair bls12_381_g1 bls12_381_g2)" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.PAIRING_CHECK VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SOURCE VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TAddress : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TAddress : inp)
AnnSOURCE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.SENDER VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TAddress : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TAddress : inp)
AnnSENDER (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.ADDRESS VarAnn
vn, (STContract{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TContract n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TContract n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TContract n : xs)))
-> TypeCheckInstr (SomeInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TContract n : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TContract n : xs) ('TAddress : xs)
forall (a :: T) (s :: [T]).
AnnVar -> Instr ('TContract a : s) ('TAddress : s)
AnnADDRESS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TContract n : xs) ('TAddress : xs)
-> HST ('TAddress : xs) -> SomeInstrOut ('TContract n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST xs -> HST ('TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.ADDRESS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"contract 'p" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.ADDRESS VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.CHAIN_ID VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TChainId : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TChainId : inp)
AnnCHAIN_ID (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TChainId : inp)
-> HST ('TChainId : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TChainId
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TChainId)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TChainId, Dict (WellTyped 'TChainId))
-> HST inp -> HST ('TChainId : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.LEVEL VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TNat : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TNat : inp)
AnnLEVEL (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat))
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.SELF_ADDRESS VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TAddress : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TAddress : inp)
AnnSELF_ADDRESS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (ExpandedInstr
U.NEVER, (STNever{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNever : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNever : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNever : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNever : xs)))
-> TypeCheckInstr (SomeInstr ('TNever : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNever : xs))
forall a b. (a -> b) -> a -> b
$
    SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ (forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
AnyOutInstr forall (out :: [T]). Instr inp out
forall (s :: [T]) (out :: [T]). Instr ('TNever : s) out
NEVER
  (ExpandedInstr
U.NEVER, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"never" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (ExpandedInstr
U.NEVER, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.TICKET VarAnn
vn, (Sing x
stVal :: Sing v, Dict (WellTyped x)
_) ::& (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped x => TypeCheckInstr (SomeInstr (x : 'TNat : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TNat : xs)))
-> (WellTyped x => TypeCheckInstr (SomeInstr (x : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> ExpandedInstr
-> HST inp
-> (Comparable x => SomeInstr (x : 'TNat : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : 'TNat : xs))
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck Sing x
stVal ExpandedInstr
uInstr HST inp
inp ((Comparable x => SomeInstr (x : 'TNat : xs))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr (x : 'TNat : xs)))
-> (Comparable x => SomeInstr (x : 'TNat : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : 'TNat : xs) ('TTicket x : xs)
forall (a :: T) (s :: [T]).
Comparable a =>
AnnVar -> Instr (a : 'TNat : s) ('TTicket a : s)
AnnTICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TNat : xs) ('TTicket x : xs)
-> HST ('TTicket x : xs) -> SomeInstrOut (x : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TTicket x)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TTicket x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TTicket x), Dict (WellTyped ('TTicket x)))
-> HST xs -> HST ('TTicket x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.TICKET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"a'" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.TICKET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.READ_TICKET VarAnn
vn, ticket :: (SingT x, Dict (WellTyped x))
ticket@(STTicket{}, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TTicket n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TTicket n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TTicket n : xs)))
-> TypeCheckInstr (SomeInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TTicket n : xs))
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
     ('TTicket n : xs)
     (RightComb '[ 'TAddress, n, 'TNat] : 'TTicket n : xs)
forall (a :: T) (s :: [T]).
AnnVar
-> Instr
     ('TTicket a : s)
     (RightComb '[ 'TAddress, a, 'TNat] : 'TTicket a : s)
AnnREAD_TICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
  ('TTicket n : xs) ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
-> HST ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
-> SomeInstrOut ('TTicket n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TPair 'TAddress ('TPair n 'TNat))
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TPair 'TAddress ('TPair n 'TNat)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair 'TAddress ('TPair n 'TNat)),
 Dict (WellTyped ('TPair 'TAddress ('TPair n 'TNat))))
-> HST (x : xs) -> HST ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
ticket (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.READ_TICKET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"ticket 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.READ_TICKET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SPLIT_TICKET VarAnn
vn, (STTicket{}, Dict (WellTyped x)
Dict) ::& (STPair STNat{} STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr
     (SomeInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TTicket n : 'TPair 'TNat 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TTicket n : 'TPair 'TNat 'TNat : xs)))
-> TypeCheckInstr
     (SomeInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TTicket n : 'TPair 'TNat 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
     ('TTicket n : 'TPair 'TNat 'TNat : xs)
     ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
forall (a :: T) (s :: [T]).
AnnVar
-> Instr
     ('TTicket a : 'TPair 'TNat 'TNat : s)
     ('TOption ('TPair ('TTicket a) ('TTicket a)) : s)
AnnSPLIT_TICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
  ('TTicket n : 'TPair 'TNat 'TNat : xs)
  ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
-> HST ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
-> SomeInstrOut ('TTicket n : 'TPair 'TNat 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOption ('TPair ('TTicket n) ('TTicket n)))
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TOption ('TPair ('TTicket n) ('TTicket n))))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TPair ('TTicket n) ('TTicket n))),
 Dict (WellTyped ('TOption ('TPair ('TTicket n) ('TTicket n)))))
-> HST xs -> HST ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.SPLIT_TICKET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair nat nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"ticket 'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.SPLIT_TICKET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.JOIN_TICKETS VarAnn
vn,
     (STPair (nt1 :: SingT n1
nt1@STTicket{} :: SingT t1) (STTicket{} :: SingT t2), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr
     (SomeInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TPair ('TTicket n) ('TTicket n) : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair ('TTicket n) ('TTicket n) : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TPair ('TTicket n) ('TTicket n) : xs)))
-> TypeCheckInstr
     (SomeInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TPair ('TTicket n) ('TTicket n) : xs))
forall a b. (a -> b) -> a -> b
$ do
      n1 :~: n2
Refl <-
        ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (n1 :~: n2)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (n1 :~: n2)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
TicketsJoin) (Either TCTypeError (n1 :~: n2)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (n1 :~: n2))
-> Either TCTypeError (n1 :~: n2)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (n1 :~: n2)
forall a b. (a -> b) -> a -> b
$
          forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t2
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
     ('TPair ('TTicket n) ('TTicket n) : xs)
     ('TOption ('TTicket n) : xs)
forall (a :: T) (s :: [T]).
AnnVar
-> Instr
     ('TPair ('TTicket a) ('TTicket a) : s) ('TOption ('TTicket a) : s)
AnnJOIN_TICKETS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
  ('TPair ('TTicket n) ('TTicket n) : xs)
  ('TOption ('TTicket n) : xs)
-> HST ('TOption ('TTicket n) : xs)
-> SomeInstrOut ('TPair ('TTicket n) ('TTicket n) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing ('TTicket n) -> SingT ('TOption ('TTicket n))
forall (n :: T). Sing n -> SingT ('TOption n)
STOption Sing ('TTicket n)
SingT n1
nt1, Dict (WellTyped ('TOption ('TTicket n)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TTicket n)),
 Dict (WellTyped ('TOption ('TTicket n))))
-> HST xs -> HST ('TOption ('TTicket n) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.JOIN_TICKETS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair (ticket 'a) (ticket 'a)" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.JOIN_TICKETS VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.OPEN_CHEST VarAnn
vn,
      (SingT x
STChestKey, Dict (WellTyped x)
Dict)
      ::& (SingT x
STChest, Dict (WellTyped x)
Dict)
      ::& (SingT x
STNat, Dict (WellTyped x)
Dict)
      ::& HST xs
rs) ->
      ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TChestKey : 'TChest : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TChestKey : 'TChest : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TChestKey : 'TChest : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TChestKey : 'TChest : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$ do
        SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
     ('TChestKey : 'TChest : 'TNat : xs) ('TOr 'TBytes 'TBool : xs)
forall (s :: [T]).
AnnVar
-> Instr
     ('TChestKey : 'TChest : 'TNat : s) ('TOr 'TBytes 'TBool : s)
AnnOPEN_CHEST (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
  ('TChestKey : 'TChest : 'TNat : xs) ('TOr 'TBytes 'TBool : xs)
-> HST ('TOr 'TBytes 'TBool : xs)
-> SomeInstrOut ('TChestKey : 'TChest : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: (
          (Sing 'TBytes -> Sing 'TBool -> SingT ('TOr 'TBytes 'TBool)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TOr n1 n2)
STOr Sing 'TBytes
SingT 'TBytes
STBytes Sing 'TBool
SingT 'TBool
STBool, Dict (WellTyped ('TOr 'TBytes 'TBool))
forall (a :: Constraint). a => Dict a
Dict)
          (SingT ('TOr 'TBytes 'TBool),
 Dict (WellTyped ('TOr 'TBytes 'TBool)))
-> HST xs -> HST ('TOr 'TBytes 'TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  (U.OPEN_CHEST VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"chest_key" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"chest", Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.OPEN_CHEST VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.SAPLING_EMPTY_STATE VarAnn
vn Natural
n, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    (\(SomeSing (Sing a
s :: Sing a)) -> Sing a
-> (SingI a =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT
       TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
    (SomeInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> (SingI a =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Sing a -> Instr inp ('TSaplingState a : inp)
forall (n :: Nat) (inp :: [T]).
AnnVar -> Sing n -> Instr inp ('TSaplingState n : inp)
AnnSAPLING_EMPTY_STATE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Sing a
s Instr inp ('TSaplingState a : inp)
-> HST ('TSaplingState a : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TSaplingState a)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TSaplingState a))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TSaplingState a), Dict (WellTyped ('TSaplingState a)))
-> HST inp -> HST ('TSaplingState a : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
    ) (SomeSing Nat
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeSing Nat
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ Natural -> SomeSing Nat
Peano.someSingNat Natural
n

  (U.SAPLING_VERIFY_UPDATE VarAnn
vn,
      (STSaplingTransaction Sing n
s1, Dict (WellTyped x)
Dict)
      ::& (STSaplingState Sing n
s2, Dict (WellTyped x)
Dict)
      ::& HST xs
rs) ->
      ExpandedInstr
-> TypeCheckInstr
     (SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TSaplingTransaction n : 'TSaplingState n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr
   (SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> TypeCheckInstr
     (SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a b. (a -> b) -> a -> b
$
        case SingNat n -> SingNat n -> Maybe (n :~: n)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality Sing n
SingNat n
s1 Sing n
SingNat n
s2 of
          Just n :~: n
Refl ->
            SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
     ('TSaplingTransaction n : 'TSaplingState n : xs)
     ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
forall (n :: Nat) (s :: [T]).
AnnVar
-> Instr
     ('TSaplingTransaction n : 'TSaplingState n : s)
     ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : s)
AnnSAPLING_VERIFY_UPDATE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
  ('TSaplingTransaction n : 'TSaplingState n : xs)
  ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
-> HST
     ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
-> SomeInstrOut ('TSaplingTransaction n : 'TSaplingState n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: (
              (Sing ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))
-> SingT
     ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))))
forall (n :: T). Sing n -> SingT ('TOption n)
STOption (Sing 'TBytes
-> Sing ('TPair 'TInt ('TSaplingState n))
-> SingT ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing 'TBytes
SingT 'TBytes
STBytes (Sing 'TInt
-> Sing ('TSaplingState n)
-> SingT ('TPair 'TInt ('TSaplingState n))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing 'TInt
SingT 'TInt
STInt (Sing n -> SingT ('TSaplingState n)
forall (n :: Nat). Sing n -> SingT ('TSaplingState n)
STSaplingState Sing n
s1))), Dict
  (WellTyped
     ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))))
forall (a :: Constraint). a => Dict a
Dict)
              (SingT
   ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))),
 Dict
   (WellTyped
      ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))))))
-> HST xs
-> HST
     ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
          Maybe (n :~: n)
Nothing -> TCTypeError
-> TypeCheckInstr
     (SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
 -> TypeCheckInstr
      (SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> TCTypeError
-> TypeCheckInstr
     (SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr
            Text
"Memo sizes of two sapling states or transactions do not match."

  (U.SAPLING_VERIFY_UPDATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"sapling_transaction" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"sapling_state"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
  (U.SAPLING_VERIFY_UPDATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.EMIT{}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack

  (U.EMIT VarAnn
va RootAnn
tag Maybe Ty
mty, ((SingT x
_ :: SingT t2), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr do
      Dict (PackedValScope x)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t2 ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (PackedValScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Dict (PackedValScope x))
forall a b. (a -> b) -> a -> b
$
        forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(PackedValScope t2)
      case Maybe Ty
mty of
        Just (AsUType (Notes t
ty :: Notes t1)) -> do
          t :~: x
Refl <- Either TCTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (t :~: x)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (t :~: x)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (t :~: x))
-> Either TCTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (t :~: x)
forall a b. (a -> b) -> a -> b
$ forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t2
          SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> RootAnn -> Maybe (Notes t) -> Instr (t : xs) ('TOperation : xs)
forall (t :: T) (s :: [T]).
PackedValScope t =>
AnnVar
-> RootAnn -> Maybe (Notes t) -> Instr (t : s) ('TOperation : s)
AnnEMIT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
va) RootAnn
tag (Notes t -> Maybe (Notes t)
forall a. a -> Maybe a
Just Notes t
ty) Instr (t : xs) ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeInstrOut (t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
        Maybe Ty
Nothing ->
          SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr inp))
-> SomeInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> RootAnn -> Maybe (Notes x) -> Instr (x : xs) ('TOperation : xs)
forall (t :: T) (s :: [T]).
PackedValScope t =>
AnnVar
-> RootAnn -> Maybe (Notes t) -> Instr (t : s) ('TOperation : s)
AnnEMIT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
va) RootAnn
tag Maybe (Notes x)
forall a. Maybe a
Nothing Instr (x : xs) ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
      where
        errM :: (MonadReader TypeCheckInstrEnv m, MonadError TCError m) => Either TCTypeError a -> m a
        errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
EmitArgument)

  where
    withWTPInstr'
      :: forall t inp. SingI t
      => (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
      -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
    withWTPInstr' :: forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' = forall (t :: T) (inp :: [T]).
SingI t =>
ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp)

    withWTPInstr
      :: forall t a. SingI t => (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
    withWTPInstr :: forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr = forall (t :: T) a.
SingI t =>
ExpandedInstr
-> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp)

    failWithErr :: TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
    failWithErr :: forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr = ExpandedInstr
-> TypeCheckInstr (SomeInstr a)
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     Identity
     (TypeCheckedSeq a)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (SomeInstr a)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq a))
-> (TCTypeError
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         (SomeInstr a))
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr a)
forall a. TCTypeError -> TypeCheckInstr a
failWithErr'

    failWithErr' :: TCTypeError -> TypeCheckInstr a
    failWithErr' :: forall a. TCTypeError -> TypeCheckInstr a
failWithErr' = ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing

    notEnoughItemsOnStack :: TypeCheckInstrNoExcept (TypeCheckedSeq a)
    notEnoughItemsOnStack :: forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack = TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     Identity
     (TypeCheckedSeq a)
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr TCTypeError
NotEnoughItemsOnStack

    notEnoughItemsOnStack' :: TypeCheckInstr a
    notEnoughItemsOnStack' :: forall a. TypeCheckInstr a
notEnoughItemsOnStack' = TCTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
     (ExceptT TCError Identity)
     a
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' TCTypeError
NotEnoughItemsOnStack

    withNotInView :: U.ExpandedInstr -> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
    withNotInView :: forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
instr IsNotInView => TypeCheckInstr r
act = (TypeCheckEnv -> TypeCheckMode)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     TypeCheckMode
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckEnv -> TypeCheckMode
tcMode ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  TypeCheckMode
-> (TypeCheckMode
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         r)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      -- we provide the not-in-view constraint in the isolated mode
      TypeCheckMode
TypeCheckTest -> (IsNotInView =>
 ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   r)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     r
forall r. (IsNotInView => r) -> r
giveNotInView IsNotInView =>
ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  r
IsNotInView => TypeCheckInstr r
act
      TypeCheckMode
_ -> Getting
  (Maybe (Dict IsNotInView))
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (Maybe (Dict IsNotInView))
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Maybe (Dict IsNotInView))
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  (Maybe (Dict IsNotInView))
-> (Maybe (Dict IsNotInView)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         r)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Just Dict IsNotInView
Dict -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
  r
IsNotInView => TypeCheckInstr r
act
        Maybe (Dict IsNotInView)
Nothing -> TCTypeError -> TypeCheckInstr r
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr r)
-> TCTypeError -> TypeCheckInstr r
forall a b. (a -> b) -> a -> b
$
          ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
instr Text
"This instruction cannot be used on the top level of a view"

-- | Helper function for two-branch if where each branch is given a single
-- value.
genericIf
  :: forall bti bfi cond rs .
    (SingI bti, SingI bfi)
  => (forall s'.
        Instr bti s' ->
        Instr bfi s' ->
        Instr (cond ': rs) s'
     )
  -> (forall op. [op] -> [op] -> U.InstrAbstract op)
  -> [U.ExpandedOp]
  -> [U.ExpandedOp]
  -> HST bti
  -> HST bfi
  -> HST (cond ': rs)
  -> TypeCheckInstrNoExcept (TypeCheckedSeq (cond ': rs))
genericIf :: forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
 Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons forall op. [op] -> [op] -> InstrAbstract op
mCons [ExpandedOp]
mbt [ExpandedOp]
mbf HST bti
bti HST bfi
bfi i :: HST (cond : rs)
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_) = do
  let cons1 :: [TypeCheckedOp] -> TypeCheckedInstr
cons1 [TypeCheckedOp]
opsT = [TypeCheckedOp] -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> [op] -> InstrAbstract op
mCons [TypeCheckedOp]
opsT ((ExpandedOp -> TypeCheckedOp) -> [ExpandedOp] -> [TypeCheckedOp]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (IllTypedInstr -> TypeCheckedOp
IllTypedOp (IllTypedInstr -> TypeCheckedOp)
-> (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> TypeCheckedOp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExpandedOp -> IllTypedInstr
NonTypedInstr) [ExpandedOp]
mbf)
  TypeCheckInstrNoExcept (TypeCheckedSeq bti)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr bti
    -> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving' ([ExpandedOp]
-> HST bti -> TypeCheckInstrNoExcept (TypeCheckedSeq bti)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
mbt HST bti
bti) [TypeCheckedOp] -> TypeCheckedInstr
cons1 ((SomeInstr bti
  -> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> (SomeInstr bti
    -> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall a b. (a -> b) -> a -> b
$ \tInstr :: SomeInstr bti
tInstr@(HST bti
_ :/ SomeInstrOut bti
pinstr) -> do
    let cons2 :: [TypeCheckedOp] -> TypeCheckedInstr
cons2 [TypeCheckedOp]
opsF = [TypeCheckedOp] -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> [op] -> InstrAbstract op
mCons [SomeInstr bti -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr bti
tInstr] [TypeCheckedOp]
opsF
    TypeCheckInstrNoExcept (TypeCheckedSeq bfi)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr bfi -> TypeCheckInstr (SomeInstr (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST bfi -> TypeCheckInstrNoExcept (TypeCheckedSeq bfi)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
mbf HST bfi
bfi) [TypeCheckedOp] -> TypeCheckedInstr
cons2 ((SomeInstr bfi -> TypeCheckInstr (SomeInstr (cond : rs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> (SomeInstr bfi -> TypeCheckInstr (SomeInstr (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall a b. (a -> b) -> a -> b
$ \(HST bfi
_ :/ SomeInstrOut bfi
qinstr) -> do
      (SomeInstrOut (cond : rs) -> SomeInstr (cond : rs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (cond : rs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HST (cond : rs)
i HST (cond : rs)
-> SomeInstrOut (cond : rs) -> SomeInstr (cond : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (SomeInstrOut (cond : rs))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr (cond : rs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (cond : rs))
forall a b. (a -> b) -> a -> b
$ case (SomeInstrOut bti
pinstr, SomeInstrOut bfi
qinstr) of
        (Instr bti out
p ::: HST out
po, Instr bfi out
q ::: HST out
qo) -> do
          let instr :: ExpandedInstr
instr = [ExpandedOp] -> [ExpandedOp] -> ExpandedInstr
forall op. [op] -> [op] -> InstrAbstract op
mCons [ExpandedOp]
mbt [ExpandedOp]
mbf
          out :~: out
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (out :~: out)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (out :~: out)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
instr (HST (cond : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (cond : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
If)
            (Either TCTypeError (out :~: out)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (out :~: out))
-> Either TCTypeError (out :~: out)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (out :~: out)
forall a b. (a -> b) -> a -> b
$ HST out -> HST out -> Either TCTypeError (out :~: out)
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
po HST out
qo
          SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
p Instr bfi out
Instr bfi out
q Instr (cond : rs) out -> HST out -> SomeInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
HST out
qo
        (AnyOutInstr forall (out :: [T]). Instr bti out
p, Instr bfi out
q ::: HST out
qo) -> do
          SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
forall (out :: [T]). Instr bti out
p Instr bfi out
q Instr (cond : rs) out -> HST out -> SomeInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
qo
        (Instr bti out
p ::: HST out
po, AnyOutInstr forall (out :: [T]). Instr bfi out
q) -> do
          SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
p Instr bfi out
forall (out :: [T]). Instr bfi out
q Instr (cond : rs) out -> HST out -> SomeInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
po
        (AnyOutInstr forall (out :: [T]). Instr bti out
p, AnyOutInstr forall (out :: [T]). Instr bfi out
q) ->
          SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ (forall (out :: [T]). Instr (cond : rs) out)
-> SomeInstrOut (cond : rs)
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
AnyOutInstr (Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
forall (out :: [T]). Instr bti out
p Instr bfi out
forall (out :: [T]). Instr bfi out
q)

mapImpl
  :: forall c rs.
    ( MapOp c
    , WellTyped (MapOpInp c)
    , SingIOne (MapOpRes c)
    )
  => ([TypeCheckedOp] -> TypeCheckedInstr)
  -> SingT (MapOpInp c)
  -> VarAnn
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> HST (c ': rs)
  -> (forall v'. (SingI v') =>
        SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' ': rs)))
  -> TypeCheckInstrNoExcept (TypeCheckedSeq (c ': rs))
mapImpl :: forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl [TypeCheckedOp] -> TypeCheckedInstr
cons SingT (MapOpInp c)
vn VarAnn
anns ExpandedInstr
instr [ExpandedOp]
mp i :: HST (c : rs)
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
rs) forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs))
mkRes = do
  TypeCheckInstrNoExcept (TypeCheckedSeq (MapOpInp c : rs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (MapOpInp c : rs)
    -> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST (MapOpInp c : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (MapOpInp c : xs))
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
mp ((SingT (MapOpInp c)
vn, Dict (WellTyped (MapOpInp c))
forall (a :: Constraint). a => Dict a
Dict) (SingT (MapOpInp c), Dict (WellTyped (MapOpInp c)))
-> HST xs -> HST (MapOpInp c : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)) [TypeCheckedOp] -> TypeCheckedInstr
cons ((SomeInstr (MapOpInp c : rs)
  -> TypeCheckInstr (SomeInstr (c : rs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs)))
-> (SomeInstr (MapOpInp c : rs)
    -> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall a b. (a -> b) -> a -> b
$ \(HST (MapOpInp c : rs)
_ :/ SomeInstrOut (MapOpInp c : rs)
subp) ->
    case SomeInstrOut (MapOpInp c : rs)
subp of
      Instr (MapOpInp c : rs) out
sub ::: HST out
subo ->
        case HST out
subo of
          (SingT x
bn :: SingT v', Dict (WellTyped x)
_) ::& HST xs
rs' -> do
            xs :~: xs
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (xs :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (xs :~: xs)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration)
              (Either TCTypeError (xs :~: xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (xs :~: xs))
-> Either TCTypeError (xs :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (xs :~: xs)
forall a b. (a -> b) -> a -> b
$ HST xs -> HST xs -> Either TCTypeError (xs :~: xs)
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST xs
rs HST xs
rs'
            HST (MapOpRes c x : rs)
x <- SingT x -> HST rs -> TypeCheckInstr (HST (MapOpRes c x : rs))
forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs))
mkRes SingT x
bn HST rs
HST xs
rs'
            pure $ HST (c : rs)
i HST (c : rs) -> SomeInstrOut (c : rs) -> SomeInstr (c : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ forall {k1} {k2} (f :: k1 -> k2) (x :: k1) r.
(SingIOne f, SingI x) =>
(SingI (f x) => r) -> r
forall (f :: T -> T) (x :: T) r.
(SingIOne f, SingI x) =>
(SingI (f x) => r) -> r
withSingIOne @(MapOpRes c) @v' (AnnVar
-> Instr (MapOpInp c : rs) (x : rs)
-> Instr (c : rs) (MapOpRes c x : rs)
forall (c :: T) (b :: T) (s :: [T]).
(MapOp c, SingI b) =>
AnnVar
-> Instr (MapOpInp c : s) (b : s)
-> Instr (c : s) (MapOpRes c b : s)
AnnMAP (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
anns) Instr (MapOpInp c : rs) out
Instr (MapOpInp c : rs) (x : rs)
sub Instr (c : rs) (MapOpRes c x : rs)
-> HST (MapOpRes c x : rs) -> SomeInstrOut (c : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (MapOpRes c x : rs)
x)
          HST out
_ -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (c : rs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> m a
typeCheckInstrErr ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration)
      AnyOutInstr forall (out :: [T]). Instr (MapOpInp c : rs) out
_ ->
        ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (c : rs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
CodeAlwaysFails

iterImpl
  :: forall c rs .
    ( IterOp c
    , WellTyped (IterOpEl c)
    )
  => SingT (IterOpEl c)
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> HST (c ': rs)
  -> TypeCheckInstrNoExcept (TypeCheckedSeq (c ': rs))
iterImpl :: forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl SingT (IterOpEl c)
en ExpandedInstr
instr [ExpandedOp]
mp i :: HST (c : rs)
i@((SingT x
_, Dict (WellTyped x)
_) ::& HST xs
rs) = do
  let tcAction :: TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
tcAction = case [ExpandedOp]
mp of
        [] -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (IterOpEl c : rs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
instr
          (ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (IterOpEl c : rs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
EmptyCode)
        [ExpandedOp]
_ -> TcInstrHandler
-> [ExpandedOp]
-> HST (IterOpEl c : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : xs))
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr [ExpandedOp]
mp ((SingT (IterOpEl c)
en, Dict (WellTyped (IterOpEl c))
forall (a :: Constraint). a => Dict a
Dict) (SingT (IterOpEl c), Dict (WellTyped (IterOpEl c)))
-> HST xs -> HST (IterOpEl c : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
  TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (IterOpEl c : rs)
    -> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
tcAction [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.ITER ((SomeInstr (IterOpEl c : rs)
  -> TypeCheckInstr (SomeInstr (c : rs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs)))
-> (SomeInstr (IterOpEl c : rs)
    -> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall a b. (a -> b) -> a -> b
$ \(HST (IterOpEl c : rs)
_ :/ SomeInstrOut (IterOpEl c : rs)
subp) -> case SomeInstrOut (IterOpEl c : rs)
subp of
    Instr (IterOpEl c : rs) out
subI ::: HST out
o -> do
      out :~: xs
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (out :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (out :~: xs)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) (Either TCTypeError (out :~: xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (out :~: xs))
-> Either TCTypeError (out :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (out :~: xs)
forall a b. (a -> b) -> a -> b
$ HST out -> HST xs -> Either TCTypeError (out :~: xs)
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o HST xs
rs
      SomeInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (c : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr (c : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr (c : rs)))
-> SomeInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (c : rs))
forall a b. (a -> b) -> a -> b
$ HST (c : rs)
i HST (c : rs) -> SomeInstrOut (c : rs) -> SomeInstr (c : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (IterOpEl c : out) out -> Instr (c : out) out
forall (c :: T) (out :: [T]).
IterOp c =>
Instr (IterOpEl c : out) out -> Instr (c : out) out
ITER Instr (IterOpEl c : rs) out
Instr (IterOpEl c : out) out
subI Instr (c : out) out -> HST out -> SomeInstrOut (c : out)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
o
    AnyOutInstr forall (out :: [T]). Instr (IterOpEl c : rs) out
subI ->
      SomeInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (c : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr (c : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr (c : rs)))
-> SomeInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr (c : rs))
forall a b. (a -> b) -> a -> b
$ HST (c : rs)
i HST (c : rs) -> SomeInstrOut (c : rs) -> SomeInstr (c : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (IterOpEl c : xs) xs -> Instr (c : xs) xs
forall (c :: T) (out :: [T]).
IterOp c =>
Instr (IterOpEl c : out) out -> Instr (c : out) out
ITER Instr (IterOpEl c : xs) xs
forall (out :: [T]). Instr (IterOpEl c : rs) out
subI Instr (c : xs) xs -> HST xs -> SomeInstrOut (c : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs

lamImpl
  :: forall it ot ts .
    ( WellTyped it, WellTyped ot
    , SingI ts
    )
  => ([TypeCheckedOp] -> TypeCheckedInstr)
  -> Anns '[VarAnn, Notes it, Notes ot]
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> SingT it
  -> SingT ot
  -> HST ts
  -> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl :: forall (it :: T) (ot :: T) (ts :: [T]).
(WellTyped it, WellTyped ot, SingI ts) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes it, Notes ot]
-> ExpandedInstr
-> [ExpandedOp]
-> SingT it
-> SingT ot
-> HST ts
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl [TypeCheckedOp] -> TypeCheckedInstr
cons Anns '[VarAnn, Notes it, Notes ot]
anns ExpandedInstr
instr [ExpandedOp]
is SingT it
ins SingT ot
ons HST ts
i =
  ExpandedInstr
-> TypeCheckInstr ()
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall a (inp :: [T]).
ExpandedInstr
-> TypeCheckInstr a
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
guarding_ ExpandedInstr
instr
    (Maybe ExpandedInstr
-> (ExpandedInstr
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         ())
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     ()
forall (f :: * -> *) a.
Applicative f =>
Maybe a -> (a -> f ()) -> f ()
whenJust (First ExpandedInstr -> Maybe ExpandedInstr
forall a. First a -> Maybe a
getFirst (First ExpandedInstr -> Maybe ExpandedInstr)
-> First ExpandedInstr -> Maybe ExpandedInstr
forall a b. (a -> b) -> a -> b
$ (Element [ExpandedOp] -> First ExpandedInstr)
-> [ExpandedOp] -> First ExpandedInstr
forall t m. (Container t, Monoid m) => (Element t -> m) -> t -> m
foldMap Element [ExpandedOp] -> First ExpandedInstr
ExpandedOp -> First ExpandedInstr
hasSelf [ExpandedOp]
is) ((ExpandedInstr
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
       ())
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      ())
-> (ExpandedInstr
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
         ())
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     ()
forall a b. (a -> b) -> a -> b
$ \ExpandedInstr
selfInstr -> do
      let err :: TCTypeError
err = ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
selfInstr Text
"SELF instruction cannot be used in a LAMBDA"
      ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     ()
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST ts -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST ts
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaCode) TCTypeError
err) (TypeCheckInstrNoExcept (TypeCheckedSeq ts)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr '[it] -> TypeCheckInstr (SomeInstr ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq '[it])
TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
tcInstr [TypeCheckedOp] -> TypeCheckedInstr
cons ((SomeInstr '[it] -> TypeCheckInstr (SomeInstr ts))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ts))
-> (SomeInstr '[it] -> TypeCheckInstr (SomeInstr ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall a b. (a -> b) -> a -> b
$ \(HST '[it]
_ :/ SomeInstrOut '[it]
lamI) -> do
      let lamNotes :: SingT ot -> SingT ('TLambda it ot)
lamNotes SingT ot
onsr = Sing it -> Sing ot -> SingT ('TLambda it ot)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TLambda n1 n2)
STLambda Sing it
SingT it
ins Sing ot
SingT ot
onsr
      let lamSt :: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
onsr = (SingT ot -> SingT ('TLambda it ot)
lamNotes SingT ot
onsr, Dict (WellTyped ('TLambda it ot))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TLambda it ot), Dict (WellTyped ('TLambda it ot)))
-> HST ts -> HST ('TLambda it ot : ts)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST ts
i
      (SomeInstrOut ts -> SomeInstr ts)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut ts)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ts)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HST ts
i HST ts -> SomeInstrOut ts -> SomeInstr ts
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
   (SomeInstrOut ts)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
      (SomeInstr ts))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut ts)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstr ts)
forall a b. (a -> b) -> a -> b
$ case SomeInstrOut '[it]
lamI of
        Instr '[it] out
lam ::: HST out
lo -> do
          case forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @ot HST out
lo of
            Right out :~: '[ot]
Refl -> do
                SomeInstrOut ts
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Anns '[VarAnn, Notes it, Notes ot]
-> Value' Instr ('TLambda it ot) -> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (inp :: [T]).
(SingI i, SingI o) =>
Anns '[VarAnn, Notes i, Notes o]
-> Value' Instr ('TLambda i o) -> Instr inp ('TLambda i o : inp)
AnnLAMBDA Anns '[VarAnn, Notes it, Notes ot]
anns (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall (inp :: T) (out :: T) (instr :: [T] -> [T] -> *).
(SingI inp, SingI out,
 forall (i :: [T]) (o :: [T]). Show (instr i o),
 forall (i :: [T]) (o :: [T]). Eq (instr i o),
 forall (i :: [T]) (o :: [T]). NFData (instr i o)) =>
RemFail instr '[inp] '[out] -> Value' instr ('TLambda inp out)
VLam (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot))
-> RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall a b. (a -> b) -> a -> b
$ Instr '[it] out -> RemFail Instr '[it] out
forall {k} (instr :: k -> k -> *) (i :: k) (o :: k).
instr i o -> RemFail instr i o
RfNormal Instr '[it] out
lam) Instr ts ('TLambda it ot : ts)
-> HST ('TLambda it ot : ts) -> SomeInstrOut ts
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
ons)
            Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut ts)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST ts -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST ts
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaCode) TCTypeError
m
        AnyOutInstr forall (out :: [T]). Instr '[it] out
lam ->
          SomeInstrOut ts
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
     (SomeInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Anns '[VarAnn, Notes it, Notes ot]
-> Value' Instr ('TLambda it ot) -> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (inp :: [T]).
(SingI i, SingI o) =>
Anns '[VarAnn, Notes i, Notes o]
-> Value' Instr ('TLambda i o) -> Instr inp ('TLambda i o : inp)
AnnLAMBDA Anns '[VarAnn, Notes it, Notes ot]
anns (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall (inp :: T) (out :: T) (instr :: [T] -> [T] -> *).
(SingI inp, SingI out,
 forall (i :: [T]) (o :: [T]). Show (instr i o),
 forall (i :: [T]) (o :: [T]). Eq (instr i o),
 forall (i :: [T]) (o :: [T]). NFData (instr i o)) =>
RemFail instr '[inp] '[out] -> Value' instr ('TLambda inp out)
VLam (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot))
-> RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall a b. (a -> b) -> a -> b
$ (forall (out :: [T]). Instr '[it] out) -> RemFail Instr '[it] '[ot]
forall {k} (instr :: k -> k -> *) (i :: k) (o :: k).
(forall (o' :: k). instr i o') -> RemFail instr i o
RfAlwaysFails forall (out :: [T]). Instr '[it] out
lam) Instr ts ('TLambda it ot : ts)
-> HST ('TLambda it ot : ts) -> SomeInstrOut ts
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
ons)
  where
    tcInstr :: ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq '[it])
tcInstr = (IsNotInView =>
 ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq '[it]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[it])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq '[it]))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq '[it]))
-> (IsNotInView =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq '[it]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[it])
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[it])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[it])
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter
  TypeCheckInstrEnv
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
  (Maybe (Dict IsNotInView))
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  TypeCheckInstrEnv
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
  (Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView (Maybe (Dict IsNotInView)
 -> TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall a b. (a -> b) -> a -> b
$ Dict IsNotInView -> Maybe (Dict IsNotInView)
forall a. a -> Maybe a
Just Dict IsNotInView
forall (a :: Constraint). a => Dict a
Dict) (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq '[it])
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq '[it]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[it])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq '[it])
forall a b. (a -> b) -> a -> b
$ [ExpandedOp]
-> HST '[it] -> TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is ((SingT it
ins, Dict (WellTyped it)
forall (a :: Constraint). a => Dict a
Dict) (SingT it, Dict (WellTyped it)) -> HST '[] -> HST '[it]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil)
    hasSelf :: U.ExpandedOp -> First U.ExpandedInstr
    hasSelf :: ExpandedOp -> First ExpandedInstr
hasSelf = (First ExpandedInstr -> First ExpandedInstr -> First ExpandedInstr)
-> GenericQ (First ExpandedInstr) -> GenericQ (First ExpandedInstr)
forall r. (r -> r -> r) -> GenericQ r -> GenericQ r
everything First ExpandedInstr -> First ExpandedInstr -> First ExpandedInstr
forall a. Semigroup a => a -> a -> a
(<>)
      (First ExpandedInstr
-> (ExpandedInstr -> First ExpandedInstr)
-> a
-> First ExpandedInstr
forall a b r. (Typeable a, Typeable b) => r -> (b -> r) -> a -> r
mkQ (Maybe ExpandedInstr -> First ExpandedInstr
forall a. Maybe a -> First a
First Maybe ExpandedInstr
forall a. Maybe a
Nothing)
       (\case
           selfInstr :: ExpandedInstr
selfInstr@(U.SELF{} :: U.InstrAbstract U.ExpandedOp) -> Maybe ExpandedInstr -> First ExpandedInstr
forall a. Maybe a -> First a
First (Maybe ExpandedInstr -> First ExpandedInstr)
-> Maybe ExpandedInstr -> First ExpandedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> Maybe ExpandedInstr
forall a. a -> Maybe a
Just ExpandedInstr
selfInstr
           ExpandedInstr
_ -> Maybe ExpandedInstr -> First ExpandedInstr
forall a. Maybe a -> First a
First Maybe ExpandedInstr
forall a. Maybe a
Nothing
       )
      )

----------------------------------------------------------------------------
-- Helpers for DIP (n) typechecking
----------------------------------------------------------------------------

-- Helper data type we use to typecheck DIPN.
data TCDipHelper inp where
  TCDipHelperOk ::
    forall (n :: Peano) inp out s s'.
    (SingI out, ConstraintDIPN n inp out s s') =>
    PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper inp
  TCDipHelperErr :: TCError -> [IllTypedInstr] -> TCDipHelper inp

typeCheckDipBody
  :: SingI inp
  => ([TypeCheckedOp] -> TypeCheckedInstr)
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> HST inp
  -> (TCError -> [IllTypedInstr] -> r)
  -> (forall out. SingI out => Instr inp out -> HST out -> r)
  -> TypeCheckInstrNoExcept r
typeCheckDipBody :: forall (inp :: [T]) r.
SingI inp =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody [TypeCheckedOp] -> TypeCheckedInstr
cons ExpandedInstr
mainInstr [ExpandedOp]
instructions HST inp
inputHST TCError -> [IllTypedInstr] -> r
onErr forall (out :: [T]). SingI out => Instr inp out -> HST out -> r
onOk = do
  TypeCheckedSeq inp
listRes <- [ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
instructions HST inp
inputHST
  ErrorSrcPos
pos <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
     ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
  pure $ TypeCheckedSeq inp
listRes TypeCheckedSeq inp -> (TypeCheckedSeq inp -> r) -> r
forall a b. a -> (a -> b) -> b
& ([TypeCheckedOp] -> TCError -> r)
-> (SomeInstr inp -> r) -> TypeCheckedSeq inp -> r
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither
    (\[TypeCheckedOp]
tcOps TCError
err -> TCError -> [IllTypedInstr] -> r
onErr TCError
err [TypeCheckedInstr -> IllTypedInstr
SemiTypedInstr (TypeCheckedInstr -> IllTypedInstr)
-> TypeCheckedInstr -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ [TypeCheckedOp] -> TypeCheckedInstr
cons [TypeCheckedOp]
tcOps])
    (\someInstr :: SomeInstr inp
someInstr@(HST inp
_ :/ SomeInstrOut inp
iAndOut) -> case SomeInstrOut inp
iAndOut of
        AnyOutInstr forall (out :: [T]). Instr inp out
_ ->
        -- This may seem like we throw error because of despair, but in fact,
        -- the reference implementation seems to behave exactly in this way -
        -- if output stack of code block within @DIP@ occurs to be any, an
        -- error "FAILWITH must be at tail position" is raised.
        -- It is not allowed even in `DIP 0`.
          let err :: TCError
err = ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
mainInstr
                                    (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inputHST)
                                    ErrorSrcPos
pos
                                    (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
DipCode)
                                    (TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
CodeAlwaysFails)
          in TCError -> [IllTypedInstr] -> r
onErr TCError
err [TypeCheckedInstr -> IllTypedInstr
SemiTypedInstr (TypeCheckedInstr -> IllTypedInstr)
-> TypeCheckedInstr -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ [TypeCheckedOp] -> TypeCheckedInstr
cons [SomeInstr inp -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr inp
someInstr]]
        Instr inp out
subI ::: HST out
t -> Instr inp out -> HST out -> r
forall (out :: [T]). SingI out => Instr inp out -> HST out -> r
onOk Instr inp out
subI HST out
t)