-- 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
-- @SomeTcInstr@ 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 @SomeTcInstr@ 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
    , typeCheckContract'
    , typeCheckContractAndStorage
    , typeCheckContractAndStorage'
    , typeCheckInstr
    , typeCheckList
    , tcList
    , typeCheckListNoExcept
    , typeCheckParameter
    , typeCheckStorage
    , typeCheckTopLevelType
    , typeCheckTopLevelType'
    , typeCheckViews
    , typeCheckView'
    , typeCheckViews'
    , typeCheckValue
    , typeCheckValueRunCodeCompat
    , typeCheckExpandedOp
    , typeVerifyContract
    , typeVerifyContract'
    , typeVerifyParameter
    , typeVerifyStorage
    , typeVerifyTopLevelType
    , typeVerifyView
    , 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)
import Data.Type.Equality (TestEquality(..))
import Data.Typeable ((:~:)(..))
import Fmt (pretty)

import Morley.Michelson.ErrorPos (ErrorSrcPos)
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 U.ExpandedOp SomeContractAndStorage
typeCheckContractAndStorage :: Contract
-> Value -> TypeCheckResult ExpandedOp SomeContractAndStorage
typeCheckContractAndStorage = TcInstrBase ExpandedOp
-> Contract
-> Value
-> TypeCheckResult ExpandedOp SomeContractAndStorage
forall op.
IsInstrOp op =>
TcInstrBase op
-> Contract' op
-> Value' op
-> TypeCheckResult op SomeContractAndStorage
typeCheckContractAndStorage' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeCheckContractAndStorage'
  :: IsInstrOp op
  => TcInstrBase op -> U.Contract' op -> U.Value' op -> TypeCheckResult op SomeContractAndStorage
typeCheckContractAndStorage' :: forall op.
IsInstrOp op =>
TcInstrBase op
-> Contract' op
-> Value' op
-> TypeCheckResult op SomeContractAndStorage
typeCheckContractAndStorage' TcInstrBase op
tcOp Contract' op
uContract Value' op
uStorage = do
  SomeContract (contract :: Contract cp st
contract@Contract{} :: Contract cp st) <- TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' TcInstrBase op
tcOp Contract' op
uContract
  Value st
storage <- forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op -> Value' op -> TypeCheckResult op (Value t)
typeVerifyStorage' @st TcInstrBase op
tcOp Value' op
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 U.ExpandedOp SomeContract
typeCheckContract :: Contract -> TypeCheckResult ExpandedOp SomeContract
typeCheckContract = TcInstrBase ExpandedOp
-> Contract -> TypeCheckResult ExpandedOp SomeContract
forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeCheckContract'
  :: IsInstrOp op
  => TcInstrBase op
  -> U.Contract' op
  -> TypeCheckResult op SomeContract
typeCheckContract' :: forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' TcInstrBase op
tcOp Contract' op
c = do
  SomeParamType
paramType <- Either (TcError' op) SomeParamType
-> ReaderT TypeCheckOptions (Except (TcError' op)) SomeParamType
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either (TcError' op) SomeParamType
 -> ReaderT TypeCheckOptions (Except (TcError' op)) SomeParamType)
-> Either (TcError' op) SomeParamType
-> ReaderT TypeCheckOptions (Except (TcError' op)) SomeParamType
forall a b. (a -> b) -> a -> b
$ (TcTypeError -> TcError' op)
-> Either TcTypeError SomeParamType
-> Either (TcError' op) SomeParamType
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError Text
"illegal parameter declaration: " (Maybe TcTypeError -> TcError' op)
-> (TcTypeError -> Maybe TcTypeError) -> TcTypeError -> TcError' op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcTypeError -> Maybe TcTypeError
forall a. a -> Maybe a
Just ) (Either TcTypeError SomeParamType
 -> Either (TcError' op) SomeParamType)
-> Either TcTypeError SomeParamType
-> Either (TcError' op) SomeParamType
forall a b. (a -> b) -> a -> b
$
    ParameterType -> Either TcTypeError SomeParamType
mkSomeParamType (Contract' op -> ParameterType
forall op. Contract' op -> ParameterType
U.contractParameter Contract' op
c)
  TypeCheckMode op
-> TypeCheck op SomeContract -> TypeCheckResult op SomeContract
forall op a.
TypeCheckMode op -> TypeCheck op a -> TypeCheckResult op a
runTypeCheck (SomeParamType -> TypeCheckMode op
forall op. SomeParamType -> TypeCheckMode op
TypeCheckContract SomeParamType
paramType) (TypeCheck op SomeContract -> TypeCheckResult op SomeContract)
-> TypeCheck op SomeContract -> TypeCheckResult op SomeContract
forall a b. (a -> b) -> a -> b
$ TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
doTypeCheckContract' TcInstrBase op
tcOp Contract' op
c

typeVerifyContract
  :: forall cp st.
     (SingI cp, SingI st)
  => U.Contract -> TypeCheckResult U.ExpandedOp (Contract cp st)
typeVerifyContract :: forall (cp :: T) (st :: T).
(SingI cp, SingI st) =>
Contract -> TypeCheckResult ExpandedOp (Contract cp st)
typeVerifyContract = TcInstrBase ExpandedOp
-> Contract -> TypeCheckResult ExpandedOp (Contract cp st)
forall (cp :: T) (st :: T) op.
(SingI cp, SingI st, IsInstrOp op) =>
TcInstrBase op
-> Contract' op -> TypeCheckResult op (Contract cp st)
typeVerifyContract' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeVerifyContract'
  :: forall cp st op.
     (SingI cp, SingI st, IsInstrOp op)
  => TcInstrBase op -> U.Contract' op -> TypeCheckResult op (Contract cp st)
typeVerifyContract' :: forall (cp :: T) (st :: T) op.
(SingI cp, SingI st, IsInstrOp op) =>
TcInstrBase op
-> Contract' op -> TypeCheckResult op (Contract cp st)
typeVerifyContract' TcInstrBase op
tcOp Contract' op
uContract = do
  SomeContract tContract :: Contract cp st
tContract@(Contract{} :: Contract cp' st') <-
    TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' TcInstrBase op
tcOp Contract' op
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 op x
forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op 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 op x
forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op any
mkErr TopLevelType
TltStorageType)
  Contract cp st
-> ReaderT TypeCheckOptions (Except (TcError' op)) (Contract cp st)
forall (m :: * -> *) a. Monad m => a -> m a
return Contract cp st
tContract
  where
    mkErr :: TopLevelType -> MismatchError T -> TypeCheckResult op any
    mkErr :: forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op any
mkErr TopLevelType
tyDesc MismatchError T
merr =
      TcError' op -> ReaderT TypeCheckOptions (Except (TcError' op)) any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT TypeCheckOptions (Except (TcError' op)) any)
-> TcError' op
-> ReaderT TypeCheckOptions (Except (TcError' op)) any
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError Text
"error in contract type" (Maybe TcTypeError -> TcError' op)
-> Maybe TcTypeError -> TcError' op
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 op. SingI t => (WellTyped t => TypeCheck op a) -> TypeCheck op a
withWTP :: forall (t :: T) a op.
SingI t =>
(WellTyped t => TypeCheck op a) -> TypeCheck op a
withWTP WellTyped t => TypeCheck op a
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
  Right Dict (WellTyped t)
Dict -> TypeCheck op a
WellTyped t => TypeCheck op a
fn
  Left NotWellTyped
err -> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      a)
-> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
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 op a. SingI t => U.InstrAbstract op -> SomeHST -> (WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr_ :: forall (t :: T) op a.
SingI t =>
InstrAbstract op
-> SomeHST
-> (WellTyped t => TypeCheckInstr op a)
-> TypeCheckInstr op a
withWTPInstr_ InstrAbstract op
v SomeHST
t WellTyped t => TypeCheckInstr op a
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
  Right Dict (WellTyped t)
Dict -> TypeCheckInstr op a
WellTyped t => TypeCheckInstr op a
fn
  Left (NotWellTyped T
badType BadTypeForScope
cause) -> do
    ErrorSrcPos
loc <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      a)
-> TcError' op
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
forall op.
InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
TcFailedOnInstr InstrAbstract op
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 op inp. (SingI t, IsInstrOp op)
  => U.InstrAbstract op
  -> SomeHST
  -> (WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr'_ :: forall (t :: T) op (inp :: [T]).
(SingI t, IsInstrOp op) =>
InstrAbstract op
-> SomeHST
-> (WellTyped t =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr'_ InstrAbstract op
v SomeHST
t WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
  Right Dict (WellTyped t)
Dict -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
fn
  Left (NotWellTyped T
badType BadTypeForScope
cause) -> do
    ErrorSrcPos
loc <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (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' op
err = InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
forall op.
InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
TcFailedOnInstr InstrAbstract op
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 op inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq op inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op inp))
-> TypeCheckedSeq op inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
IllTypedSeq TcError' op
err [op -> IllTypedInstr op
forall op. op -> IllTypedInstr op
NonTypedInstr (op -> IllTypedInstr op) -> op -> IllTypedInstr op
forall a b. (a -> b) -> a -> b
$ InstrAbstract op -> op
forall op. IsInstrOp op => InstrAbstract op -> op
liftInstr InstrAbstract op
v]

doTypeCheckContract'
  :: IsInstrOp op
  => TcInstrBase op
  -> U.Contract' op
  -> TypeCheck op SomeContract
doTypeCheckContract' :: forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
doTypeCheckContract' TcInstrBase op
tcOp uContract :: Contract' op
uContract@(U.Contract wholeParam :: ParameterType
wholeParam@(U.ParameterType Ty
mParam RootAnn
rootAnn) Ty
mStorage [op]
pCode EntriesOrder
entriesOrder [View' op]
uViews) = do
  NonEmpty op
_ <- ReaderT
  (TypeCheckEnv op)
  (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
  (NonEmpty op)
-> (NonEmpty op
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (NonEmpty op))
-> Maybe (NonEmpty op)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (NonEmpty op)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (NonEmpty op)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (NonEmpty op))
-> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (NonEmpty op)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError Text
"no instructions in contract code" (Maybe TcTypeError -> TcError' op)
-> Maybe TcTypeError -> TcError' op
forall a b. (a -> b) -> a -> b
$ TcTypeError -> Maybe TcTypeError
forall a. a -> Maybe a
Just TcTypeError
EmptyCode)
                NonEmpty op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (NonEmpty op)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([op] -> Maybe (NonEmpty op)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty [op]
pCode)
  Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
       (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
       SomeContract)
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      SomeContract)
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
paramNote :: Notes param) ->
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
       (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
       SomeContract)
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      SomeContract)
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
storageNote :: Notes st) -> do
      forall (t :: T) a op.
SingI t =>
(WellTyped t => TypeCheck op a) -> TypeCheck op a
withWTP @st ((WellTyped t => TypeCheck op SomeContract)
 -> TypeCheck op SomeContract)
-> (WellTyped t => TypeCheck op SomeContract)
-> TypeCheck op SomeContract
forall a b. (a -> b) -> a -> b
$ do
        forall (t :: T) a op.
SingI t =>
(WellTyped t => TypeCheck op a) -> TypeCheck op a
withWTP @param ((WellTyped t => TypeCheck op SomeContract)
 -> TypeCheck op SomeContract)
-> (WellTyped t => TypeCheck op SomeContract)
-> TypeCheck op SomeContract
forall a b. (a -> b) -> a -> b
$ do
          Dict (ParameterScope t)
Dict <- (BadTypeForScope
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Dict (ParameterScope t)))
-> (Dict (ParameterScope t)
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ParameterScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a op.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError @param Text
"parameter") Dict (ParameterScope t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ParameterScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either BadTypeForScope (Dict (ParameterScope t))
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Dict (StorageScope t)))
-> (Dict (StorageScope t)
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (StorageScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a op.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError @st Text
"storage") Dict (StorageScope t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (StorageScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either BadTypeForScope (Dict (StorageScope t))
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op '[ 'TPair t t]
codeRes <-
            TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TypeCheckedSeq op '[ 'TPair t t])
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (TypeCheckedSeq op '[ '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 op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (TypeCheckedSeq op '[ 'TPair t t])
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (TypeCheckedSeq op '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TypeCheckedSeq op '[ 'TPair t t])
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
            ReaderT
  TypeCheckInstrEnv
  (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq op '[ 'TPair t t])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity)))
     (ExceptT (TcError' op) Identity)
     (TypeCheckedSeq op '[ 'TPair t t])
forall (m :: * -> *) e a.
MonadMultiReaderT m Identity =>
m a -> ChangeMultiReaderBase m (Except e) a
liftNoExcept (ReaderT
   TypeCheckInstrEnv
   (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[ 'TPair t t])
 -> ChangeMultiReaderBase
      (ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity)))
      (ExceptT (TcError' op) Identity)
      (TypeCheckedSeq op '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity)))
     (ExceptT (TcError' op) Identity)
     (TypeCheckedSeq op '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
            TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
typeCheckImpl
              ((IsNotInView =>
 op
 -> HST inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op inp))
-> op
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  op
  -> HST inp
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
       (TypeCheckedSeq op inp))
 -> op
 -> HST inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op inp))
-> (IsNotInView =>
    op
    -> HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op inp))
-> op
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op inp))
-> (op
    -> HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op inp))
-> op
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
forall a b c. SuperComposition a b c => a -> b -> c
... op
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
TcInstrBase op
tcOp)
              [op]
pCode
              HST '[ 'TPair t t]
inp
          instr :: SomeTcInstr '[ 'TPair t t]
instr@(HST '[ 'TPair t t]
_ :/ SomeTcInstrOut '[ 'TPair t t]
instrOut) <-
            ([TypeCheckedOp op]
 -> TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (SomeTcInstr '[ 'TPair t t]))
-> (SomeTcInstr '[ 'TPair t t]
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (SomeTcInstr '[ 'TPair t t]))
-> TypeCheckedSeq op '[ 'TPair t t]
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeTcInstr '[ 'TPair t t])
forall op a (inp :: [T]).
([TypeCheckedOp op] -> TcError' op -> a)
-> (SomeTcInstr inp -> a) -> TypeCheckedSeq op inp -> a
tcsEither [TypeCheckedOp op]
-> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeTcInstr '[ 'TPair t t])
forall op a. [TypeCheckedOp op] -> TcError' op -> TypeCheck op a
onFailedCodeTypeCheck SomeTcInstr '[ 'TPair t t]
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeTcInstr '[ 'TPair t t])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq op '[ 'TPair t t]
codeRes

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

          (TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
forall e (m :: * -> *) a.
MonadError e m =>
(e -> m a) -> m a -> m a
handleError ([TypeCheckedOp op]
-> [View' (TypeCheckedOp op)]
-> TcError' op
-> TypeCheck op SomeContract
forall op a.
[TypeCheckedOp op]
-> [View' (TypeCheckedOp op)] -> TcError' op -> TypeCheck op a
onFailedFullTypeCheck [SomeTcInstr '[ 'TPair t t] -> TypeCheckedOp op
forall (inp :: [T]) op. SomeTcInstr inp -> TypeCheckedOp op
someInstrToOp SomeTcInstr '[ 'TPair t t]
instr] ((View' op -> SomeView t -> View' (TypeCheckedOp op))
-> [View' op] -> [SomeView t] -> [View' (TypeCheckedOp op)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith View' op -> SomeView t -> View' (TypeCheckedOp op)
forall op (st :: T).
View' op -> SomeView st -> View' (TypeCheckedOp op)
someViewToOp [View' op]
uViews [SomeView t]
views)) (ReaderT
   (TypeCheckEnv op)
   (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
   SomeContract
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op) (ParamNotes t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (ParamNotes t)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either (TcError' op) (ParamNotes t)
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (ParamNotes t))
-> Either (TcError' op) (ParamNotes t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op)
-> Either (TcError' op) (ParamNotes t)
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst`
                  (Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError Text
"invalid parameter declaration: " (Maybe TcTypeError -> TcError' op)
-> (ParamEpError -> Maybe TcTypeError)
-> ParamEpError
-> TcError' op
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' op) (ViewsSet' Instr t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (ViewsSet' Instr t)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either (TcError' op) (ViewsSet' Instr t)
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (ViewsSet' Instr t))
-> Either (TcError' op) (ViewsSet' Instr t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op)
-> Either (TcError' op) (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' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError (ViewsSetError -> Text
forall a b. (Buildable a, FromBuilder b) => a -> b
pretty ViewsSetError
e) Maybe TcTypeError
forall a. Maybe a
Nothing
            case SomeTcInstrOut '[ 'TPair t t]
instrOut of
              Instr '[ 'TPair t t] out
instr' ::: HST out
out -> Either (TcError' op) SomeContract
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either (TcError' op) SomeContract
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      SomeContract)
-> Either (TcError' op) SomeContract
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op) SomeContract
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeContract -> Either (TcError' op) SomeContract)
-> SomeContract -> Either (TcError' op) 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' op -> Either (TcError' op) SomeContract
forall a b. a -> Either a b
Left (TcError' op -> Either (TcError' op) SomeContract)
-> TcError' op -> Either (TcError' op) SomeContract
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError Text
"contract output type violates convention:" (Maybe TcTypeError -> TcError' op)
-> Maybe TcTypeError -> TcError' op
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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeContract
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      SomeContract)
-> SomeContract
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op. SingI t => Text -> BadTypeForScope -> TypeCheck op a
    hasTypeError :: forall (t :: T) a op.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError Text
name BadTypeForScope
reason = TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      a)
-> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall a b. (a -> b) -> a -> b
$
      Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
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' op)
-> Maybe TcTypeError -> TcError' op
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 op] -> TcError' op -> TypeCheck op a
    onFailedCodeTypeCheck :: forall op a. [TypeCheckedOp op] -> TcError' op -> TypeCheck op a
onFailedCodeTypeCheck [TypeCheckedOp op]
ops TcError' op
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TcError' op -> Contract' (TypeCheckedOp op) -> TcError' op
forall op.
TcError' op -> Contract' (TypeCheckedOp op) -> TcError' op
TcIncompletelyTyped TcError' op
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 op]
contractCode = [TypeCheckedOp op]
ops
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             , contractViews :: [View' (TypeCheckedOp op)]
contractViews = []
             }
        else TcError' op
err

    onFailedFullTypeCheck :: [TypeCheckedOp op] -> [U.View' (TypeCheckedOp op)] -> TcError' op -> TypeCheck op a
    onFailedFullTypeCheck :: forall op a.
[TypeCheckedOp op]
-> [View' (TypeCheckedOp op)] -> TcError' op -> TypeCheck op a
onFailedFullTypeCheck [TypeCheckedOp op]
ops [View' (TypeCheckedOp op)]
views TcError' op
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TcError' op -> Contract' (TypeCheckedOp op) -> TcError' op
forall op.
TcError' op -> Contract' (TypeCheckedOp op) -> TcError' op
TcIncompletelyTyped TcError' op
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 op]
contractCode = [TypeCheckedOp op]
ops
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             , contractViews :: [View' (TypeCheckedOp op)]
contractViews = [View' (TypeCheckedOp op)]
views
             }
        else TcError' op
err

typeVerifyView
  :: forall arg ret st.
     (SingI arg, SingI ret, WellTyped st)
  => Notes st -> U.View -> TypeCheckResult U.ExpandedOp (View arg st ret)
typeVerifyView :: forall (arg :: T) (ret :: T) (st :: T).
(SingI arg, SingI ret, WellTyped st) =>
Notes st -> View -> TypeCheckResult ExpandedOp (View arg st ret)
typeVerifyView = TcInstrBase ExpandedOp
-> Notes st -> View -> TypeCheckResult ExpandedOp (View arg st ret)
forall (arg :: T) (ret :: T) (st :: T) op.
(SingI arg, SingI ret, WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheckResult op (View arg st ret)
typeVerifyView' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeVerifyView'
  :: forall arg ret st op.
     (SingI arg, SingI ret, WellTyped st, IsInstrOp op)
  => TcInstrBase op -> Notes st -> U.View' op -> TypeCheckResult op (View arg st ret)
typeVerifyView' :: forall (arg :: T) (ret :: T) (st :: T) op.
(SingI arg, SingI ret, WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheckResult op (View arg st ret)
typeVerifyView' TcInstrBase op
tcOp Notes st
notes View' op
v = do
  SomeView (tcView :: View' Instr arg st ret
tcView@View{} :: View arg' st' ret') <-
    TypeCheckMode op
-> TypeCheck op (SomeView' Instr st)
-> TypeCheckResult op (SomeView' Instr st)
forall op a.
TypeCheckMode op -> TypeCheck op a -> TypeCheckResult op a
runTypeCheck TypeCheckMode op
forall op. TypeCheckMode op
TypeCheckTest (TypeCheck op (SomeView' Instr st)
 -> TypeCheckResult op (SomeView' Instr st))
-> TypeCheck op (SomeView' Instr st)
-> TypeCheckResult op (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView' Instr st)
forall (st :: T) op.
(WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
typeCheckView' TcInstrBase op
tcOp Notes st
notes View' op
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 op x
forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op 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 op x
forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op 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 op x
forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op any
mkErr TopLevelType
TltParameterType)
  View' Instr arg st ret
-> ReaderT
     TypeCheckOptions (Except (TcError' op)) (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 op any
    mkErr :: forall any.
TopLevelType -> MismatchError T -> TypeCheckResult op any
mkErr TopLevelType
tyDesc MismatchError T
merr =
      TcError' op -> ReaderT TypeCheckOptions (Except (TcError' op)) any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT TypeCheckOptions (Except (TcError' op)) any)
-> TcError' op
-> ReaderT TypeCheckOptions (Except (TcError' op)) any
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TcTypeError -> TcError' op
forall op. Text -> Maybe TcTypeError -> TcError' op
TcContractError Text
"error in view type" (Maybe TcTypeError -> TcError' op)
-> Maybe TcTypeError -> TcError' op
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

typeCheckView'
  :: (WellTyped st, IsInstrOp op)
  => TcInstrBase op
  -> Notes st
  -> U.View' op
  -> TypeCheck op (SomeView st)
typeCheckView' :: forall (st :: T) op.
(WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
typeCheckView' TcInstrBase op
tcOp Notes st
storageNote
  uView :: View' op
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 = [op]
uInstr
  , viewName :: forall op. View' op -> ViewName
U.viewName = ViewName
viewName
  }
  = forall (t :: T) a op.
SingI t =>
(WellTyped t => TypeCheck op a) -> TypeCheck op a
withWTP @param ((WellTyped t =>
  MultiReaderT
    '[TypeCheckEnv op, TypeCheckOptions]
    (ExceptT (TcError' op) Identity)
    (SomeView' Instr st))
 -> MultiReaderT
      '[TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      (SomeView' Instr st))
-> (WellTyped t =>
    MultiReaderT
      '[TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      (SomeView' Instr st))
-> MultiReaderT
     '[TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a op.
SingI t =>
(WellTyped t => TypeCheck op a) -> TypeCheck op a
withWTP @ret ((WellTyped t =>
  MultiReaderT
    '[TypeCheckEnv op, TypeCheckOptions]
    (ExceptT (TcError' op) Identity)
    (SomeView' Instr st))
 -> MultiReaderT
      '[TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      (SomeView' Instr st))
-> (WellTyped t =>
    MultiReaderT
      '[TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      (SomeView' Instr st))
-> MultiReaderT
     '[TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) 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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Dict (ViewableScope t)))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Dict (ViewableScope t)))
-> (Dict (ViewableScope t)
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a op.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError @param Text
"parameter") Dict (ViewableScope t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Dict (ViewableScope t)))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Dict (ViewableScope t)))
-> (Dict (ViewableScope t)
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a op.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError @ret Text
"return") Dict (ViewableScope t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    TypeCheckedSeq op '[ 'TPair t st]
codeRes <-
      TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TypeCheckedSeq op '[ 'TPair t st])
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (TypeCheckedSeq op '[ '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 op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (TypeCheckedSeq op '[ 'TPair t st])
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (TypeCheckedSeq op '[ 'TPair t st]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TypeCheckedSeq op '[ 'TPair t st])
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (TypeCheckedSeq op '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
      ReaderT
  TypeCheckInstrEnv
  (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq op '[ 'TPair t st])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity)))
     (ExceptT (TcError' op) Identity)
     (TypeCheckedSeq op '[ 'TPair t st])
forall (m :: * -> *) e a.
MonadMultiReaderT m Identity =>
m a -> ChangeMultiReaderBase m (Except e) a
liftNoExcept (ReaderT
   TypeCheckInstrEnv
   (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[ 'TPair t st])
 -> ChangeMultiReaderBase
      (ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity)))
      (ExceptT (TcError' op) Identity)
      (TypeCheckedSeq op '[ 'TPair t st]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t st])
-> ChangeMultiReaderBase
     (ReaderT
        TypeCheckInstrEnv
        (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity)))
     (ExceptT (TcError' op) Identity)
     (TypeCheckedSeq op '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
      TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
typeCheckImpl TcInstrBase op
tcOp [op]
uInstr HST '[ 'TPair t st]
inp
    HST '[ 'TPair t st]
_ :/ SomeTcInstrOut '[ 'TPair t st]
instrOut <-
      ([TypeCheckedOp op]
 -> TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (SomeTcInstr '[ 'TPair t st]))
-> (SomeTcInstr '[ 'TPair t st]
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (SomeTcInstr '[ 'TPair t st]))
-> TypeCheckedSeq op '[ 'TPair t st]
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeTcInstr '[ 'TPair t st])
forall op a (inp :: [T]).
([TypeCheckedOp op] -> TcError' op -> a)
-> (SomeTcInstr inp -> a) -> TypeCheckedSeq op inp -> a
tcsEither (View' op
-> [TypeCheckedOp op]
-> TcError' op
-> TypeCheck op (SomeTcInstr '[ 'TPair t st])
forall op a.
View' op -> [TypeCheckedOp op] -> TcError' op -> TypeCheck op a
onFailedViewsTypeCheck View' op
uView) SomeTcInstr '[ 'TPair t st]
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeTcInstr '[ 'TPair t st])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq op '[ '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 SomeTcInstrOut '[ 'TPair t st]
instrOut of
      Instr '[ 'TPair t st] out
instr ::: HST out
out -> Either (TcError' op) (SomeView' Instr st)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op)
-> Either (TcError' op) (out :~: '[t])
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` (Text -> ViewName -> Maybe TcTypeError -> TcError' op
forall op. Text -> ViewName -> Maybe TcTypeError -> TcError' op
TcViewError Text
"view return type mismatch:" ViewName
viewName (Maybe TcTypeError -> TcError' op)
-> (TcTypeError -> Maybe TcTypeError) -> TcTypeError -> TcError' op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcTypeError -> Maybe TcTypeError
forall a. a -> Maybe a
Just)
        SomeView' Instr st -> Either (TcError' op) (SomeView' Instr st)
forall (m :: * -> *) a. Monad m => a -> m a
return (SomeView' Instr st -> Either (TcError' op) (SomeView' Instr st))
-> SomeView' Instr st -> Either (TcError' op) (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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeView' Instr st)
forall (m :: * -> *) a. Monad m => a -> m a
return (SomeView' Instr st
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (SomeView' Instr st))
-> SomeView' Instr st
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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' op -> [TypeCheckedOp op] -> TcError' op -> TypeCheck op a
    onFailedViewsTypeCheck :: forall op a.
View' op -> [TypeCheckedOp op] -> TcError' op -> TypeCheck op a
onFailedViewsTypeCheck View' op
v [TypeCheckedOp op]
viewOps TcError' op
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TcError' op -> View' (TypeCheckedOp op) -> TcError' op
forall op. TcError' op -> View' (TypeCheckedOp op) -> TcError' op
TcIncompletelyTypedView TcError' op
err View' op
v{ viewCode :: [TypeCheckedOp op]
U.viewCode = [TypeCheckedOp op]
viewOps }
        else TcError' op
err

    hasTypeError :: forall (t :: T) a op. SingI t => Text -> BadTypeForScope -> TypeCheck op a
    hasTypeError :: forall (t :: T) a op.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError Text
desc BadTypeForScope
reason = TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      a)
-> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall a b. (a -> b) -> a -> b
$
      Text -> ViewName -> Maybe TcTypeError -> TcError' op
forall op. Text -> ViewName -> Maybe TcTypeError -> TcError' op
TcViewError (Text
desc Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" type error in view") ViewName
viewName (Maybe TcTypeError -> TcError' op)
-> Maybe TcTypeError -> TcError' op
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

typeCheckViews'
  :: forall st op.
     (WellTyped st, IsInstrOp op)
  => TcInstrBase op
  -> U.Contract' (TypeCheckedOp op)
  -> Notes st
  -> [U.View' op]
  -> TypeCheck op [SomeView st]
typeCheckViews' :: forall (st :: T) op.
(WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Contract' (TypeCheckedOp op)
-> Notes st
-> [View' op]
-> TypeCheck op [SomeView st]
typeCheckViews' TcInstrBase op
doTypeCheckOp Contract' (TypeCheckedOp op)
tcContract Notes st
storageNote [View' op]
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' op, SomeView st) -> [SomeView st])
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Seq (View' op, SomeView st))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     [SomeView st]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((View' op, SomeView st) -> SomeView st)
-> [(View' op, SomeView st)] -> [SomeView st]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (View' op, SomeView st) -> SomeView st
forall a b. (a, b) -> b
snd ([(View' op, SomeView st)] -> [SomeView st])
-> (Seq (View' op, SomeView st) -> [(View' op, SomeView st)])
-> Seq (View' op, SomeView st)
-> [SomeView st]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq (View' op, SomeView st) -> [(View' op, SomeView st)]
forall t. Container t => t -> [Element t]
toList) (ReaderT
   (TypeCheckEnv op)
   (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
   (Seq (View' op, SomeView st))
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      [SomeView st])
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Seq (View' op, SomeView st))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     [SomeView st]
forall a b. (a -> b) -> a -> b
$ [View' op]
-> Seq (View' op, SomeView st)
-> (Seq (View' op, SomeView st)
    -> View' op
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Seq (View' op, SomeView st)))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Seq (View' op, SomeView st))
forall {t :: * -> *} {m :: * -> *} {a} {b}.
(Foldable t, Monad m) =>
t a -> b -> (b -> a -> m b) -> m b
myfoldM [View' op]
cViews (Seq (View' op, SomeView st)
forall a. Seq a
Seq.Empty :: Seq (U.View' op, SomeView st))
    \Seq (View' op, SomeView st)
processedViews View' op
uView -> do
      SomeView st
resView <- TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
forall (st :: T) op.
(WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
typeCheckView' TcInstrBase op
doTypeCheckOp Notes st
storageNote View' op
uView
      pure $ Seq (View' op, SomeView st)
processedViews Seq (View' op, SomeView st)
-> (View' op, SomeView st) -> Seq (View' op, SomeView st)
forall a. Seq a -> a -> Seq a
|> (View' op
uView, SomeView st
resView)
      ReaderT
  (TypeCheckEnv op)
  (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
  (Seq (View' op, SomeView st))
-> (TcError' op
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (Seq (View' op, SomeView st)))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Seq (View' op, SomeView st))
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` \case
        TcIncompletelyTypedView TcError' op
err View' (TypeCheckedOp op)
view' ->
          let tcViews :: Seq (View' (TypeCheckedOp op))
tcViews = ((View' op, SomeView st) -> View' (TypeCheckedOp op))
-> Seq (View' op, SomeView st) -> Seq (View' (TypeCheckedOp op))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map ((View' op -> SomeView st -> View' (TypeCheckedOp op))
-> (View' op, SomeView st) -> View' (TypeCheckedOp op)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry View' op -> SomeView st -> View' (TypeCheckedOp op)
forall op (st :: T).
View' op -> SomeView st -> View' (TypeCheckedOp op)
someViewToOp) Seq (View' op, SomeView st)
processedViews
          in Seq (View' (TypeCheckedOp op))
-> View' (TypeCheckedOp op)
-> TcError' op
-> TypeCheck op (Seq (View' op, SomeView st))
forall a.
Seq (View' (TypeCheckedOp op))
-> View' (TypeCheckedOp op) -> TcError' op -> TypeCheck op a
onFailedViewsTypeCheck Seq (View' (TypeCheckedOp op))
tcViews View' (TypeCheckedOp op)
view' TcError' op
err
        TcError' op
err -> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Seq (View' op, SomeView st))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError TcError' op
err
  where
    onFailedViewsTypeCheck
      :: Seq (U.View' (TypeCheckedOp op)) -> U.View' (TypeCheckedOp op) -> TcError' op -> TypeCheck op a
    onFailedViewsTypeCheck :: forall a.
Seq (View' (TypeCheckedOp op))
-> View' (TypeCheckedOp op) -> TcError' op -> TypeCheck op a
onFailedViewsTypeCheck Seq (View' (TypeCheckedOp op))
processedViews View' (TypeCheckedOp op)
v TcError' op
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
      TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
        then TcError' op -> Contract' (TypeCheckedOp op) -> TcError' op
forall op.
TcError' op -> Contract' (TypeCheckedOp op) -> TcError' op
TcIncompletelyTyped TcError' op
err Contract' (TypeCheckedOp op)
tcContract
             { contractViews :: [View' (TypeCheckedOp op)]
U.contractViews = Seq (View' (TypeCheckedOp op))
-> [Element (Seq (View' (TypeCheckedOp op)))]
forall t. Container t => t -> [Element t]
toList (Seq (View' (TypeCheckedOp op))
processedViews Seq (View' (TypeCheckedOp op))
-> View' (TypeCheckedOp op) -> Seq (View' (TypeCheckedOp op))
forall a. Seq a -> a -> Seq a
|> View' (TypeCheckedOp op)
v)
             }
        else TcError' op
err

typeCheckViews
  :: WellTyped st
  => U.Contract' (TypeCheckedOp U.ExpandedOp)
  -> Notes st
  -> [U.View]
  -> TypeCheck U.ExpandedOp [SomeView st]
typeCheckViews :: forall (st :: T).
WellTyped st =>
Contract' (TypeCheckedOp ExpandedOp)
-> Notes st -> [View] -> TypeCheck ExpandedOp [SomeView st]
typeCheckViews = TcInstrBase ExpandedOp
-> Contract' (TypeCheckedOp ExpandedOp)
-> Notes st
-> [View]
-> TypeCheck ExpandedOp [SomeView st]
forall (st :: T) op.
(WellTyped st, IsInstrOp op) =>
TcInstrBase op
-> Contract' (TypeCheckedOp op)
-> Notes st
-> [View' op]
-> TypeCheck op [SomeView st]
typeCheckViews' TcInstrBase ExpandedOp
typeCheckExpandedOp

-- | 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 U.ExpandedOp (SomeTcInstr inp)
typeCheckList :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheck ExpandedOp (SomeTcInstr inp)
typeCheckList = ReaderT
  (TypeCheckEnv ExpandedOp)
  (ReaderT TypeCheckOptions Identity)
  (TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     (TypeCheckEnv ExpandedOp)
     (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
     (SomeTcInstr inp)
forall op (inp :: [T]) (m :: * -> *) (m' :: * -> *).
(MonadMultiReaderT m Identity,
 m' ~ ChangeMultiReaderBase m (Except (TcError' op)),
 MonadError (TcError' op) m') =>
m (TypeCheckedSeq op inp) -> m' (SomeTcInstr inp)
throwingTcError (ReaderT
   (TypeCheckEnv ExpandedOp)
   (ReaderT TypeCheckOptions Identity)
   (TypeCheckedSeq ExpandedOp inp)
 -> ReaderT
      (TypeCheckEnv ExpandedOp)
      (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
      (SomeTcInstr inp))
-> ([ExpandedOp]
    -> HST inp
    -> ReaderT
         (TypeCheckEnv ExpandedOp)
         (ReaderT TypeCheckOptions Identity)
         (TypeCheckedSeq ExpandedOp inp))
-> [ExpandedOp]
-> HST inp
-> ReaderT
     (TypeCheckEnv ExpandedOp)
     (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
     (SomeTcInstr inp)
forall a b c. SuperComposition a b c => a -> b -> c
... TcInstrBase ExpandedOp
-> [ExpandedOp]
-> HST inp
-> TypeCheckNoExcept ExpandedOp (TypeCheckedSeq ExpandedOp inp)
forall (inp :: [T]) op.
(SingI inp, IsInstrOp op) =>
TcInstrBase op
-> [op] -> HST inp -> TypeCheckNoExcept op (TypeCheckedSeq op inp)
typeCheckListNoExcept TcInstrBase ExpandedOp
typeCheckExpandedOp

-- | 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, IsInstrOp op)
  => TcInstrBase op -> [op] -> HST inp -> TypeCheckNoExcept op (TypeCheckedSeq op inp)
typeCheckListNoExcept :: forall (inp :: [T]) op.
(SingI inp, IsInstrOp op) =>
TcInstrBase op
-> [op] -> HST inp -> TypeCheckNoExcept op (TypeCheckedSeq op inp)
typeCheckListNoExcept TcInstrBase op
tcOp = TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions Identity)
     (TypeCheckedSeq op inp)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op inp)
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions Identity)
      (TypeCheckedSeq op inp))
-> ([op]
    -> HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op inp))
-> [op]
-> HST inp
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions Identity)
     (TypeCheckedSeq op inp)
forall a b c. SuperComposition a b c => a -> b -> c
... TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
typeCheckImpl TcInstrBase op
tcOp

-- | 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 U.ExpandedOp (Value t)
typeCheckValue :: forall (t :: T).
SingI t =>
Value -> TypeCheckResult ExpandedOp (Value t)
typeCheckValue Value
value = do
  TypeCheckMode ExpandedOp
-> TypeCheck ExpandedOp (Value t)
-> TypeCheckResult ExpandedOp (Value t)
forall op a.
TypeCheckMode op -> TypeCheck op a -> TypeCheckResult op a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode ExpandedOp
forall op. (Value' op, T) -> Maybe BigMapFinder -> TypeCheckMode op
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 ExpandedOp (Value t)
 -> TypeCheckResult ExpandedOp (Value t))
-> TypeCheck ExpandedOp (Value t)
-> TypeCheckResult ExpandedOp (Value t)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp)
        (ReaderT
           TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity)))
     (Value t)
-> ReaderT
     (TypeCheckEnv ExpandedOp)
     (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) 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 ExpandedOp)
      (ReaderT
         TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity)))
   (Value t)
 -> ReaderT
      (TypeCheckEnv ExpandedOp)
      (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp)
        (ReaderT
           TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity)))
     (Value t)
-> ReaderT
     (TypeCheckEnv ExpandedOp)
     (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
     (Value t)
forall a b. (a -> b) -> a -> b
$
      Maybe TcOriginatedContracts
-> TcInstrBase ExpandedOp
-> Value
-> TypeCheckInstr ExpandedOp (Value t)
forall (ty :: T) op.
(SingI ty, IsInstrOp op) =>
Maybe TcOriginatedContracts
-> TcInstrBase op -> Value' op -> TypeCheckInstr op (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrBase ExpandedOp
typeCheckExpandedOp 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 U.ExpandedOp (Value t)
typeCheckValueRunCodeCompat :: forall (t :: T).
SingI t =>
BigMapFinder -> Value -> TypeCheckResult ExpandedOp (Value t)
typeCheckValueRunCodeCompat BigMapFinder
bigMapFinder Value
val =
  TypeCheckMode ExpandedOp
-> TypeCheck ExpandedOp (Value t)
-> TypeCheckResult ExpandedOp (Value t)
forall op a.
TypeCheckMode op -> TypeCheck op a -> TypeCheckResult op a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode ExpandedOp
forall op. (Value' op, T) -> Maybe BigMapFinder -> TypeCheckMode op
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 ExpandedOp (Value t)
 -> TypeCheckResult ExpandedOp (Value t))
-> TypeCheck ExpandedOp (Value t)
-> TypeCheckResult ExpandedOp (Value t)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp)
        (ReaderT
           TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity)))
     (Value t)
-> ReaderT
     (TypeCheckEnv ExpandedOp)
     (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) 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 ExpandedOp)
      (ReaderT
         TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity)))
   (Value t)
 -> ReaderT
      (TypeCheckEnv ExpandedOp)
      (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp)
        (ReaderT
           TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity)))
     (Value t)
-> ReaderT
     (TypeCheckEnv ExpandedOp)
     (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
     (Value t)
forall a b. (a -> b) -> a -> b
$
      Maybe TcOriginatedContracts
-> TcInstrBase ExpandedOp
-> Value
-> TypeCheckInstr ExpandedOp (Value t)
forall (ty :: T) op.
(SingI ty, IsInstrOp op) =>
Maybe TcOriginatedContracts
-> TcInstrBase op -> Value' op -> TypeCheckInstr op (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrBase ExpandedOp
typeCheckExpandedOp Value
val

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

typeVerifyStorage
  :: SingI t
  => U.Value -> TypeCheckResult U.ExpandedOp (Value t)
typeVerifyStorage :: forall (t :: T).
SingI t =>
Value -> TypeCheckResult ExpandedOp (Value t)
typeVerifyStorage = TcInstrBase ExpandedOp
-> Value -> TypeCheckResult ExpandedOp (Value t)
forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op -> Value' op -> TypeCheckResult op (Value t)
typeVerifyStorage' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeVerifyStorage'
  :: (SingI t, IsInstrOp op)
  => TcInstrBase op -> U.Value' op -> TypeCheckResult op (Value t)
typeVerifyStorage' :: forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op -> Value' op -> TypeCheckResult op (Value t)
typeVerifyStorage' TcInstrBase op
tcOp = TcInstrBase op
-> Maybe TcOriginatedContracts
-> Value' op
-> TypeCheckResult op (Value t)
forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op
-> Maybe TcOriginatedContracts
-> Value' op
-> TypeCheckResult op (Value t)
typeVerifyTopLevelType' TcInstrBase op
tcOp Maybe TcOriginatedContracts
forall a. Maybe a
Nothing

typeVerifyTopLevelType
  :: forall t. SingI t
  => Maybe TcOriginatedContracts -> U.Value -> TypeCheckResult U.ExpandedOp (Value t)
typeVerifyTopLevelType :: forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts
-> Value -> TypeCheckResult ExpandedOp (Value t)
typeVerifyTopLevelType = TcInstrBase ExpandedOp
-> Maybe TcOriginatedContracts
-> Value
-> TypeCheckResult ExpandedOp (Value t)
forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op
-> Maybe TcOriginatedContracts
-> Value' op
-> TypeCheckResult op (Value t)
typeVerifyTopLevelType' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeVerifyTopLevelType'
  :: forall t op. (SingI t, IsInstrOp op)
  => TcInstrBase op -> Maybe TcOriginatedContracts -> U.Value' op -> TypeCheckResult op (Value t)
typeVerifyTopLevelType' :: forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op
-> Maybe TcOriginatedContracts
-> Value' op
-> TypeCheckResult op (Value t)
typeVerifyTopLevelType' TcInstrBase op
tcOp Maybe TcOriginatedContracts
mOriginatedContracts Value' op
valueU =
  TypeCheckMode op
-> TypeCheck op (Value t) -> TypeCheckResult op (Value t)
forall op a.
TypeCheckMode op -> TypeCheck op a -> TypeCheckResult op a
runTypeCheck ((Value' op, T) -> Maybe BigMapFinder -> TypeCheckMode op
forall op. (Value' op, T) -> Maybe BigMapFinder -> TypeCheckMode op
TypeCheckValue (Value' op
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 op (Value t) -> TypeCheckResult op (Value t))
-> TypeCheck op (Value t) -> TypeCheckResult op (Value t)
forall a b. (a -> b) -> a -> b
$ TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Value t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (Value t)
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Value t)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (Value t)
forall a b. (a -> b) -> a -> b
$
    Maybe TcOriginatedContracts
-> TcInstrBase op -> Value' op -> TypeCheckInstr op (Value t)
forall (ty :: T) op.
(SingI ty, IsInstrOp op) =>
Maybe TcOriginatedContracts
-> TcInstrBase op -> Value' op -> TypeCheckInstr op (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
mOriginatedContracts TcInstrBase op
tcOp Value' op
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 U.ExpandedOp SomeValue
typeCheckParameter :: TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult ExpandedOp SomeValue
typeCheckParameter TcOriginatedContracts
originatedContracts = Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult ExpandedOp 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 U.ExpandedOp SomeValue
typeCheckStorage :: Ty -> Value -> TypeCheckResult ExpandedOp SomeValue
typeCheckStorage = Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult ExpandedOp SomeValue
typeCheckTopLevelType Maybe TcOriginatedContracts
forall a. Maybe a
Nothing

typeCheckTopLevelType
  :: Maybe TcOriginatedContracts -> U.Ty -> U.Value -> TypeCheckResult U.ExpandedOp SomeValue
typeCheckTopLevelType :: Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult ExpandedOp SomeValue
typeCheckTopLevelType = TcInstrBase ExpandedOp
-> Maybe TcOriginatedContracts
-> Ty
-> Value
-> TypeCheckResult ExpandedOp SomeValue
forall op.
IsInstrOp op =>
TcInstrBase op
-> Maybe TcOriginatedContracts
-> Ty
-> Value' op
-> TypeCheckResult op SomeValue
typeCheckTopLevelType' TcInstrBase ExpandedOp
typeCheckExpandedOp

typeCheckTopLevelType'
  :: IsInstrOp op
  => TcInstrBase op -> Maybe TcOriginatedContracts -> U.Ty -> U.Value' op -> TypeCheckResult op SomeValue
typeCheckTopLevelType' :: forall op.
IsInstrOp op =>
TcInstrBase op
-> Maybe TcOriginatedContracts
-> Ty
-> Value' op
-> TypeCheckResult op SomeValue
typeCheckTopLevelType' TcInstrBase op
tcOp Maybe TcOriginatedContracts
mOriginatedContracts (AsUType (Notes t
_ :: Notes t)) Value' op
valueU =
  Value t -> SomeValue
forall (t :: T). SingI t => Value t -> SomeValue
SomeValue (Value t -> SomeValue)
-> ReaderT TypeCheckOptions (Except (TcError' op)) (Value t)
-> ReaderT TypeCheckOptions (Except (TcError' op)) SomeValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: T) op.
(SingI t, IsInstrOp op) =>
TcInstrBase op
-> Maybe TcOriginatedContracts
-> Value' op
-> TypeCheckResult op (Value t)
typeVerifyTopLevelType' @t TcInstrBase op
tcOp Maybe TcOriginatedContracts
mOriginatedContracts Value' op
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
  :: IsInstrOp op
  => U.InstrAbstract op
  -> TypeCheckInstr op (SomeTcInstr s)
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr :: forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
instr = (TcError' op
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
      Identity
      (TypeCheckedSeq op s))
-> (SomeTcInstr s
    -> MultiReaderT
         '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
         Identity
         (TypeCheckedSeq op s))
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     (SomeTcInstr s)
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     Identity
     (TypeCheckedSeq op s)
forall op a b.
(TcError' op -> TypeCheckInstrNoExcept op a)
-> (b -> TypeCheckInstrNoExcept op a)
-> TypeCheckInstr op b
-> TypeCheckInstrNoExcept op a
tcEither
  (\TcError' op
err -> TypeCheckedSeq op s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq op s
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op s))
-> TypeCheckedSeq op s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op s)
forall a b. (a -> b) -> a -> b
$ TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op s
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
IllTypedSeq TcError' op
err [op -> IllTypedInstr op
forall op. op -> IllTypedInstr op
NonTypedInstr (op -> IllTypedInstr op) -> op -> IllTypedInstr op
forall a b. (a -> b) -> a -> b
$ InstrAbstract op -> op
forall op. IsInstrOp op => InstrAbstract op -> op
liftInstr InstrAbstract op
instr])
  (TypeCheckedSeq op s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq op s
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op s))
-> (SomeTcInstr s -> TypeCheckedSeq op s)
-> SomeTcInstr s
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeTcInstr s -> TypeCheckedSeq op s
forall op (inp :: [T]). SomeTcInstr inp -> TypeCheckedSeq op inp
WellTypedSeq)

-- | Alias for 'typeCheckImpl'.
tcList :: IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList :: forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList = (forall {inp :: [T]}.
 SingI inp =>
 op
 -> HST inp
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
      Identity
      (TypeCheckedSeq op inp))
-> forall {inp :: [T]}.
   SingI inp =>
   [op]
   -> HST inp
   -> MultiReaderT
        '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
        Identity
        (TypeCheckedSeq op inp)
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
typeCheckImpl

-- | 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 :: forall op. IsInstrOp op => TcInstrBase op -> TcInstr op (U.InstrAbstract op)
typeCheckInstr :: forall op.
IsInstrOp op =>
TcInstrBase op -> TcInstr op (InstrAbstract op)
typeCheckInstr TcInstrBase op
tcOp InstrAbstract op
uInstr HST inp
inp = case (InstrAbstract op
uInstr, HST inp
inp) of
  (U.EXT ExtInstrAbstract op
ext, HST inp
si) ->
    TcInstrBase op
-> ExtInstrAbstract op
-> HST inp
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (s :: [T]) op.
(SingI s, IsInstrOp op) =>
TcInstrBase op
-> ExtInstrAbstract op
-> HST s
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
typeCheckExt TcInstrBase op
tcOp ExtInstrAbstract op
ext HST inp
si

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

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

  (U.DROPN Word
nTotal, HST inp
inputHST) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr op (TCDropHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDropHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDropHelper inp)
-> (TCDropHelper inp -> SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr op (TCDropHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDropHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCDropHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDropHelper inp)
forall a. TypeCheckInstr op a
notEnoughItemsOnStack'

        (Word
n, ((SingT x, Dict (WellTyped x))
_ ::& HST xs
iTail)) -> do
          Word -> HST xs -> TypeCheckInstr op (TCDropHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDropHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDropHelper xs)
-> (TCDropHelper xs -> TCDropHelper inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Dict (DupableScope x)
Dict <-
      forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
      forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope t)
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.DUPN VarAnn
vn Word
nTotal, HST inp
inputHST) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr op (TCDupNHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDupNHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDupNHelper inp)
-> (TCDupNHelper inp -> SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr op (TCDupNHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDupNHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCDupNHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCDupNHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
_, HST inp
SNil) -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDupNHelper inp)
forall a. TypeCheckInstr op a
notEnoughItemsOnStack'

        (Word
0, HST inp
_) ->
          InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCDupNHelper inp)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
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 @octez-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) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op (TCDupNHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDupNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDupNHelper xs)
-> (TCDupNHelper xs -> TCDupNHelper inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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)

  (InstrAbstract op
U.SWAP, (SingT x, Dict (WellTyped x))
a ::& (SingT x, Dict (WellTyped x))
b ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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))

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

  (U.DIG Word
nTotal, HST inp
inputHST) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr op (TCDigHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDigHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDigHelper inp)
-> (TCDigHelper inp -> SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr op (TCDigHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDigHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCDigHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDigHelper inp)
forall a. TypeCheckInstr op a
notEnoughItemsOnStack'

        (Word
0, i :: HST inp
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_)) -> TCDigHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op (TCDigHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDigHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDigHelper xs)
-> (TCDigHelper xs -> TCDigHelper (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr op (TCDugHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDugHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDugHelper inp)
-> (TCDugHelper inp -> SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr op (TCDugHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (TCDugHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCDugHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op (TCDugHelper (x : xs))
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr op (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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDugHelper (x : xs))
-> (TCDugHelper (x : xs) -> TCDugHelper (x : x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCDugHelper inp)
forall a. TypeCheckInstr op a
notEnoughItemsOnStack'

  (U.PUSH VarAnn
vn Ty
mt Value' op
mval, HST inp
i) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
nt :: Notes t) -> do
      -- Locally switch 'TypeCheckMode' to 'TypeCheckValue'.
      Value t
val <- (TypeCheckEnv op -> TypeCheckEnv op)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Value t)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Value t)
forall (n :: Nat) r (m :: * -> *) a.
MultiReader n r m =>
(r -> r) -> m a -> m a
local' ((TypeCheckMode op -> Identity (TypeCheckMode op))
-> TypeCheckEnv op -> Identity (TypeCheckEnv op)
forall op1 op2.
Iso
  (TypeCheckEnv op1)
  (TypeCheckEnv op2)
  (TypeCheckMode op1)
  (TypeCheckMode op2)
tcModeL ((TypeCheckMode op -> Identity (TypeCheckMode op))
 -> TypeCheckEnv op -> Identity (TypeCheckEnv op))
-> TypeCheckMode op -> TypeCheckEnv op -> TypeCheckEnv op
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Value' op, T) -> Maybe BigMapFinder -> TypeCheckMode op
forall op. (Value' op, T) -> Maybe BigMapFinder -> TypeCheckMode op
TypeCheckValue (Value' op
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 op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (Value t)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Value t)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Value t)
forall a b. (a -> b) -> a -> b
$
        forall (ty :: T) op.
(SingI ty, IsInstrOp op) =>
Maybe TcOriginatedContracts
-> TcInstrBase op -> Value' op -> TypeCheckInstr op (Value ty)
typeCheckValImpl @t Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrBase op
tcOp Value' op
mval

      Dict (ConstantScope t)
proofScope <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ConstantScope t)))
-> Either BadTypeForScope (Dict (ConstantScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op a) -> TypeCheckInstr op a
withWTPInstr @t ((WellTyped t => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped t => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
          HST inp
i HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NONE TypeAnn
tn VarAnn
vn Ty
elMt, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
elNotes :: Notes t) ->
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @t ((WellTyped t => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped t => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
        SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 [op]
mp [op]
mq, (STOption (SingT n
asing :: SingT a), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @a ((WellTyped n =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$
      TcInstrBase op
-> (forall (s' :: [T]).
    Instr xs s' -> Instr (n : xs) s' -> Instr ('TOption n : xs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST xs
-> HST (n : xs)
-> HST ('TOption n : xs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]) op.
(SingI bti, SingI bfi, IsInstrOp op) =>
TcInstrBase op
-> (forall (s' :: [T]).
    Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
genericIf TcInstrBase op
tcOp 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 op1. [op1] -> [op1] -> InstrAbstract op1
U.IF_NONE [op]
mp [op]
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 [op]
_ [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_ [op]
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
  TypeCheckInstr op (SomeTcInstr (x : x : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : x : xs)))
-> (WellTyped ('TPair x x) =>
    TypeCheckInstr op (SomeTcInstr (x : x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TPair n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
        HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack
  (U.PAIRN VarAnn
varAnn Word
nTotal, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ do
    Word -> HST inp -> TypeCheckInstr op (TCPairNHelper inp)
forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr op (TCPairNHelper inp)
go Word
nTotal HST inp
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCPairNHelper inp)
-> (TCPairNHelper inp -> SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
:/ AnnVar -> PeanoNatural n -> Instr inp (PairN n inp)
forall (n :: Nat) (inp :: [T]).
ConstraintPairN n inp =>
AnnVar
-> PeanoNatural n
-> Instr inp (RightComb (LazyTake 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST (PairN n inp)
out
    where
      go :: forall inp. Word -> HST inp -> TypeCheckInstr op (TCPairNHelper inp)
      go :: forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr op (TCPairNHelper inp)
go Word
n HST inp
hst
        | Word
n Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
2 =
            InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCPairNHelper inp)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
              (InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
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 op a) -> TypeCheckInstr op a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
  TypeCheckInstr op (TCPairNHelper (x : x : xs)))
 -> TypeCheckInstr op (TCPairNHelper (x : x : xs)))
-> (WellTyped ('TPair x x) =>
    TypeCheckInstr op (TCPairNHelper (x : x : xs)))
-> TypeCheckInstr op (TCPairNHelper (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
                  TCPairNHelper (x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCPairNHelper (x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCPairNHelper (x : x : xs)))
-> TCPairNHelper (x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op, TypeCheckOptions]
  (ExceptT (TcError' op) Identity)
  (TCPairNHelper inp)
forall a. TypeCheckInstr op 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 op (TCPairNHelper xs)
forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr op (TCPairNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
hstTail ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCPairNHelper (x : x : xs))
-> (TCPairNHelper (x : x : xs)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (TCPairNHelper (x : x : x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op a) -> TypeCheckInstr op a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
  TypeCheckInstr op (TCPairNHelper (x : x : x : xs)))
 -> TypeCheckInstr op (TCPairNHelper (x : x : x : xs)))
-> (WellTyped ('TPair x x) =>
    TypeCheckInstr op (TCPairNHelper (x : x : x : xs)))
-> TypeCheckInstr op (TCPairNHelper (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
                      TCPairNHelper (x : x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCPairNHelper (x : x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCPairNHelper (x : x : x : xs)))
-> TCPairNHelper (x : x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 (LazyTake n (x : x : xs)))
-> SingT ('TPair x (RightComb (LazyTake 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 (LazyTake n (x : x : xs)))
SingT x
bn, Dict (WellTyped ('TPair x (RightComb (LazyTake n (x : x : xs)))))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x (RightComb (LazyTake n (x : x : xs)))),
 Dict (WellTyped ('TPair x (RightComb (LazyTake n (x : x : xs))))))
-> HST xs
-> HST ('TPair x (RightComb (LazyTake 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 op, TypeCheckOptions]
  (ExceptT (TcError' op) Identity)
  (TCPairNHelper inp)
forall a. TypeCheckInstr op a
notEnoughItemsOnStack'

  (U.UNPAIRN Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack
  (U.UNPAIRN Word
nTotal, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Word
-> HST (x : xs) -> TypeCheckInstr op (TCUnpairNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word
-> HST (x : xs) -> TypeCheckInstr op (TCUnpairNHelper (x : xs))
go Word
nTotal HST inp
HST (x : xs)
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCUnpairNHelper (x : xs))
-> (TCUnpairNHelper (x : xs) -> SomeTcInstr (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TPair a b : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TCUnpairNHelper (x : xs))
      go :: forall (x :: T) (xs :: [T]).
Word
-> HST (x : xs) -> TypeCheckInstr op (TCUnpairNHelper (x : xs))
go Word
n HST (x : xs)
hst
        | Word
n Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
2 =
            InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCUnpairNHelper (x : xs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
              (InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCUnpairNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair n1 n2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCUnpairNHelper ('TPair n1 n2 : xs)))
-> TCUnpairNHelper ('TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op, TypeCheckOptions]
  (ExceptT (TcError' op) Identity)
  (TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr op 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 op (TCUnpairNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word
-> HST (x : xs) -> TypeCheckInstr op (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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCUnpairNHelper (n2 : xs))
-> (TCUnpairNHelper (n2 : xs)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (TCUnpairNHelper ('TPair n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)))
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op, TypeCheckOptions]
  (ExceptT (TcError' op) Identity)
  (TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr op a
unexpectedType

      unexpectedType :: TypeCheckInstr op a
      unexpectedType :: forall a. TypeCheckInstr op a
unexpectedType = TcTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     a
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      a)
-> TcTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TPair n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.CDR VarAnn
vn RootAnn
fn, (STPair Sing n1
_ Sing n2
rt, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TPair n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
       (TypeCheckedSeq op (x : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
bn :: Notes r) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @r ((WellTyped t => TypeCheckInstr op (SomeTcInstr (x : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : xs)))
-> (WellTyped t => TypeCheckInstr op (SomeTcInstr (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (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)
        SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
       (TypeCheckedSeq op (x : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq op (x : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
an :: Notes l) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @l ((WellTyped t => TypeCheckInstr op (SomeTcInstr (x : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : xs)))
-> (WellTyped t => TypeCheckInstr op (SomeTcInstr (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (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
        SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.IF_LEFT [op]
mp [op]
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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TOr n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TOr n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @l ((WellTyped n1 =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (WellTyped n1 =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
        forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @r ((WellTyped n2 =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('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
          TcInstrBase op
-> (forall (s' :: [T]).
    Instr (n1 : xs) s'
    -> Instr (n2 : xs) s' -> Instr ('TOr n1 n2 : xs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST (n1 : xs)
-> HST (n2 : xs)
-> HST ('TOr n1 n2 : xs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]) op.
(SingI bti, SingI bfi, IsInstrOp op) =>
TcInstrBase op
-> (forall (s' :: [T]).
    Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
genericIf TcInstrBase op
tcOp 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 op1. [op1] -> [op1] -> InstrAbstract op1
U.IF_LEFT [op]
mp [op]
mq HST (n1 : xs)
ait HST (n2 : xs)
bit HST inp
HST ('TOr n1 n2 : xs)
inp

  (U.IF_LEFT [op]
_ [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_ [op]
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NIL TypeAnn
tn VarAnn
vn Ty
elMt, HST inp
i) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
elNotes :: Notes t) ->
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @('TList t) ((WellTyped ('TList t) => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped ('TList t) => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
        SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
i HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
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 op a) -> TypeCheckInstr op a
withWTPInstr @('TList l) ((WellTyped ('TList x) =>
  TypeCheckInstr op (SomeTcInstr (x : 'TList x : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TList x : xs)))
-> (WellTyped ('TList x) =>
    TypeCheckInstr op (SomeTcInstr (x : 'TList x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TList x : xs))
forall a b. (a -> b) -> a -> b
$
          SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : 'TList x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 -> InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : x : xs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.IF_CONS [op]
mp [op]
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 op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('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
      TcInstrBase op
-> (forall (s' :: [T]).
    Instr (n : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST (n : x : xs)
-> HST xs
-> HST ('TList n : xs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]) op.
(SingI bti, SingI bfi, IsInstrOp op) =>
TcInstrBase op
-> (forall (s' :: [T]).
    Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
genericIf TcInstrBase op
tcOp 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 op1. [op1] -> [op1] -> InstrAbstract op1
U.IF_CONS [op]
mp [op]
mq HST (n : x : xs)
ait HST xs
rs HST inp
HST ('TList n : xs)
inp

  (U.IF_CONS [op]
_ [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_ [op]
_, HST inp
SNil)-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SIZE VarAnn
vn, (STList{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TList n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TList n : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TList n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STSet{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TSet n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TSet n : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TSet n : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STMap{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TString : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TString : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TString : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TString : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TString : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
sizeImpl HST inp
inp VarAnn
vn
  (U.SIZE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.EMPTY_SET TypeAnn
tn VarAnn
vn Ty
mv, HST inp
i) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v) ->
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @('TSet v) ((WellTyped ('TSet t) => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped ('TSet t) => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
        Sing t
-> InstrAbstract op
-> HST inp
-> (Comparable t => SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]) op.
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
Sing a -> InstrAbstract op -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns) InstrAbstract op
uInstr HST inp
inp ((Comparable t => SomeTcInstr inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (Comparable t => SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
          HST inp
i HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ do
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
ktn :: Notes k) ->
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @('TMap k v) ((WellTyped ('TMap t t) => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped ('TMap t t) => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
          Sing t
-> InstrAbstract op
-> HST inp
-> (Comparable t => SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]) op.
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
Sing a -> InstrAbstract op -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) InstrAbstract op
uInstr HST inp
inp ((Comparable t => SomeTcInstr inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (Comparable t => SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
            HST inp
i HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
ktn :: Notes k) ->
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @('TBigMap k v) ((WellTyped ('TBigMap t t) => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped ('TBigMap t t) =>
    TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
          Sing t
-> InstrAbstract op
-> HST inp
-> (Comparable t => SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]) op.
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
Sing a -> InstrAbstract op -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) InstrAbstract op
uInstr HST inp
inp ((Comparable t => SomeTcInstr inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (Comparable t => SomeTcInstr inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
            HST inp
i HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 [op]
mp, (STList (SingT n
vns :: SingT t1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TList n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TList n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TList n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TList n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs))
forall a b. (a -> b) -> a -> b
$
      TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp ('TList n))
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST ('TList n : xs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v'
    -> HST xs -> TypeCheckInstr op (HST (MapOpRes ('TList n) v' : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TList n : xs))
forall (c :: T) (rs :: [T]) op.
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c),
 IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp c)
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
mapImpl TcInstrBase op
tcOp (VarAnn -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) SingT n
SingT (MapOpInp ('TList n))
vns VarAnn
vn InstrAbstract op
uInstr [op]
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 op a) -> TypeCheckInstr op a
withWTPInstr @t ((WellTyped v' => TypeCheckInstr op (HST ('TList v' : xs)))
 -> TypeCheckInstr op (HST ('TList v' : xs)))
-> (WellTyped v' => TypeCheckInstr op (HST ('TList v' : xs)))
-> TypeCheckInstr op (HST ('TList v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TList v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (HST ('TList v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TList v' : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (HST ('TList v' : xs)))
-> HST ('TList v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 [op]
mp, (STOption (SingT n
vns :: SingT t1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOption n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TOption n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOption n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TOption n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @t1 ((WellTyped n =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$
      TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp ('TOption n))
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST ('TOption n : xs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v'
    -> HST xs
    -> TypeCheckInstr op (HST (MapOpRes ('TOption n) v' : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOption n : xs))
forall (c :: T) (rs :: [T]) op.
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c),
 IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp c)
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
mapImpl TcInstrBase op
tcOp (VarAnn -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) SingT n
SingT (MapOpInp ('TOption n))
vns VarAnn
vn InstrAbstract op
uInstr [op]
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 op a) -> TypeCheckInstr op a
withWTPInstr @t ((WellTyped v' => TypeCheckInstr op (HST ('TOption v' : xs)))
 -> TypeCheckInstr op (HST ('TOption v' : xs)))
-> (WellTyped v' => TypeCheckInstr op (HST ('TOption v' : xs)))
-> TypeCheckInstr op (HST ('TOption v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TOption v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (HST ('TOption v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TOption v' : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (HST ('TOption v' : xs)))
-> HST ('TOption v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 [op]
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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @('TPair k v1) ((WellTyped ('TPair n1 n2) =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> (WellTyped ('TPair n1 n2) =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp ('TMap n1 n2))
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST ('TMap n1 n2 : xs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v'
    -> HST xs
    -> TypeCheckInstr op (HST (MapOpRes ('TMap n1 n2) v' : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall (c :: T) (rs :: [T]) op.
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c),
 IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp c)
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
mapImpl TcInstrBase op
tcOp (VarAnn -> [TypeCheckedOp op] -> TypeCheckedInstr op
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 InstrAbstract op
uInstr [op]
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 op a) -> TypeCheckInstr op a
withWTPInstr @('TMap k v) ((WellTyped ('TMap n1 v') =>
  TypeCheckInstr op (HST ('TMap n1 v' : xs)))
 -> TypeCheckInstr op (HST ('TMap n1 v' : xs)))
-> (WellTyped ('TMap n1 v') =>
    TypeCheckInstr op (HST ('TMap n1 v' : xs)))
-> TypeCheckInstr op (HST ('TMap n1 v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TMap n1 v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (HST ('TMap n1 v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TMap n1 v' : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (HST ('TMap n1 v' : xs)))
-> HST ('TMap n1 v' : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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
_ [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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
_ [op]
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

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

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

  (U.ITER [op]
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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op ('TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @('TPair a b) ((WellTyped ('TPair n1 n2) =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> (WellTyped ('TPair n1 n2) =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ TcInstrBase op
-> SingT (IterOpEl ('TMap n1 n2))
-> InstrAbstract op
-> [op]
-> HST ('TMap n1 n2 : xs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TMap n1 n2 : xs))
forall (c :: T) (rs :: [T]) op.
(IterOp c, WellTyped (IterOpEl c), IsInstrOp op) =>
TcInstrBase op
-> SingT (IterOpEl c)
-> InstrAbstract op
-> [op]
-> HST (c : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
iterImpl TcInstrBase op
tcOp (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) InstrAbstract op
uInstr [op]
is HST inp
HST ('TMap n1 n2 : xs)
inp

  (U.ITER [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TSet n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TSet n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TSet n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TSet n : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TSet n : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$
    HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *) op.
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *) op.
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
    HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *) op.
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
memImpl HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
-> SingT (GetOpVal ('TMap n1 n2))
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (getKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *) op.
(GetOp c, SingI (GetOpKey c), WellTyped (GetOpVal c),
 inp ~ (getKey : c : rs), SingI rs, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
HST inp -> SingT (GetOpVal c) -> VarAnn -> m (SomeTcInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
-> SingT (GetOpVal ('TBigMap n1 n2))
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (getKey :: T) (rs :: [T]) (inp :: [T])
       (m :: * -> *) op.
(GetOp c, SingI (GetOpKey c), WellTyped (GetOpVal c),
 inp ~ (getKey : c : rs), SingI rs, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
HST inp -> SingT (GetOpVal c) -> VarAnn -> m (SomeTcInstr 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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.GETN VarAnn
_ Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack
  (U.GETN VarAnn
getNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Word -> HST (x : xs) -> TypeCheckInstr op (TCGetNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr op (TCGetNHelper (x : xs))
go Word
ix0 HST inp
HST (x : xs)
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCGetNHelper (x : xs))
-> (TCGetNHelper (x : xs) -> SomeTcInstr (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST (GetN ix x : xs)
HST (GetN ix pair : rest)
out
    where
      go :: forall x xs. Word -> HST (x : xs) -> TypeCheckInstr op (TCGetNHelper (x : xs))
      go :: forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr op (TCGetNHelper (x : xs))
go Word
0 ((SingT x
a, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCGetNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper ('TPair n1 n2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCGetNHelper ('TPair n1 n2 : xs)))
-> TCGetNHelper ('TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op (TCGetNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr op (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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCGetNHelper (n2 : xs))
-> (TCGetNHelper (n2 : xs) -> TCGetNHelper ('TPair n1 n2 : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     (TCGetNHelper (x : xs))
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      (TCGetNHelper (x : xs)))
-> TcTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *) op.
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *) op.
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TSet n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TSet n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TSet n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TSet n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : 'TSet n : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : x : 'TSet n : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *) op.
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op (TypeCheckedSeq op (x : x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.UPDATEN VarAnn
updateNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Word
-> HST (x : x : xs)
-> TypeCheckInstr op (TCUpdateNHelper (x : x : xs))
forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr op (TCUpdateNHelper (val : pair : rest))
go Word
ix0 HST inp
HST (x : x : xs)
inp ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCUpdateNHelper (x : x : xs))
-> (TCUpdateNHelper (x : x : xs) -> SomeTcInstr (x : x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (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 -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TCUpdateNHelper (val : pair : rest))
      go :: forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr op (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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCUpdateNHelper (val : pair : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCUpdateNHelper (val : pair : xs)))
-> TCUpdateNHelper (val : pair : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (TCUpdateNHelper (val : 'TPair n1 n2 : xs)))
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op (TCUpdateNHelper (x : n2 : xs))
forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr op (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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TCUpdateNHelper (val : n2 : rest))
-> (TCUpdateNHelper (val : n2 : rest)
    -> TCUpdateNHelper (val : 'TPair n1 n2 : rest))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> MultiReaderT
      '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      (TCUpdateNHelper (val : pair : rest)))
-> TcTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
        HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *) op.
(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' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @v ((WellTyped n2 =>
  TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
        HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *) op.
(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' op) m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op (TypeCheckedSeq op (x : x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.IF [op]
mp [op]
mq, (STBool{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    TcInstrBase op
-> (forall (s' :: [T]).
    Instr xs s' -> Instr xs s' -> Instr ('TBool : xs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST xs
-> HST xs
-> HST ('TBool : xs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]) op.
(SingI bti, SingI bfi, IsInstrOp op) =>
TcInstrBase op
-> (forall (s' :: [T]).
    Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
genericIf TcInstrBase op
tcOp 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 op1. [op1] -> [op1] -> InstrAbstract op1
U.IF [op]
mp [op]
mq HST xs
rs HST xs
rs HST inp
HST ('TBool : xs)
inp

  (U.IF [op]
_ [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_ [op]
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LOOP [op]
is, (STBool{}, Dict (WellTyped x)
_) ::& (HST xs
rs :: HST rs)) -> do
    TypeCheckInstrNoExcept op (TypeCheckedSeq op xs)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr xs
    -> TypeCheckInstr op (SomeTcInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs))
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving (TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
is HST xs
rs) [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. [op] -> InstrAbstract op
U.LOOP ((SomeTcInstr xs -> TypeCheckInstr op (SomeTcInstr ('TBool : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs)))
-> (SomeTcInstr xs
    -> TypeCheckInstr op (SomeTcInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs))
forall a b. (a -> b) -> a -> b
$ \(HST xs
_ :/ SomeTcInstrOut xs
tp) ->
      case SomeTcInstrOut 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 -> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut ('TBool : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST xs
rs
            Left TcTypeError
m -> InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBool : xs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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 ->
          SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut ('TBool : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST xs
rs

  (U.LOOP [op]
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_, HST inp
_) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LOOP_LEFT [op]
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 op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @t ((WellTyped n1 =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (WellTyped n1 =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @b ((WellTyped n2 =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('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 op (TypeCheckedSeq op (n1 : xs))
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr (n1 : xs)
    -> TypeCheckInstr op (SomeTcInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving (TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
is HST (n1 : xs)
ait) [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. [op] -> InstrAbstract op
U.LOOP_LEFT ((SomeTcInstr (n1 : xs)
  -> TypeCheckInstr op (SomeTcInstr ('TOr n1 n2 : xs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs)))
-> (SomeTcInstr (n1 : xs)
    -> TypeCheckInstr op (SomeTcInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ \(HST (n1 : xs)
_ :/ SomeTcInstrOut (n1 : xs)
tp) ->
        case SomeTcInstrOut (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') ->
                  SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TOr n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TOr n1 n2 : xs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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)
            SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TOr n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 [op]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 [op]
_, HST inp
_) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LAMBDA VarAnn
vn p1 :: Ty
p1@(AsUType (Notes t
ins :: Notes t)) p2 :: Ty
p2@(AsUType (Notes t
ons :: Notes u)) [op]
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 op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @t ((WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (WellTyped t =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @u ((WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (WellTyped t =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
        TcInstrBase op -> LamTC t t inp op
forall (it :: T) (ot :: T) (ts :: [T]) op.
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
TcInstrBase op -> LamTC it ot ts op
lamImpl TcInstrBase op
tcOp [op]
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)
          (VarAnn -> Ty -> Ty -> [TypeCheckedOp op] -> TypeCheckedInstr op
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) InstrAbstract op
uInstr HST inp
i

  (U.LAMBDA_REC VarAnn
vn p1 :: Ty
p1@(AsUType (Notes t
ins :: Notes t)) p2 :: Ty
p2@(AsUType (Notes t
ons :: Notes u)) [op]
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 op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @t ((WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (WellTyped t =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' @u ((WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (WellTyped t =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
        TcInstrBase op -> LamTC t t inp op
forall (it :: T) (ot :: T) (ts :: [T]) op.
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
TcInstrBase op -> LamTC it ot ts op
lamRecImpl TcInstrBase op
tcOp [op]
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)
          (VarAnn -> Ty -> Ty -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. VarAnn -> Ty -> Ty -> [op] -> InstrAbstract op
U.LAMBDA_REC 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) InstrAbstract op
uInstr 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    x :~: n1
Refl <- Either TcTypeError (x :~: n1)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (x :~: n1)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Either TcTypeError a -> m a
errM (Either TcTypeError (x :~: n1)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (x :~: n1))
-> Either TcTypeError (x :~: n1)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op a) -> TypeCheckInstr op a
withWTPInstr @t2' ((WellTyped n2 =>
  TypeCheckInstr op (SomeTcInstr (x : 'TLambda x n2 : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TLambda x n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr op (SomeTcInstr (x : 'TLambda x n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TLambda x n2 : xs))
forall a b. (a -> b) -> a -> b
$ SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : 'TLambda x n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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' op) m) => Either TcTypeError a -> m a
        errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Either TcTypeError a -> m a
errM = InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n1 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n2 =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr
     op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @('TLambda t1 t2) ((WellTyped ('TLambda n1 n2) =>
  TypeCheckInstr
    op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
 -> TypeCheckInstr
      op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (WellTyped ('TLambda n1 n2) =>
    TypeCheckInstr
      op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr
     op (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
      x :~: n1
proofArgEq <- InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (x :~: n1)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (x :~: n1)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ConstantScope n1)))
-> Either BadTypeForScope (Dict (ConstantScope n1))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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) ->
          SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut (n1 : 'TLambda ('TPair n1 n2) n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.DIP [op]
is, (SingT x, Dict (WellTyped x))
a ::& HST xs
s) -> do
    TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> InstrAbstract op
-> [op]
-> HST xs
-> (TcError' op
    -> [IllTypedInstr op] -> TypeCheckedSeq op (x : xs))
-> (forall (out :: [T]).
    SingI out =>
    Instr xs out -> HST out -> TypeCheckedSeq op (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (inp :: [T]) op r.
(SingI inp, IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> InstrAbstract op
-> [op]
-> HST inp
-> (TcError' op -> [IllTypedInstr op] -> r)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept op r
typeCheckDipBody TcInstrBase op
tcOp [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. [op] -> InstrAbstract op
U.DIP InstrAbstract op
uInstr [op]
is HST xs
s
      (TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op (x : xs)
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
IllTypedSeq)
      (\Instr xs out
subI HST out
t -> SomeTcInstr inp -> TypeCheckedSeq op inp
forall op (inp :: [T]). SomeTcInstr inp -> TypeCheckedSeq op inp
WellTypedSeq (SomeTcInstr inp -> TypeCheckedSeq op inp)
-> SomeTcInstr inp -> TypeCheckedSeq op inp
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 [op]
_is, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.DIPN Word
nTotal [op]
instructions, HST inp
inputHST) ->
    Word -> HST inp -> TypeCheckInstrNoExcept op (TCDipHelper op inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept op (TCDipHelper op inp)
go Word
nTotal HST inp
inputHST ReaderT
  TypeCheckInstrEnv
  (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
  (TCDipHelper op inp)
-> (TCDipHelper op inp -> TypeCheckedSeq op inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCDipHelperErr TcError' op
err [IllTypedInstr op]
rest -> TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
IllTypedSeq TcError' op
err [IllTypedInstr op]
rest
      TCDipHelperOk PeanoNatural n
s Instr s s'
subI HST out
out -> SomeTcInstr inp -> TypeCheckedSeq op inp
forall op (inp :: [T]). SomeTcInstr inp -> TypeCheckedSeq op inp
WellTypedSeq (SomeTcInstr inp -> TypeCheckedSeq op inp)
-> SomeTcInstr inp -> TypeCheckedSeq op inp
forall a b. (a -> b) -> a -> b
$ HST inp
inputHST HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstrNoExcept op (TCDipHelper op inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept op (TCDipHelper op inp)
go Word
n HST inp
curHST = case (Word
n, HST inp
curHST) of
        (Word
0, HST inp
_) -> TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> InstrAbstract op
-> [op]
-> HST inp
-> (TcError' op -> [IllTypedInstr op] -> TCDipHelper op inp)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> TCDipHelper op inp)
-> TypeCheckInstrNoExcept op (TCDipHelper op inp)
forall (inp :: [T]) op r.
(SingI inp, IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> InstrAbstract op
-> [op]
-> HST inp
-> (TcError' op -> [IllTypedInstr op] -> r)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept op r
typeCheckDipBody TcInstrBase op
tcOp (Word -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. Word -> [op] -> InstrAbstract op
U.DIPN Word
nTotal) InstrAbstract op
uInstr [op]
instructions HST inp
curHST
          (TcError' op -> [IllTypedInstr op] -> TCDipHelper op inp
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TCDipHelper op inp
TCDipHelperErr)
          (PeanoNatural 'Z -> Instr inp out -> HST out -> TCDipHelper op inp
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T])
       op.
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper op 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 op) (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' op
err = InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
forall op.
InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
TcFailedOnInstr InstrAbstract op
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 op '[]
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TCDipHelper op '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCDipHelper op '[]
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TCDipHelper op '[]))
-> TCDipHelper op '[]
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TCDipHelper op '[])
forall a b. (a -> b) -> a -> b
$ TcError' op -> [IllTypedInstr op] -> TCDipHelper op '[]
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TCDipHelper op inp
TCDipHelperErr TcError' op
err [op -> IllTypedInstr op
forall op. op -> IllTypedInstr op
NonTypedInstr (op -> IllTypedInstr op) -> op -> IllTypedInstr op
forall a b. (a -> b) -> a -> b
$ InstrAbstract op -> op
forall op. IsInstrOp op => InstrAbstract op -> op
liftInstr InstrAbstract op
uInstr]
        (Word
_, (SingT x, Dict (WellTyped x))
hstHead ::& HST xs
hstTail) ->
          Word -> HST xs -> TypeCheckInstrNoExcept op (TCDipHelper op xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept op (TCDipHelper op inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
hstTail ReaderT
  TypeCheckInstrEnv
  (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
  (TCDipHelper op xs)
-> (TCDipHelper op xs -> TCDipHelper op (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TCDipHelper op (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 op (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T])
       op.
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper op 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' op
err [IllTypedInstr op]
rest -> TcError' op -> [IllTypedInstr op] -> TCDipHelper op (x : xs)
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TCDipHelper op inp
TCDipHelperErr TcError' op
err [IllTypedInstr op]
rest

  (InstrAbstract op
U.FAILWITH, ((SingT x
_ :: SingT a, Dict (WellTyped x)
_) ::& HST xs
_)) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Dict (ConstantScope x)
Dict <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ConstantScope x)))
-> Either BadTypeForScope (Dict (ConstantScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Dict (ConstantScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope a)
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
:/ (forall (out :: [T]). Instr inp out) -> SomeTcInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeTcInstrOut inp
AnyOutInstr forall (out :: [T]). Instr inp out
forall (a :: T) (s :: [T]) (out :: [T]).
(SingI a, ConstantScope a) =>
Instr (a : s) out
FAILWITH

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

  (U.CAST VarAnn
vn (AsUType (Notes t
castToNotes :: Notes t)), (SingT x
_ :: SingT t1, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
      t :~: x
Refl <- Either TcTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (t :~: x)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Either TcTypeError a -> m a
errM (Either TcTypeError (t :~: x)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (t :~: x))
-> Either TcTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op a) -> TypeCheckInstr op a
withWTPInstr @t ((WellTyped t => TypeCheckInstr op (SomeTcInstr (t : xs)))
 -> TypeCheckInstr op (SomeTcInstr (t : xs)))
-> (WellTyped t => TypeCheckInstr op (SomeTcInstr (t : xs)))
-> TypeCheckInstr op (SomeTcInstr (t : xs))
forall a b. (a -> b) -> a -> b
$
        SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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' op) m) => Either TcTypeError a -> m a
      errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Either TcTypeError a -> m a
errM = InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.RENAME VarAnn
vn, (SingT x
an, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.UNPACK TypeAnn
tn VarAnn
vn Ty
mt, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr ('TBytes : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr ('TBytes : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TBytes : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr ('TBytes : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 op a) -> TypeCheckInstr op a
withWTPInstr @('TOption t1) ((WellTyped ('TOption t) =>
  TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
 -> TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
-> (WellTyped ('TOption t) =>
    TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ do
          Dict (UnpackedValScope t)
Dict <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @tn InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (UnpackedValScope t)))
-> Either BadTypeForScope (Dict (UnpackedValScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Dict (UnpackedValScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(UnpackedValScope tn)
          SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.PACK VarAnn
vn, (SingT x
_ :: SingT a, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall a b. (a -> b) -> a -> b
$ do
    Dict (PackedValScope x)
Dict <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Dict (PackedValScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(PackedValScope a)
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.CONCAT VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBytes : 'TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBytes : 'TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBytes : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, inp ~ (c : c : rs), WellTyped c,
 MonadReader TypeCheckInstrEnv m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
concatImpl HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
vn, (STString{}, Dict (WellTyped x)
_) ::& (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TString : 'TString : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TString : 'TString : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TString : 'TString : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TString : 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, inp ~ (c : c : rs), WellTyped c,
 MonadReader TypeCheckInstrEnv m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
concatImpl HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
vn, (STList Sing n
SingT n
STBytes, Dict (WellTyped x)
_) ::& HST xs
_) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TList 'TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TList 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TList 'TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TList 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, WellTyped c, inp ~ ('TList c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
concatImpl' HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
vn, (STList Sing n
SingT n
STString, Dict (WellTyped x)
_) ::& HST xs
_) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TList 'TString : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TList 'TString : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TList 'TString : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TList 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, WellTyped c, inp ~ ('TList c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr inp)
concatImpl' HST inp
inp VarAnn
vn
  (U.CONCAT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SLICE VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::&
               (STNat{}, Dict (WellTyped x)
_) ::&
               (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : 'TString : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : 'TString : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : 'TString : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SliceOp c, inp ~ ('TNat : 'TNat : c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : 'TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : 'TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SliceOp c, inp ~ ('TNat : 'TNat : c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeTcInstr 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 op (TypeCheckedSeq op (x : x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.ISNAT VarAnn
vn', (STInt{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TInt : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> Sing x
-> HST inp
-> VarAnn
-> InstrAbstract op
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *) op.
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
 MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> InstrAbstract op
-> m (SomeTcInstr inp)
addImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn InstrAbstract op
uInstr

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

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

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

  (U.SUB_MUTEZ VarAnn
vn, (SingT x
STMutez, Dict (WellTyped x)
_) ::& (SingT x
STMutez, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TMutez : 'TMutez : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TMutez : 'TMutez : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TMutez : 'TMutez : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TMutez : 'TMutez : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.SUB_MUTEZ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

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

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

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

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

  (U.ABS VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NEG VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TNat : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TNat : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TNat : xs)))
-> SomeTcInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381Fr : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBls12381Fr : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TBls12381Fr : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBls12381Fr : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBls12381Fr : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TBls12381Fr : xs)))
-> SomeTcInstr ('TBls12381Fr : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381G1 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBls12381G1 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBls12381G1 : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381G1 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TBls12381G1 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBls12381G1 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBls12381G1 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TBls12381G1 : xs)))
-> SomeTcInstr ('TBls12381G1 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381G2 : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBls12381G2 : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBls12381G2 : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381G2 : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TBls12381G2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBls12381G2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBls12381G2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TBls12381G2 : xs)))
-> SomeTcInstr ('TBls12381G2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LSL VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.LSL VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LSR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.LSR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.OR VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
            (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBool : 'TBool : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBool : 'TBool : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.OR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
            (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.OR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.AND VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TInt : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TInt : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TInt : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.AND VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.AND VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
             (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBool : 'TBool : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBool : 'TBool : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.AND VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.XOR VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
             (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBool : 'TBool : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBool : 'TBool : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.XOR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TNat : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *) op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *)
       op.
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> InstrAbstract op -> t (SomeTcInstr 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 InstrAbstract op
uInstr
  (U.XOR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NOT VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TNat : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TNat : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TNat : xs)))
-> SomeTcInstr ('TNat : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBool : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBool : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBool : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBool : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TBool : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBool : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBool : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TBool : xs)))
-> SomeTcInstr ('TBool : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.COMPARE VarAnn
vn,
        (SingT x
_ :: SingT aT, Dict (WellTyped x)
_)
    ::& (SingT x
_ :: SingT bT, Dict (WellTyped x)
_)
    ::& HST xs
rs
    )
    -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : x : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @aT (VarAnn -> InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ComparabilityScope x)))
-> Either BadTypeForScope (Dict (ComparabilityScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 ->
            SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
        InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : x : xs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.EQ VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NEQ VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LT VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.GT VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.LE VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.GE VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 (SomeTcInstr 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 (SomeTcInstr 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.INT VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381Fr : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBls12381Fr : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBls12381Fr : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TAddress : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TAddress : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TAddress : xs))
forall a b. (a -> b) -> a -> b
$
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @ret ((WellTyped t =>
  TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs)))
-> (WellTyped t =>
    TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TAddress : xs))
forall a b. (a -> b) -> a -> b
$ do
        Dict (ViewableScope t)
Dict <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @ret InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (Dict (ViewableScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope ret)
        SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : 'TAddress : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SELF VarAnn
vn RootAnn
fn, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> (IsNotInView => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r.
InstrAbstract op
-> (IsNotInView => TypeCheckInstr op r) -> TypeCheckInstr op r
withNotInView InstrAbstract op
uInstr do
    TypeCheckMode op
mode <- (TypeCheckEnv op -> TypeCheckMode op)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TypeCheckMode op)
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckEnv op -> TypeCheckMode op
forall op. TypeCheckEnv op -> TypeCheckMode op
tcMode
    case TypeCheckMode op
mode of
      TypeCheckValue (Value' op
value, T
ty) Maybe BigMapFinder
_ ->
        Value' op
-> T
-> Text
-> Maybe TcTypeError
-> TypeCheckInstr op (SomeTcInstr inp)
forall op a.
Value' op -> T -> Text -> Maybe TcTypeError -> TypeCheckInstr op a
tcFailedOnValue Value' op
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 op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (MkEntrypointCallRes t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (MkEntrypointCallRes t)
forall a b. a -> (a -> b) -> b
& InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (MkEntrypointCallRes t)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (MkEntrypointCallRes t)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op a) -> TypeCheckInstr op a
withWTPInstr @('TContract t1) ((WellTyped ('TContract arg) =>
  TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (WellTyped ('TContract arg) =>
    TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
                    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op
TypeCheckTest ->
        TcTypeError -> TypeCheckInstr op (SomeTcInstr inp)
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError -> TypeCheckInstr op (SomeTcInstr inp))
-> TcTypeError -> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
uInstr) Text
"'SELF' appears in test typechecking"
  (U.CONTRACT VarAnn
vn RootAnn
fn Ty
mt, (STAddress{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TAddress : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TAddress : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TAddress : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr ('TAddress : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('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 op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       (SomeTcInstr ('TAddress : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TAddress : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr ('TAddress : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
tns :: Notes t) -> do
      Dict (ParameterScope t)
proofScope <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 <- InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError EpName
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     EpName
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      EpName)
-> Either TcTypeError EpName
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op a) -> TypeCheckInstr op a
withWTPInstr @t ((WellTyped t => TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
 -> TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
-> (WellTyped t =>
    TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$ SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TAddress : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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 op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (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 op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs)))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs)))
-> (SingI n =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TMutez : 'TContract n : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs)))
-> TypeCheckInstr
     op (SomeTcInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op (x : 'TMutez : 'TContract n : xs))
forall a b. (a -> b) -> a -> b
$
      InstrAbstract op
-> (IsNotInView =>
    TypeCheckInstr op (SomeTcInstr (x : 'TMutez : 'TContract n : xs)))
-> TypeCheckInstr
     op (SomeTcInstr (x : 'TMutez : 'TContract n : xs))
forall r.
InstrAbstract op
-> (IsNotInView => TypeCheckInstr op r) -> TypeCheckInstr op r
withNotInView InstrAbstract op
uInstr do
        Dict (ParameterScope n)
proofScope <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @p InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (ParameterScope n)))
-> Either BadTypeForScope (Dict (ParameterScope n))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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) ->
            SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut (x : 'TMutez : 'TContract x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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)
_) ->
            InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TMutez : 'TContract n : xs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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 op (TypeCheckedSeq op (x : x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SET_DELEGATE VarAnn
vn,
    (STOption Sing n
SingT n
STKeyHash, Dict (WellTyped x)
_)
    ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TOption 'TKeyHash : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TOption 'TKeyHash : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TOption 'TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> (IsNotInView =>
    TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs))
forall r.
InstrAbstract op
-> (IsNotInView => TypeCheckInstr op r) -> TypeCheckInstr op r
withNotInView InstrAbstract op
uInstr do
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TOption 'TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.CREATE_CONTRACT VarAnn
ovn VarAnn
avn Contract' op
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) -> InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TOption 'TKeyHash : 'TMutez : x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TOption 'TKeyHash : 'TMutez : x : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract op
-> (IsNotInView =>
    TypeCheckInstr
      op (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
forall r.
InstrAbstract op
-> (IsNotInView => TypeCheckInstr op r) -> TypeCheckInstr op r
withNotInView InstrAbstract op
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 op)
  (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
  SomeContract
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     SomeContract
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT
   (TypeCheckEnv op)
   (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
   SomeContract
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      SomeContract)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     SomeContract
forall a b. (a -> b) -> a -> b
$ TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
forall op.
IsInstrOp op =>
TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
doTypeCheckContract' TcInstrBase op
tcOp Contract' op
contract
      x :~: st
Refl <- InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (x :~: st)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (x :~: st)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (x :~: st))
-> Either TcTypeError (x :~: st)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure
        (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TOption 'TKeyHash : 'TMutez : st : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.IMPLICIT_ACCOUNT VarAnn
vn, (STKeyHash{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKeyHash : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TKeyHash : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKeyHash : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NOW VarAnn
vn, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKeyHash : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TKeyHash : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKeyHash : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.TOTAL_VOTING_POWER VarAnn
vn, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) ->
    InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TKey : 'TSignature : 'TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TKey : 'TSignature : 'TBytes : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TKey : 'TSignature : 'TBytes : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TKey : 'TSignature : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TKey : 'TSignature : 'TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SHA256 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SHA512 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.BLAKE2B VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SHA3 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.KECCAK VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.HASH_KEY VarAnn
vn, (STKey{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TKey : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKey : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TKey : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKey : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TKey : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TKey : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TKey : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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) ->
    InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
     op
     (TypeCheckedSeq
        op ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
 -> TypeCheckInstrNoExcept
      op
      (TypeCheckedSeq
         op ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
     op
     (TypeCheckedSeq
        op ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SOURCE VarAnn
vn, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TContract n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TContract n : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TContract n : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TContract n : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut ('TContract n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.CHAIN_ID VarAnn
vn, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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)

  (InstrAbstract op
U.NEVER, (STNever{}, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TNever : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNever : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TNever : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNever : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TNever : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TNever : xs))
forall a b. (a -> b) -> a -> b
$
    SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
:/ (forall (out :: [T]). Instr inp out) -> SomeTcInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeTcInstrOut inp
AnyOutInstr forall (out :: [T]). Instr inp out
forall (s :: [T]) (out :: [T]). Instr ('TNever : s) out
NEVER
  (InstrAbstract op
U.NEVER, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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
:| []
  (InstrAbstract op
U.NEVER, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.TICKET VarAnn
vn, (Sing x
stVal :: Sing v, Dict (WellTyped x)
_) ::& (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @v ((WellTyped x => TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
-> (WellTyped x =>
    TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> InstrAbstract op
-> HST inp
-> (Comparable x => SomeTcInstr (x : 'TNat : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TNat : xs))
forall (a :: T) (m :: * -> *) v (ts :: [T]) op.
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
Sing a -> InstrAbstract op -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck Sing x
stVal InstrAbstract op
uInstr HST inp
inp ((Comparable x => SomeTcInstr (x : 'TNat : xs))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : 'TNat : xs)))
-> (Comparable x => SomeTcInstr (x : 'TNat : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
:/ AnnVar -> Instr (x : 'TNat : xs) ('TOption ('TTicket x) : xs)
forall (a :: T) (s :: [T]).
Comparable a =>
AnnVar -> Instr (a : 'TNat : s) ('TOption ('TTicket a) : s)
AnnTICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TNat : xs) ('TOption ('TTicket x) : xs)
-> HST ('TOption ('TTicket x) : xs)
-> SomeTcInstrOut (x : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((SingT ('TOption ('TTicket x))
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TOption ('TTicket x)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TTicket x)),
 Dict (WellTyped ('TOption ('TTicket x))))
-> HST xs -> HST ('TOption ('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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.TICKET_DEPRECATED VarAnn
vn, (Sing x
stVal :: Sing v, Dict (WellTyped x)
_) ::& (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr @v ((WellTyped x => TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
-> (WellTyped x =>
    TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
    Sing x
-> InstrAbstract op
-> HST inp
-> (Comparable x => SomeTcInstr (x : 'TNat : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TNat : xs))
forall (a :: T) (m :: * -> *) v (ts :: [T]) op.
(SingI ts, MonadReader TypeCheckInstrEnv m,
 MonadError (TcError' op) m) =>
Sing a -> InstrAbstract op -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck Sing x
stVal InstrAbstract op
uInstr HST inp
inp ((Comparable x => SomeTcInstr (x : 'TNat : xs))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : 'TNat : xs)))
-> (Comparable x => SomeTcInstr (x : 'TNat : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
      HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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_DEPRECATED (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) -> SomeTcInstrOut (x : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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_DEPRECATED VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
    TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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_DEPRECATED VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.READ_TICKET VarAnn
vn, ticket :: (SingT x, Dict (WellTyped x))
ticket@(STTicket{}, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TTicket n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr ('TTicket n : xs))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TTicket n : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ('TTicket n : xs))
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TTicket n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SPLIT_TICKET VarAnn
vn, (STTicket{}, Dict (WellTyped x)
Dict) ::& (STPair STNat{} STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
    InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TTicket n : 'TPair 'TNat 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TTicket n : 'TPair 'TNat 'TNat : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TTicket n : 'TPair 'TNat 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TTicket n : 'TPair 'TNat 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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) ->
    InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair ('TTicket n) ('TTicket n) : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TPair ('TTicket n) ('TTicket n) : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TPair ('TTicket n) ('TTicket n) : xs))
forall a b. (a -> b) -> a -> b
$ do
      n1 :~: n2
Refl <-
        InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (n1 :~: n2)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (n1 :~: n2)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (n1 :~: n2))
-> Either TcTypeError (n1 :~: n2)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TPair ('TTicket n) ('TTicket n) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op 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) ->
      InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TChestKey : 'TChest : 'TNat : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TChestKey : 'TChest : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TChestKey : 'TChest : 'TNat : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TChestKey : 'TChest : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$ do
        Bool
isStrict <- (TypeCheckOptions -> Bool)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcStrict
        Bool
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
isStrict (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   ()
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      ())
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall a b. (a -> b) -> a -> b
$
          InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (TcTypeError
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      ())
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall a b. (a -> b) -> a -> b
$
            InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
uInstr) Text
"OPEN_CHEST temporarily deprecated"
        pure $ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TChestKey : 'TChest : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op (TypeCheckedSeq op (x : x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.SAPLING_EMPTY_STATE VarAnn
vn Natural
n, HST inp
_) -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr op (SomeTcInstr inp)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstr op (SomeTcInstr inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$
    (\(SomeSing (Sing a
s :: Sing a)) -> Sing a
-> (SingI a =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT
       (TypeCheckEnv op)
       (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
    (SomeTcInstr inp))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> (SingI a =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeSing Nat
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr 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) ->
      InstrAbstract op
-> TypeCheckInstr
     op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
     op
     (TypeCheckedSeq
        op ('TSaplingTransaction n : 'TSaplingState n : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (TypeCheckInstr
   op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
 -> TypeCheckInstrNoExcept
      op
      (TypeCheckedSeq
         op ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> TypeCheckInstr
     op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
     op
     (TypeCheckedSeq
        op ('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 ->
            SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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)
-> SomeTcInstrOut ('TSaplingTransaction n : 'TSaplingState n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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
     op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> TypeCheckInstr
      op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> TcTypeError
-> TypeCheckInstr
     op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a b. (a -> b) -> a -> b
$ InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
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 op (TypeCheckedSeq op (x : x : xs))
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr (TcTypeError
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : x : xs)))
-> TcTypeError
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (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 op (TypeCheckedSeq op inp)
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

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

  (U.EMIT VarAnn
va RootAnn
tag Maybe Ty
mty, ((SingT x
_ :: SingT t2), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
    InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (x : xs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (x : xs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr do
      Dict (PackedValScope x)
Dict <- forall (t :: T) op (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m,
 SingI t) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t2 InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (t :~: x)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Either TcTypeError a -> m a
errM (Either TcTypeError (t :~: x)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (t :~: x))
-> Either TcTypeError (t :~: x)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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
          SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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 ->
          SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr inp))
-> SomeTcInstr inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut 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' op) m) => Either TcTypeError a -> m a
        errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
Either TcTypeError a -> m a
errM = InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op (TypeCheckedSeq op inp))
      -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
    withWTPInstr' :: forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr' = forall (t :: T) op (inp :: [T]).
(SingI t, IsInstrOp op) =>
InstrAbstract op
-> SomeHST
-> (WellTyped t =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
withWTPInstr'_ @t InstrAbstract op
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 op a) -> TypeCheckInstr op a
    withWTPInstr :: forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr op a) -> TypeCheckInstr op a
withWTPInstr = forall (t :: T) op a.
SingI t =>
InstrAbstract op
-> SomeHST
-> (WellTyped t => TypeCheckInstr op a)
-> TypeCheckInstr op a
withWTPInstr_ @t InstrAbstract op
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp)

    failWithErr :: TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
    failWithErr :: forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr = InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr a)
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     Identity
     (TypeCheckedSeq op a)
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
uInstr (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (SomeTcInstr a)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op a))
-> (TcTypeError
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         (SomeTcInstr a))
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr a)
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr'

    failWithErr' :: TcTypeError -> TypeCheckInstr op a
    failWithErr' :: forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' = InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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 op (TypeCheckedSeq op a)
    notEnoughItemsOnStack :: forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack = TcTypeError
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv op, TypeCheckOptions]
     Identity
     (TypeCheckedSeq op a)
forall (a :: [T]).
TcTypeError -> TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
failWithErr TcTypeError
NotEnoughItemsOnStack

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

    withNotInView :: U.InstrAbstract op -> (IsNotInView => TypeCheckInstr op r) -> TypeCheckInstr op r
    withNotInView :: forall r.
InstrAbstract op
-> (IsNotInView => TypeCheckInstr op r) -> TypeCheckInstr op r
withNotInView InstrAbstract op
instr IsNotInView => TypeCheckInstr op r
act = (TypeCheckEnv op -> TypeCheckMode op)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TypeCheckMode op)
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' (forall op. TypeCheckEnv op -> TypeCheckMode op
tcMode @op) ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (TypeCheckMode op)
-> (TypeCheckMode op
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         r)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op
TypeCheckTest -> (IsNotInView =>
 ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   r)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     r
forall r. (IsNotInView => r) -> r
giveNotInView IsNotInView =>
ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  r
IsNotInView => TypeCheckInstr op r
act
      TypeCheckMode op
_ -> Getting
  (Maybe (Dict IsNotInView))
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  (Maybe (Dict IsNotInView))
-> (Maybe (Dict IsNotInView)
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         r)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Just Dict IsNotInView
Dict -> ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  r
IsNotInView => TypeCheckInstr op r
act
        Maybe (Dict IsNotInView)
Nothing -> TcTypeError -> TypeCheckInstr op r
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError -> TypeCheckInstr op r)
-> TcTypeError -> TypeCheckInstr op r
forall a b. (a -> b) -> a -> b
$
          InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
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 op .
    (SingI bti, SingI bfi, IsInstrOp op)
  => TcInstrBase op
  -> (forall s'.
        Instr bti s' ->
        Instr bfi s' ->
        Instr (cond ': rs) s'
     )
  -> (forall op1. [op1] -> [op1] -> U.InstrAbstract op1)
  -> [op]
  -> [op]
  -> HST bti
  -> HST bfi
  -> HST (cond ': rs)
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond ': rs))
genericIf :: forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]) op.
(SingI bti, SingI bfi, IsInstrOp op) =>
TcInstrBase op
-> (forall (s' :: [T]).
    Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op1. [op1] -> [op1] -> InstrAbstract op1)
-> [op]
-> [op]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
genericIf TcInstrBase op
tcOp forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons forall op1. [op1] -> [op1] -> InstrAbstract op1
mCons [op]
mbt [op]
mbf HST bti
bti HST bfi
bfi i :: HST (cond : rs)
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_) = do
  let cons1 :: [TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op)
cons1 [TypeCheckedOp op]
opsT = [TypeCheckedOp op]
-> [TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op)
forall op1. [op1] -> [op1] -> InstrAbstract op1
mCons [TypeCheckedOp op]
opsT ((op -> TypeCheckedOp op) -> [op] -> [TypeCheckedOp op]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (IllTypedInstr op -> TypeCheckedOp op
forall op. IllTypedInstr op -> TypeCheckedOp op
IllTypedOp (IllTypedInstr op -> TypeCheckedOp op)
-> (op -> IllTypedInstr op) -> op -> TypeCheckedOp op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. op -> IllTypedInstr op
forall op. op -> IllTypedInstr op
NonTypedInstr) [op]
mbf)
  TypeCheckInstrNoExcept op (TypeCheckedSeq op bti)
-> ([TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op))
-> (SomeTcInstr bti
    -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp
    -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving' (TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
mbt HST bti
bti) [TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op)
cons1 ((SomeTcInstr bti
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs)))
-> (SomeTcInstr bti
    -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
forall a b. (a -> b) -> a -> b
$ \tInstr :: SomeTcInstr bti
tInstr@(HST bti
_ :/ SomeTcInstrOut bti
pinstr) -> do
    let cons2 :: [TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op)
cons2 [TypeCheckedOp op]
opsF = [TypeCheckedOp op]
-> [TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op)
forall op1. [op1] -> [op1] -> InstrAbstract op1
mCons [SomeTcInstr bti -> TypeCheckedOp op
forall (inp :: [T]) op. SomeTcInstr inp -> TypeCheckedOp op
someInstrToOp SomeTcInstr bti
tInstr] [TypeCheckedOp op]
opsF
    TypeCheckInstrNoExcept op (TypeCheckedSeq op bfi)
-> ([TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op))
-> (SomeTcInstr bfi -> TypeCheckInstr op (SomeTcInstr (cond : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving (TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
mbf HST bfi
bfi) [TypeCheckedOp op] -> InstrAbstract (TypeCheckedOp op)
cons2 ((SomeTcInstr bfi -> TypeCheckInstr op (SomeTcInstr (cond : rs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs)))
-> (SomeTcInstr bfi -> TypeCheckInstr op (SomeTcInstr (cond : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (cond : rs))
forall a b. (a -> b) -> a -> b
$ \(HST bfi
_ :/ SomeTcInstrOut bfi
qinstr) -> do
      (SomeTcInstrOut (cond : rs) -> SomeTcInstr (cond : rs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (cond : rs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HST (cond : rs)
i HST (cond : rs)
-> SomeTcInstrOut (cond : rs) -> SomeTcInstr (cond : rs)
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
:/) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (SomeTcInstrOut (cond : rs))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (cond : rs)))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (cond : rs))
forall a b. (a -> b) -> a -> b
$ case (SomeTcInstrOut bti
pinstr, SomeTcInstrOut bfi
qinstr) of
        (Instr bti out
p ::: HST out
po, Instr bfi out
q ::: HST out
qo) -> do
          let instr :: InstrAbstract op
instr = [op] -> [op] -> InstrAbstract op
forall op1. [op1] -> [op1] -> InstrAbstract op1
mCons [op]
mbt [op]
mbf
          out :~: out
Refl <- InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (out :~: out)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (out :~: out)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (out :~: out))
-> Either TcTypeError (out :~: out)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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
          SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (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 -> SomeTcInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
HST out
qo
        (AnyOutInstr forall (out :: [T]). Instr bti out
p, Instr bfi out
q ::: HST out
qo) -> do
          SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (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 -> SomeTcInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
qo
        (Instr bti out
p ::: HST out
po, AnyOutInstr forall (out :: [T]). Instr bfi out
q) -> do
          SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (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 -> SomeTcInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
po
        (AnyOutInstr forall (out :: [T]). Instr bti out
p, AnyOutInstr forall (out :: [T]). Instr bfi out
q) ->
          SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ (forall (out :: [T]). Instr (cond : rs) out)
-> SomeTcInstrOut (cond : rs)
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeTcInstrOut 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 op.
    ( MapOp c
    , WellTyped (MapOpInp c)
    , SingIOne (MapOpRes c)
    , IsInstrOp op
    )
  => TcInstrBase op
  -> ([TypeCheckedOp op] -> TypeCheckedInstr op)
  -> SingT (MapOpInp c)
  -> VarAnn
  -> U.InstrAbstract op
  -> [op]
  -> HST (c ': rs)
  -> (forall v'. (SingI v') =>
        SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' ': rs)))
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c ': rs))
mapImpl :: forall (c :: T) (rs :: [T]) op.
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c),
 IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> SingT (MapOpInp c)
-> VarAnn
-> InstrAbstract op
-> [op]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
mapImpl TcInstrBase op
tcOp [TypeCheckedOp op] -> TypeCheckedInstr op
cons SingT (MapOpInp c)
vn VarAnn
anns InstrAbstract op
instr [op]
mp i :: HST (c : rs)
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
rs) forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' : rs))
mkRes = do
  TypeCheckInstrNoExcept op (TypeCheckedSeq op (MapOpInp c : rs))
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr (MapOpInp c : rs)
    -> TypeCheckInstr op (SomeTcInstr (c : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving (TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
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 op] -> TypeCheckedInstr op
cons ((SomeTcInstr (MapOpInp c : rs)
  -> TypeCheckInstr op (SomeTcInstr (c : rs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs)))
-> (SomeTcInstr (MapOpInp c : rs)
    -> TypeCheckInstr op (SomeTcInstr (c : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
forall a b. (a -> b) -> a -> b
$ \(HST (MapOpInp c : rs)
_ :/ SomeTcInstrOut (MapOpInp c : rs)
subp) ->
    case SomeTcInstrOut (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 <- InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (xs :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (xs :~: xs)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (xs :~: xs))
-> Either TcTypeError (xs :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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 op (HST (MapOpRes c x : rs))
forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr op (HST (MapOpRes c v' : rs))
mkRes SingT x
bn HST rs
HST xs
rs'
            pure $ HST (c : rs)
i HST (c : rs) -> SomeTcInstrOut (c : rs) -> SomeTcInstr (c : rs)
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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) -> SomeTcInstrOut (c : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST (MapOpRes c x : rs)
x)
          HST out
_ -> InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (c : rs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op -> SomeHST -> Maybe TypeContext -> m a
typeCheckInstrErr InstrAbstract op
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
_ ->
        InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (c : rs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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 op .
    ( IterOp c
    , WellTyped (IterOpEl c)
    , IsInstrOp op
    )
  => TcInstrBase op
  -> SingT (IterOpEl c)
  -> U.InstrAbstract op
  -> [op]
  -> HST (c ': rs)
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c ': rs))
iterImpl :: forall (c :: T) (rs :: [T]) op.
(IterOp c, WellTyped (IterOpEl c), IsInstrOp op) =>
TcInstrBase op
-> SingT (IterOpEl c)
-> InstrAbstract op
-> [op]
-> HST (c : rs)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
iterImpl TcInstrBase op
tcOp SingT (IterOpEl c)
en InstrAbstract op
instr [op]
mp i :: HST (c : rs)
i@((SingT x
_, Dict (WellTyped x)
_) ::& HST xs
rs) = do
  let tcAction :: TypeCheckInstrNoExcept op (TypeCheckedSeq op (IterOpEl c : rs))
tcAction = case [op]
mp of
        [] -> InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr (IterOpEl c : rs))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (IterOpEl c : rs))
forall op (s :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op (SomeTcInstr s)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op s)
workOnInstr InstrAbstract op
instr
          (InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (IterOpEl c : rs))
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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)
        [op]
_ -> TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
typeCheckImpl TcInstrBase op
tcOp [op]
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 op (TypeCheckedSeq op (IterOpEl c : rs))
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr (IterOpEl c : rs)
    -> TypeCheckInstr op (SomeTcInstr (c : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving TypeCheckInstrNoExcept op (TypeCheckedSeq op (IterOpEl c : rs))
tcAction [TypeCheckedOp op] -> TypeCheckedInstr op
forall op. [op] -> InstrAbstract op
U.ITER ((SomeTcInstr (IterOpEl c : rs)
  -> TypeCheckInstr op (SomeTcInstr (c : rs)))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs)))
-> (SomeTcInstr (IterOpEl c : rs)
    -> TypeCheckInstr op (SomeTcInstr (c : rs)))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op (c : rs))
forall a b. (a -> b) -> a -> b
$ \(HST (IterOpEl c : rs)
_ :/ SomeTcInstrOut (IterOpEl c : rs)
subp) -> case SomeTcInstrOut (IterOpEl c : rs)
subp of
    Instr (IterOpEl c : rs) out
subI ::: HST out
o -> do
      out :~: xs
Refl <- InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> Either TcTypeError (out :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (out :~: xs)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> Either TcTypeError a -> m a
onTypeCheckInstrErr InstrAbstract op
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 op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (out :~: xs))
-> Either TcTypeError (out :~: xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) 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
      SomeTcInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (c : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (c : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (c : rs)))
-> SomeTcInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (c : rs))
forall a b. (a -> b) -> a -> b
$ HST (c : rs)
i HST (c : rs) -> SomeTcInstrOut (c : rs) -> SomeTcInstr (c : rs)
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut (c : out)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST out
o
    AnyOutInstr forall (out :: [T]). Instr (IterOpEl c : rs) out
subI ->
      SomeTcInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (c : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (c : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (c : rs)))
-> SomeTcInstr (c : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (c : rs))
forall a b. (a -> b) -> a -> b
$ HST (c : rs)
i HST (c : rs) -> SomeTcInstrOut (c : rs) -> SomeTcInstr (c : rs)
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr 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 -> SomeTcInstrOut (c : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST xs
rs

type LamTC it ot ts op
  =  [op]
  -> SingT it
  -> SingT ot
  ->  ([TypeCheckedOp op] -> TypeCheckedInstr op)
  -> Anns '[VarAnn, Notes it, Notes ot]
  -> U.InstrAbstract op
  -> HST ts
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)

lamImpl
  :: forall it ot ts op .
    ( WellTyped it, WellTyped ot
    , SingI ts
    , IsInstrOp op
    )
  => TcInstrBase op
  -> LamTC it ot ts op
lamImpl :: forall (it :: T) (ot :: T) (ts :: [T]) op.
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
TcInstrBase op -> LamTC it ot ts op
lamImpl TcInstrBase op
tcOp [op]
is SingT it
ins = (Anns '[VarAnn, Notes it, Notes ot]
 -> RemFail Instr '[it] '[ot] -> Instr ts ('TLambda it ot : ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
-> LamTC it ot ts op
forall (it :: T) (ot :: T) (ts :: [T]) op (inp :: [T]).
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
(Anns '[VarAnn, Notes it, Notes ot]
 -> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> LamTC it ot ts op
lamCommon Anns '[VarAnn, Notes it, Notes ot]
-> RemFail Instr '[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]
-> RemFail Instr '[i] '[o] -> Instr inp ('TLambda i o : inp)
AnnLAMBDA
  ((IsNotInView =>
 ReaderT
   TypeCheckInstrEnv
   (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[it]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op '[it]))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[it]))
-> (IsNotInView =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[it]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it])
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[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 op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[it])
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[it]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it])
forall a b. (a -> b) -> a -> b
$ TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
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))
  [op]
is SingT it
ins

lamRecImpl
  :: forall it ot ts op .
    ( WellTyped it, WellTyped ot
    , SingI ts
    , IsInstrOp op
    )
  => TcInstrBase op
  -> LamTC it ot ts op
lamRecImpl :: forall (it :: T) (ot :: T) (ts :: [T]) op.
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
TcInstrBase op -> LamTC it ot ts op
lamRecImpl TcInstrBase op
tcOp [op]
is SingT it
ins SingT ot
ons = (Anns '[VarAnn, Notes it, Notes ot]
 -> RemFail Instr '[it, 'TLambda it ot] '[ot]
 -> Instr ts ('TLambda it ot : ts))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op '[it, 'TLambda it ot])
-> LamTC it ot ts op
forall (it :: T) (ot :: T) (ts :: [T]) op (inp :: [T]).
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
(Anns '[VarAnn, Notes it, Notes ot]
 -> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> LamTC it ot ts op
lamCommon Anns '[VarAnn, Notes it, Notes ot]
-> RemFail Instr '[it, 'TLambda it ot] '[ot]
-> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (inp :: [T]).
(SingI i, SingI o) =>
Anns '[VarAnn, Notes i, Notes o]
-> RemFail Instr '[i, 'TLambda i o] '[o]
-> Instr inp ('TLambda i o : inp)
AnnLAMBDA_REC
  ((IsNotInView =>
 ReaderT
   TypeCheckInstrEnv
   (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it, 'TLambda it ot])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op '[it, 'TLambda it ot]))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> (IsNotInView =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it, 'TLambda it ot])
forall a b. (a -> b) -> a -> b
$
      (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it, 'TLambda it ot])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it, 'TLambda it ot])
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 op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[it, 'TLambda it ot])
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it, 'TLambda it ot])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[it, 'TLambda it ot])
forall a b. (a -> b) -> a -> b
$
        TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
is ((SingT it
ins, Dict (WellTyped it)
forall (a :: Constraint). a => Dict a
Dict) (SingT it, Dict (WellTyped it))
-> HST '[ 'TLambda it ot] -> HST '[it, 'TLambda it ot]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (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
ons, Dict (WellTyped ('TLambda it ot))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TLambda it ot), Dict (WellTyped ('TLambda it ot)))
-> HST '[] -> HST '[ 'TLambda it ot]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil))
  [op]
is SingT it
ins SingT ot
ons

lamCommon
  :: forall it ot ts op inp .
    ( WellTyped it, WellTyped ot
    , SingI ts
    , IsInstrOp op
    )
  => (Anns '[VarAnn, Notes it, Notes ot] -> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts))
  -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
  -> LamTC it ot ts op
lamCommon :: forall (it :: T) (ot :: T) (ts :: [T]) op (inp :: [T]).
(WellTyped it, WellTyped ot, SingI ts, IsInstrOp op) =>
(Anns '[VarAnn, Notes it, Notes ot]
 -> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> LamTC it ot ts op
lamCommon Anns '[VarAnn, Notes it, Notes ot]
-> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts)
tyCon TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
tcInstr [op]
is SingT it
ins SingT ot
ons [TypeCheckedOp op] -> TypeCheckedInstr op
cons Anns '[VarAnn, Notes it, Notes ot]
anns InstrAbstract op
instr HST ts
i =
  InstrAbstract op
-> TypeCheckInstr op ()
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
forall op a (inp :: [T]).
IsInstrOp op =>
InstrAbstract op
-> TypeCheckInstr op a
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
guarding_ InstrAbstract op
instr
    (Maybe (InstrAbstract op)
-> (InstrAbstract op
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         ())
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall (f :: * -> *) a.
Applicative f =>
Maybe a -> (a -> f ()) -> f ()
whenJust (First (InstrAbstract op) -> Maybe (InstrAbstract op)
forall a. First a -> Maybe a
getFirst (First (InstrAbstract op) -> Maybe (InstrAbstract op))
-> First (InstrAbstract op) -> Maybe (InstrAbstract op)
forall a b. (a -> b) -> a -> b
$ (Element [op] -> First (InstrAbstract op))
-> [op] -> First (InstrAbstract op)
forall t m. (Container t, Monoid m) => (Element t -> m) -> t -> m
foldMap op -> First (InstrAbstract op)
Element [op] -> First (InstrAbstract op)
hasSelf [op]
is) ((InstrAbstract op
  -> ReaderT
       TypeCheckInstrEnv
       (ReaderT
          (TypeCheckEnv op)
          (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
       ())
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      ())
-> (InstrAbstract op
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         ())
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall a b. (a -> b) -> a -> b
$ \InstrAbstract op
selfInstr -> do
      let err :: TcTypeError
err = InstrAbstract () -> Text -> TcTypeError
InvalidInstruction (InstrAbstract op -> InstrAbstract ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void InstrAbstract op
selfInstr) Text
"SELF instruction cannot be used in a LAMBDA"
      InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     ()
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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
LambdaCodeCtx) TcTypeError
err) (TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
forall op (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp'))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp')
preserving TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
tcInstr [TypeCheckedOp op] -> TypeCheckedInstr op
cons ((SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr ts))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts))
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr ts))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op ts)
forall a b. (a -> b) -> a -> b
$ \(HST inp
_ :/ SomeTcInstrOut inp
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
      (SomeTcInstrOut ts -> SomeTcInstr ts)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut ts)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ts)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HST ts
i HST ts -> SomeTcInstrOut ts -> SomeTcInstr ts
forall (inp :: [T]).
HST inp -> SomeTcInstrOut inp -> SomeTcInstr inp
:/) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
   (SomeTcInstrOut ts)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ts))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut ts)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ts)
forall a b. (a -> b) -> a -> b
$ case SomeTcInstrOut inp
lamI of
        Instr inp 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
                SomeTcInstrOut ts
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Anns '[VarAnn, Notes it, Notes ot]
-> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts)
tyCon Anns '[VarAnn, Notes it, Notes ot]
anns (Instr inp out -> RemFail Instr inp out
forall {k} (instr :: k -> k -> *) (i :: k) (o :: k).
instr i o -> RemFail instr i o
RfNormal Instr inp out
lam) Instr ts ('TLambda it ot : ts)
-> HST ('TLambda it ot : ts) -> SomeTcInstrOut ts
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
ons)
            Left TcTypeError
m -> InstrAbstract op
-> SomeHST
-> Maybe TypeContext
-> TcTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut ts)
forall (m :: * -> *) op a.
(MonadReader TypeCheckInstrEnv m, MonadError (TcError' op) m) =>
InstrAbstract op
-> SomeHST -> Maybe TypeContext -> TcTypeError -> m a
typeCheckInstrErr' InstrAbstract op
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
LambdaCodeCtx) TcTypeError
m
        AnyOutInstr forall (out :: [T]). Instr inp out
lam ->
          SomeTcInstrOut ts
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Anns '[VarAnn, Notes it, Notes ot]
-> RemFail Instr inp '[ot] -> Instr ts ('TLambda it ot : ts)
tyCon Anns '[VarAnn, Notes it, Notes ot]
anns ((forall (out :: [T]). Instr inp out) -> RemFail Instr inp '[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 inp out
lam) Instr ts ('TLambda it ot : ts)
-> HST ('TLambda it ot : ts) -> SomeTcInstrOut ts
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
ons)
  where
    hasSelf :: op -> First (U.InstrAbstract op)
    hasSelf :: op -> First (InstrAbstract op)
hasSelf = (First (InstrAbstract op)
 -> First (InstrAbstract op) -> First (InstrAbstract op))
-> GenericQ (First (InstrAbstract op))
-> GenericQ (First (InstrAbstract op))
forall r. (r -> r -> r) -> GenericQ r -> GenericQ r
everything First (InstrAbstract op)
-> First (InstrAbstract op) -> First (InstrAbstract op)
forall a. Semigroup a => a -> a -> a
(<>)
      (First (InstrAbstract op)
-> (InstrAbstract op -> First (InstrAbstract op))
-> a
-> First (InstrAbstract op)
forall a b r. (Typeable a, Typeable b) => r -> (b -> r) -> a -> r
mkQ (Maybe (InstrAbstract op) -> First (InstrAbstract op)
forall a. Maybe a -> First a
First Maybe (InstrAbstract op)
forall a. Maybe a
Nothing)
       (\case
           selfInstr :: InstrAbstract op
selfInstr@(U.SELF{} :: U.InstrAbstract op) -> Maybe (InstrAbstract op) -> First (InstrAbstract op)
forall a. Maybe a -> First a
First (Maybe (InstrAbstract op) -> First (InstrAbstract op))
-> Maybe (InstrAbstract op) -> First (InstrAbstract op)
forall a b. (a -> b) -> a -> b
$ InstrAbstract op -> Maybe (InstrAbstract op)
forall a. a -> Maybe a
Just InstrAbstract op
selfInstr
           InstrAbstract op
_ -> Maybe (InstrAbstract op) -> First (InstrAbstract op)
forall a. Maybe a -> First a
First Maybe (InstrAbstract op)
forall a. Maybe a
Nothing
       )
      )

typeCheckExpandedOp :: TcInstrBase U.ExpandedOp
typeCheckExpandedOp :: TcInstrBase ExpandedOp
typeCheckExpandedOp = \case
  U.WithSrcEx ErrorSrcPos
_ op :: ExpandedOp
op@U.WithSrcEx{} -> ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
TcInstrBase ExpandedOp
typeCheckExpandedOp ExpandedOp
op
  U.WithSrcEx ErrorSrcPos
loc (U.PrimEx ExpandedInstr
op)  -> ErrorSrcPos -> TcInstr ExpandedOp ExpandedInstr
typeCheckPrimWithLoc ErrorSrcPos
loc ExpandedInstr
op
  U.WithSrcEx ErrorSrcPos
loc (U.SeqEx [ExpandedOp]
sq)   -> ErrorSrcPos -> TcInstr ExpandedOp [ExpandedOp]
typeCheckSeqWithLoc ErrorSrcPos
loc [ExpandedOp]
sq
  U.PrimEx ExpandedInstr
op                    -> ExpandedInstr
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
TcInstr ExpandedOp ExpandedInstr
typeCheckPrim ExpandedInstr
op
  U.SeqEx [ExpandedOp]
sq                     -> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
TcInstr ExpandedOp [ExpandedOp]
typeCheckSeq [ExpandedOp]
sq
  where
    -- If we know source location from the untyped instruction, keep it in the typed one.
    typeCheckPrimWithLoc :: ErrorSrcPos -> TcInstr U.ExpandedOp U.ExpandedInstr
    typeCheckPrimWithLoc :: ErrorSrcPos -> TcInstr ExpandedOp ExpandedInstr
typeCheckPrimWithLoc ErrorSrcPos
loc ExpandedInstr
op HST inp
hst = (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter TypeCheckInstrEnv TypeCheckInstrEnv ErrorSrcPos ErrorSrcPos
-> ErrorSrcPos -> TypeCheckInstrEnv -> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter TypeCheckInstrEnv TypeCheckInstrEnv ErrorSrcPos ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos ErrorSrcPos
loc)
      (ErrorSrcPos
-> TypeCheckedSeq ExpandedOp inp -> TypeCheckedSeq ExpandedOp inp
forall op (inp :: [T]).
ErrorSrcPos -> TypeCheckedSeq op inp -> TypeCheckedSeq op inp
wrapWithLoc ErrorSrcPos
loc (TypeCheckedSeq ExpandedOp inp -> TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ExpandedInstr
-> HST inp
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv ExpandedOp, TypeCheckOptions]
     Identity
     (TypeCheckedSeq ExpandedOp inp)
TcInstr ExpandedOp ExpandedInstr
typeCheckPrim ExpandedInstr
op HST inp
hst)

    typeCheckPrim :: TcInstr U.ExpandedOp U.ExpandedInstr
    typeCheckPrim :: TcInstr ExpandedOp ExpandedInstr
typeCheckPrim = TcInstrBase ExpandedOp -> TcInstr ExpandedOp ExpandedInstr
forall op.
IsInstrOp op =>
TcInstrBase op -> TcInstr op (InstrAbstract op)
typeCheckInstr TcInstrBase ExpandedOp
typeCheckExpandedOp

    typeCheckSeqWithLoc :: ErrorSrcPos -> TcInstr U.ExpandedOp [U.ExpandedOp]
    typeCheckSeqWithLoc :: ErrorSrcPos -> TcInstr ExpandedOp [ExpandedOp]
typeCheckSeqWithLoc ErrorSrcPos
loc [ExpandedOp]
op = (TypeCheckedSeq ExpandedOp inp -> TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ErrorSrcPos
-> TypeCheckedSeq ExpandedOp inp -> TypeCheckedSeq ExpandedOp inp
forall op (inp :: [T]).
ErrorSrcPos -> TypeCheckedSeq op inp -> TypeCheckedSeq op inp
wrapWithLoc ErrorSrcPos
loc) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq ExpandedOp inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ExpandedOp inp))
-> (HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq ExpandedOp inp))
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter TypeCheckInstrEnv TypeCheckInstrEnv ErrorSrcPos ErrorSrcPos
-> ErrorSrcPos -> TypeCheckInstrEnv -> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter TypeCheckInstrEnv TypeCheckInstrEnv ErrorSrcPos ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos ErrorSrcPos
loc) (ReaderT
   TypeCheckInstrEnv
   (ReaderT
      (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq ExpandedOp inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq ExpandedOp inp))
-> (HST inp
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
         (TypeCheckedSeq ExpandedOp inp))
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ExpandedOp]
-> HST inp
-> MultiReaderT
     '[TypeCheckInstrEnv, TypeCheckEnv ExpandedOp, TypeCheckOptions]
     Identity
     (TypeCheckedSeq ExpandedOp inp)
TcInstr ExpandedOp [ExpandedOp]
typeCheckSeq [ExpandedOp]
op

    typeCheckSeq :: TcInstr U.ExpandedOp [U.ExpandedOp]
    typeCheckSeq :: TcInstr ExpandedOp [ExpandedOp]
typeCheckSeq [ExpandedOp]
sq HST inp
hst = TcInstrBase ExpandedOp -> TcInstr ExpandedOp [ExpandedOp]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
typeCheckImpl TcInstrBase ExpandedOp
typeCheckExpandedOp [ExpandedOp]
sq HST inp
hst
                      ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
  (TypeCheckedSeq ExpandedOp inp)
-> (TypeCheckedSeq ExpandedOp inp -> TypeCheckedSeq ExpandedOp inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq ExpandedOp inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (SomeTcInstr inp -> SomeTcInstr inp)
-> TypeCheckedSeq ExpandedOp inp -> TypeCheckedSeq ExpandedOp inp
forall (inp :: [T]) (inp' :: [T]) op.
(SomeTcInstr inp -> SomeTcInstr inp')
-> TypeCheckedSeq op inp -> TypeCheckedSeq op inp'
mapSeq ((forall (out :: [T]). Instr inp out -> Instr inp out)
-> SomeTcInstr inp -> SomeTcInstr inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out -> Instr inp out)
-> SomeTcInstr inp -> SomeTcInstr inp
mapSomeInstr forall (out :: [T]). Instr inp out -> Instr inp out
forall (inp :: [T]) (out :: [T]). Instr inp out -> Instr inp out
Nested)

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

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

typeCheckDipBody
  :: (SingI inp, IsInstrOp op)
  => TcInstrBase op
  -> ([TypeCheckedOp op] -> TypeCheckedInstr op)
  -> U.InstrAbstract op
  -> [op]
  -> HST inp
  -> (TcError' op -> [IllTypedInstr op] -> r)
  -> (forall out. SingI out => Instr inp out -> HST out -> r)
  -> TypeCheckInstrNoExcept op r
typeCheckDipBody :: forall (inp :: [T]) op r.
(SingI inp, IsInstrOp op) =>
TcInstrBase op
-> ([TypeCheckedOp op] -> TypeCheckedInstr op)
-> InstrAbstract op
-> [op]
-> HST inp
-> (TcError' op -> [IllTypedInstr op] -> r)
-> (forall (out :: [T]).
    SingI out =>
    Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept op r
typeCheckDipBody TcInstrBase op
tcOp [TypeCheckedOp op] -> TypeCheckedInstr op
cons InstrAbstract op
mainInstr [op]
instructions HST inp
inputHST TcError' op -> [IllTypedInstr op] -> r
onErr forall (out :: [T]). SingI out => Instr inp out -> HST out -> r
onOk = do
  TypeCheckedSeq op inp
listRes <- TcInstrBase op -> TcInstr op [op]
forall op. IsInstrOp op => TcInstrBase op -> TcInstr op [op]
tcList TcInstrBase op
tcOp [op]
instructions HST inp
inputHST
  ErrorSrcPos
pos <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (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 op inp
listRes TypeCheckedSeq op inp -> (TypeCheckedSeq op inp -> r) -> r
forall a b. a -> (a -> b) -> b
& ([TypeCheckedOp op] -> TcError' op -> r)
-> (SomeTcInstr inp -> r) -> TypeCheckedSeq op inp -> r
forall op a (inp :: [T]).
([TypeCheckedOp op] -> TcError' op -> a)
-> (SomeTcInstr inp -> a) -> TypeCheckedSeq op inp -> a
tcsEither
    (\[TypeCheckedOp op]
tcOps TcError' op
err -> TcError' op -> [IllTypedInstr op] -> r
onErr TcError' op
err [TypeCheckedInstr op -> IllTypedInstr op
forall op. TypeCheckedInstr op -> IllTypedInstr op
SemiTypedInstr (TypeCheckedInstr op -> IllTypedInstr op)
-> TypeCheckedInstr op -> IllTypedInstr op
forall a b. (a -> b) -> a -> b
$ [TypeCheckedOp op] -> TypeCheckedInstr op
cons [TypeCheckedOp op]
tcOps])
    (\someInstr :: SomeTcInstr inp
someInstr@(HST inp
_ :/ SomeTcInstrOut inp
iAndOut) -> case SomeTcInstrOut 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' op
err = InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
forall op.
InstrAbstract op
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TcTypeError
-> TcError' op
TcFailedOnInstr InstrAbstract op
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' op -> [IllTypedInstr op] -> r
onErr TcError' op
err [TypeCheckedInstr op -> IllTypedInstr op
forall op. TypeCheckedInstr op -> IllTypedInstr op
SemiTypedInstr (TypeCheckedInstr op -> IllTypedInstr op)
-> TypeCheckedInstr op -> IllTypedInstr op
forall a b. (a -> b) -> a -> b
$ [TypeCheckedOp op] -> TypeCheckedInstr op
cons [SomeTcInstr inp -> TypeCheckedOp op
forall (inp :: [T]) op. SomeTcInstr inp -> TypeCheckedOp op
someInstrToOp SomeTcInstr 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)