-- 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.Coerce (coerce)
import Data.Constraint ((\\))
import Data.Default (Default(def))
import Data.Generics (everything, mkQ)
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.Internal.ViewsSet as VS
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.Michelson.Typed.Instr.Constraints

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' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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.
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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.
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
TcInstrBase ExpandedOp
typeCheckExpandedOp

typeCheckContract'
  :: TcInstrBase op
  -> U.Contract' op
  -> TypeCheckResult op SomeContract
typeCheckContract' :: forall 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 a b c. (a -> b) -> Either a c -> Either b c
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
-> MultiReaderT (TCEnvs op) (Except (TcError' 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) (MultiReaderT (TCEnvs op) (Except (TcError' op)) SomeContract
 -> TypeCheckResult op SomeContract)
-> MultiReaderT (TCEnvs op) (Except (TcError' op)) SomeContract
-> TypeCheckResult op SomeContract
forall a b. (a -> b) -> a -> b
$ TcInstrBase op
-> Contract' op
-> MultiReaderT (TCEnvs op) (Except (TcError' op)) SomeContract
forall op.
TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
doTypeCheckContract' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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) =>
TcInstrBase op
-> Contract' op -> TypeCheckResult op (Contract cp st)
typeVerifyContract' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
TcInstrBase ExpandedOp
typeCheckExpandedOp

typeVerifyContract'
  :: forall cp st op.
     (SingI cp, SingI st)
  => TcInstrBase op -> U.Contract' op -> TypeCheckResult op (Contract cp st)
typeVerifyContract' :: forall (cp :: T) (st :: T) op.
(SingI cp, SingI st) =>
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.
TcInstrBase op -> Contract' op -> TypeCheckResult op SomeContract
typeCheckContract' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 -> TypeCheckResult op (Contract cp st)
forall a. a -> ReaderT TypeCheckOptions (Except (TcError' op)) a
forall (m :: * -> *) a. Monad m => a -> m a
return Contract cp st
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 a.
TcError' op -> ReaderT TypeCheckOptions (Except (TcError' op)) a
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 -> TypeCheck op a
forall a.
TcError' op -> MultiReaderT (TCEnvs op) (Except (TcError' op)) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op -> TypeCheck op a) -> TcError' op -> TypeCheck op 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, FromDoc 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 a.
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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     a
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'
  :: forall op. TcInstrBase op
  -> U.Contract' op
  -> TypeCheck op SomeContract
doTypeCheckContract' :: forall 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 ViewsSet op
uViews) = do
  Ty
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheck op SomeContract)
-> TypeCheck op SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mParam ((forall (t :: T). SingI t => Notes t -> TypeCheck op SomeContract)
 -> TypeCheck op SomeContract)
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheck op SomeContract)
-> TypeCheck op SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
paramNote :: Notes param) ->
    Ty
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheck op SomeContract)
-> TypeCheck op SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mStorage ((forall (t :: T). SingI t => Notes t -> TypeCheck op SomeContract)
 -> TypeCheck op SomeContract)
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheck op SomeContract)
-> TypeCheck op 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.
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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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.
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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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
$
            (IsNotInView =>
 ReaderT
   TypeCheckInstrEnv
   (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
   (TypeCheckedSeq op '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  ReaderT
    TypeCheckInstrEnv
    (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
    (TypeCheckedSeq op '[ 'TPair t t]))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[ 'TPair t t]))
-> (IsNotInView =>
    ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
forall a.
(TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     a
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 '[ 'TPair t t])
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
      (TypeCheckedSeq op '[ 'TPair t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     (TypeCheckedSeq op '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
            op
-> HST '[ 'TPair t t]
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[ 'TPair t t])
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])
[TypeCheckedOp op]
-> TcError' op -> TypeCheck op (SomeTcInstr '[ 'TPair t t])
forall 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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq op '[ 'TPair t t]
codeRes

          -- typecheck views
          ViewsSet' Instr t
cViews <- TcInstrBase op
-> Contract' (TypeCheckedOp op)
-> Notes t
-> ViewsSet op
-> TypeCheck op (ViewsSet' Instr t)
forall (st :: T) op.
WellTyped st =>
TcInstrBase op
-> Contract' (TypeCheckedOp op)
-> Notes st
-> ViewsSet op
-> TypeCheck op (ViewsSet st)
typeCheckViews' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 :: ViewsSet (TypeCheckedOp op)
U.contractViews = ViewsSet (TypeCheckedOp op)
forall a. Default a => a
def }
            Notes t
storageNote ViewsSet op
uViews

          let tcViews :: ViewsSet (TypeCheckedOp op)
tcViews = ViewsSetF (View' (TypeCheckedOp op)) -> ViewsSet (TypeCheckedOp op)
forall a b. Coercible a b => a -> b
coerce (ViewsSetF (View' (TypeCheckedOp op))
 -> ViewsSet (TypeCheckedOp op))
-> ViewsSetF (View' (TypeCheckedOp op))
-> ViewsSet (TypeCheckedOp op)
forall a b. (a -> b) -> a -> b
$ forall (st :: T) op. SomeView st -> View' (TypeCheckedOp op)
someViewToOp @_ @op (SomeView t -> View' (TypeCheckedOp op))
-> ViewsSetF (SomeView t) -> ViewsSetF (View' (TypeCheckedOp op))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @_ @(ViewsSetF (SomeView st)) ViewsSet' Instr t
cViews
          (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
-> ViewsSet (TypeCheckedOp op)
-> TcError' op
-> TypeCheck op SomeContract
forall a.
TypeCheckedOp op
-> ViewsSet (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) ViewsSet (TypeCheckedOp op)
tcViews) (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
            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 a. a -> Either (TcError' op) a
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{ 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
cViews :: ViewsSet' Instr t
cStoreNotes :: Notes t
cParamNotes :: ParamNotes t
cEntriesOrder :: EntriesOrder
cParamNotes :: ParamNotes t
cStoreNotes :: Notes t
cViews :: ViewsSet' Instr t
cEntriesOrder :: EntriesOrder
.. }
                  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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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{ 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
cViews :: ViewsSet' Instr t
cStoreNotes :: Notes t
cParamNotes :: ParamNotes t
cEntriesOrder :: EntriesOrder
cParamNotes :: ParamNotes t
cStoreNotes :: Notes t
cViews :: ViewsSet' Instr t
cEntriesOrder :: EntriesOrder
.. }

  where
    hasTypeError :: forall (t :: T) a. SingI t => Text -> BadTypeForScope -> TypeCheck op a
    hasTypeError :: forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck op a
hasTypeError Text
name BadTypeForScope
reason = TcError' op
-> MultiReaderT
     '[TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     a
forall a.
TcError' op
-> MultiReaderT
     '[TypeCheckEnv op, TypeCheckOptions]
     (ExceptT (TcError' op) Identity)
     a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op
 -> MultiReaderT
      '[TypeCheckEnv op, TypeCheckOptions]
      (ExceptT (TcError' op) Identity)
      a)
-> TcError' op
-> MultiReaderT
     '[TypeCheckEnv op, 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 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 :: Peano).
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 a.
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' (TCOpSeq op) -> TcError' op
forall op. TcError' op -> Contract' (TCOpSeq op) -> TcError' op
TcIncompletelyTyped TcError' op
err U.Contract
             { contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
             , contractStorage :: Ty
contractStorage = Ty
mStorage
             , contractCode :: TCOpSeq op
contractCode = [TypeCheckedOp op] -> TCOpSeq op
forall op. [TypeCheckedOp op] -> TCOpSeq op
TCOpSeq [TypeCheckedOp op]
ops
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             , contractViews :: ViewsSet (TCOpSeq op)
contractViews = ViewsSet (TCOpSeq op)
forall a. Default a => a
def
             }
        else TcError' op
err

    onFailedFullTypeCheck :: TypeCheckedOp op -> U.ViewsSet (TypeCheckedOp op) -> TcError' op -> TypeCheck op a
    onFailedFullTypeCheck :: forall a.
TypeCheckedOp op
-> ViewsSet (TypeCheckedOp op) -> TcError' op -> TypeCheck op a
onFailedFullTypeCheck TypeCheckedOp op
ops ViewsSet (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 :: Peano).
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 a.
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' (TCOpSeq op) -> TcError' op
forall op. TcError' op -> Contract' (TCOpSeq op) -> TcError' op
TcIncompletelyTyped TcError' op
err U.Contract
             { contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
             , contractStorage :: Ty
contractStorage = Ty
mStorage
             , contractCode :: TCOpSeq op
contractCode = [TypeCheckedOp op] -> TCOpSeq op
forall op. [TypeCheckedOp op] -> TCOpSeq op
TCOpSeq [TypeCheckedOp op
ops]
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             , contractViews :: ViewsSet (TCOpSeq op)
contractViews = [TypeCheckedOp op] -> TCOpSeq op
forall op. [TypeCheckedOp op] -> TCOpSeq op
TCOpSeq ([TypeCheckedOp op] -> TCOpSeq op)
-> (TypeCheckedOp op -> [TypeCheckedOp op])
-> TypeCheckedOp op
-> TCOpSeq op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OneItem [TypeCheckedOp op] -> [TypeCheckedOp op]
TypeCheckedOp op -> [TypeCheckedOp op]
forall x. One x => OneItem x -> x
one (TypeCheckedOp op -> TCOpSeq op)
-> ViewsSet (TypeCheckedOp op) -> ViewsSet (TCOpSeq op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ViewsSet (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) =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheckResult op (View arg st ret)
typeVerifyView' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
TcInstrBase ExpandedOp
typeCheckExpandedOp

typeVerifyView'
  :: forall arg ret st op.
     (SingI arg, SingI ret, WellTyped st)
  => 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) =>
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
-> MultiReaderT
     (TCEnvs op) (Except (TcError' op)) (SomeView' Instr st)
-> ReaderT
     TypeCheckOptions (Except (TcError' op)) (SomeView' Instr st)
forall op a.
TypeCheckMode op -> TypeCheck op a -> TypeCheckResult op a
runTypeCheck TypeCheckMode op
forall op. TypeCheckMode op
TypeCheckTest (MultiReaderT
   (TCEnvs op) (Except (TcError' op)) (SomeView' Instr st)
 -> ReaderT
      TypeCheckOptions (Except (TcError' op)) (SomeView' Instr st))
-> MultiReaderT
     (TCEnvs op) (Except (TcError' op)) (SomeView' Instr st)
-> ReaderT
     TypeCheckOptions (Except (TcError' op)) (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ TcInstrBase op
-> Notes st
-> View' op
-> MultiReaderT
     (TCEnvs op) (Except (TcError' op)) (SomeView' Instr st)
forall (st :: T) op.
WellTyped st =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
typeCheckView' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 arg st ret -> TypeCheckResult op (View arg st ret)
forall a. a -> ReaderT TypeCheckOptions (Except (TcError' op)) a
forall (m :: * -> *) a. Monad m => a -> m a
return View arg st ret
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 a.
TcError' op -> ReaderT TypeCheckOptions (Except (TcError' op)) a
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
  => TcInstrBase op
  -> Notes st
  -> U.View' op
  -> TypeCheck op (SomeView st)
typeCheckView' :: forall (st :: T) op.
WellTyped st =>
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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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
$
      op
-> HST '[ 'TPair t st]
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[ 'TPair t st])
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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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 a. a -> Either (TcError' op) a
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{ vCode :: ViewCode' Instr t st t
vCode = Instr '[ 'TPair t st] out
ViewCode' Instr t st t
instr, ViewName
Notes t
Notes t
vName :: ViewName
vArgument :: Notes t
vReturn :: Notes t
vName :: ViewName
vArgument :: Notes t
vReturn :: Notes t
.. }
      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 a.
a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
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{ 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
vName :: ViewName
vArgument :: Notes t
vReturn :: Notes t
vName :: ViewName
vArgument :: Notes t
vReturn :: Notes t
.. }

  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 :: Peano).
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 a.
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' (TCOpSeq op) -> TcError' op
forall op. TcError' op -> View' (TCOpSeq op) -> TcError' op
TcIncompletelyTypedView TcError' op
err View' op
v{ viewCode :: TCOpSeq op
U.viewCode = [TypeCheckedOp op] -> TCOpSeq op
forall op. [TypeCheckedOp op] -> TCOpSeq op
TCOpSeq [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 -> MultiReaderT (TCEnvs op) (Except (TcError' op)) a
forall a.
TcError' op -> MultiReaderT (TCEnvs op) (Except (TcError' op)) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TcError' op -> MultiReaderT (TCEnvs op) (Except (TcError' op)) a)
-> TcError' op -> MultiReaderT (TCEnvs op) (Except (TcError' op)) 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
  => TcInstrBase op
  -> U.Contract' (TypeCheckedOp op)
  -> Notes st
  -> U.ViewsSet op
  -> TypeCheck op (ViewsSet st)
typeCheckViews' :: forall (st :: T) op.
WellTyped st =>
TcInstrBase op
-> Contract' (TypeCheckedOp op)
-> Notes st
-> ViewsSet op
-> TypeCheck op (ViewsSet st)
typeCheckViews' TcInstrBase op
doTypeCheckOp Contract' (TypeCheckedOp op)
tcContract Notes st
storageNote ViewsSet op
cViews = ReaderT
  (TypeCheckEnv op)
  (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
  (ViewsSetF (SomeView st))
-> TypeCheck op (ViewsSet st)
forall a b. Coercible a b => a -> b
coerce (ReaderT
   (TypeCheckEnv op)
   (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
   (ViewsSetF (SomeView st))
 -> TypeCheck op (ViewsSet st))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (ViewsSetF (SomeView st))
-> TypeCheck op (ViewsSet st)
forall a b. (a -> b) -> a -> b
$
  ViewsSet op -> ViewsSetF (View' op)
forall a b. Coercible a b => a -> b
coerce ViewsSet op
cViews ViewsSetF (View' op)
-> (ViewsSetF (View' op)
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (ViewsSetF (SomeView st)))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (ViewsSetF (SomeView st))
forall a b. a -> (a -> b) -> b
& (ViewsSetF (SomeView st)
 -> ViewName
 -> View' op
 -> ReaderT
      (TypeCheckEnv op)
      (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
      (SomeView st))
-> ViewsSetF (View' op)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (ViewsSetF (SomeView st))
forall (m :: * -> *) b a.
Monad m =>
(ViewsSetF b -> ViewName -> a -> m b)
-> ViewsSetF a -> m (ViewsSetF b)
runningTotalMapM \ViewsSetF (SomeView st)
processedViews ViewName
name View' op
uView -> do
    TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
forall (st :: T) op.
WellTyped st =>
TcInstrBase op
-> Notes st -> View' op -> TypeCheck op (SomeView st)
typeCheckView' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
doTypeCheckOp Notes st
storageNote View' op
uView
    ReaderT
  (TypeCheckEnv op)
  (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
  (SomeView st)
-> (TcError' op
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         (SomeView st))
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeView st)
forall a.
ReaderT
  (TypeCheckEnv op)
  (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
  a
-> (TcError' op
    -> ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
         a)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` \case
      TcIncompletelyTypedView TcError' op
err View' (TCOpSeq op)
view' ->
        let tcViews :: ViewsSetF (View' (TCOpSeq op))
tcViews = (TypeCheckedOp op -> TCOpSeq op)
-> View' (TypeCheckedOp op) -> View' (TCOpSeq op)
forall a b. (a -> b) -> View' a -> View' b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([TypeCheckedOp op] -> TCOpSeq op
forall op. [TypeCheckedOp op] -> TCOpSeq op
TCOpSeq ([TypeCheckedOp op] -> TCOpSeq op)
-> (TypeCheckedOp op -> [TypeCheckedOp op])
-> TypeCheckedOp op
-> TCOpSeq op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OneItem [TypeCheckedOp op] -> [TypeCheckedOp op]
TypeCheckedOp op -> [TypeCheckedOp op]
forall x. One x => OneItem x -> x
one) (View' (TypeCheckedOp op) -> View' (TCOpSeq op))
-> (SomeView st -> View' (TypeCheckedOp op))
-> SomeView st
-> View' (TCOpSeq op)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeView st -> View' (TypeCheckedOp op)
forall (st :: T) op. SomeView st -> View' (TypeCheckedOp op)
someViewToOp (SomeView st -> View' (TCOpSeq op))
-> ViewsSetF (SomeView st) -> ViewsSetF (View' (TCOpSeq op))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ViewsSetF (SomeView st)
processedViews
        in ViewsSet (TCOpSeq op) -> TcError' op -> TypeCheck op (SomeView st)
forall a. ViewsSet (TCOpSeq op) -> TcError' op -> TypeCheck op a
onFailedViewsTypeCheck (ViewsSetF (View' (TCOpSeq op)) -> ViewsSet (TCOpSeq op)
forall a b. Coercible a b => a -> b
coerce (ViewsSetF (View' (TCOpSeq op)) -> ViewsSet (TCOpSeq op))
-> ViewsSetF (View' (TCOpSeq op)) -> ViewsSet (TCOpSeq op)
forall a b. (a -> b) -> a -> b
$ ViewName
-> View' (TCOpSeq op)
-> ViewsSetF (View' (TCOpSeq op))
-> ViewsSetF (View' (TCOpSeq op))
forall a. ViewName -> a -> ViewsSetF a -> ViewsSetF a
unsafeInsert ViewName
name View' (TCOpSeq op)
view' ViewsSetF (View' (TCOpSeq op))
tcViews) TcError' op
err
      TcError' op
err -> TcError' op
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     (SomeView st)
forall a.
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
err
  where
    -- NB: since we only walk one map and build another one using the same keys,
    -- this is actually safe, but be mindful of this when changing this code.
    unsafeInsert :: ViewName -> a -> ViewsSetF a -> ViewsSetF a
    unsafeInsert :: forall a. ViewName -> a -> ViewsSetF a -> ViewsSetF a
unsafeInsert = Either ViewsSetError (ViewsSetF a) -> ViewsSetF a
forall a b. (HasCallStack, Buildable a) => Either a b -> b
unsafe (Either ViewsSetError (ViewsSetF a) -> ViewsSetF a)
-> (ViewName
    -> a -> ViewsSetF a -> Either ViewsSetError (ViewsSetF a))
-> ViewName
-> a
-> ViewsSetF a
-> ViewsSetF a
forall a b c. SuperComposition a b c => a -> b -> c
... (a -> ViewName)
-> a -> ViewsSetF a -> Either ViewsSetError (ViewsSetF a)
forall a.
(a -> ViewName)
-> a -> ViewsSetF a -> Either ViewsSetError (ViewsSetF a)
VS.addViewToSet ((a -> ViewName)
 -> a -> ViewsSetF a -> Either ViewsSetError (ViewsSetF a))
-> (ViewName -> a -> ViewName)
-> ViewName
-> a
-> ViewsSetF a
-> Either ViewsSetError (ViewsSetF a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ViewName -> a -> ViewName
forall a b. a -> b -> a
const

    onFailedViewsTypeCheck :: U.ViewsSet (TCOpSeq op) -> TcError' op -> TypeCheck op a
    onFailedViewsTypeCheck :: forall a. ViewsSet (TCOpSeq op) -> TcError' op -> TypeCheck op a
onFailedViewsTypeCheck ViewsSet (TCOpSeq op)
processedViews TcError' op
err = do
      Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     Bool
forall (m :: * -> *) r a (n :: Peano).
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 a.
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' (TCOpSeq op) -> TcError' op
forall op. TcError' op -> Contract' (TCOpSeq op) -> TcError' op
TcIncompletelyTyped TcError' op
err ([TypeCheckedOp op] -> TCOpSeq op
forall op. [TypeCheckedOp op] -> TCOpSeq op
TCOpSeq ([TypeCheckedOp op] -> TCOpSeq op)
-> (TypeCheckedOp op -> [TypeCheckedOp op])
-> TypeCheckedOp op
-> TCOpSeq op
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OneItem [TypeCheckedOp op] -> [TypeCheckedOp op]
TypeCheckedOp op -> [TypeCheckedOp op]
forall x. One x => OneItem x -> x
one (TypeCheckedOp op -> TCOpSeq op)
-> Contract' (TypeCheckedOp op) -> Contract' (TCOpSeq op)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Contract' (TypeCheckedOp op)
tcContract)
             { contractViews :: ViewsSet (TCOpSeq op)
U.contractViews = ViewsSet (TCOpSeq op)
processedViews
             }
        else TcError' op
err

    runningTotalMapM :: Monad m => (ViewsSetF b -> ViewName -> a -> m b) -> ViewsSetF a -> m (ViewsSetF b)
    runningTotalMapM :: forall (m :: * -> *) b a.
Monad m =>
(ViewsSetF b -> ViewName -> a -> m b)
-> ViewsSetF a -> m (ViewsSetF b)
runningTotalMapM ViewsSetF b -> ViewName -> a -> m b
f ViewsSetF a
views = ViewsSetF a -> [(Key (ViewsSetF a), Val (ViewsSetF a))]
forall t. ToPairs t => t -> [(Key t, Val t)]
toPairs ViewsSetF a
views [(ViewName, a)]
-> ([(ViewName, a)] -> m (ViewsSetF b)) -> m (ViewsSetF b)
forall a b. a -> (a -> b) -> b
& ((ViewsSetF b -> (ViewName, a) -> m (ViewsSetF b))
 -> ViewsSetF b -> [(ViewName, a)] -> m (ViewsSetF b))
-> ViewsSetF b
-> (ViewsSetF b -> (ViewName, a) -> m (ViewsSetF b))
-> [(ViewName, a)]
-> m (ViewsSetF b)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (ViewsSetF b -> (ViewName, a) -> m (ViewsSetF b))
-> ViewsSetF b -> [(ViewName, a)] -> m (ViewsSetF b)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM ViewsSetF b
forall a. Default a => a
def \ViewsSetF b
acc (ViewName
k, a
el) -> do
      b
newEl <- ViewsSetF b -> ViewName -> a -> m b
f ViewsSetF b
acc ViewName
k a
el
      pure $ ViewName -> b -> ViewsSetF b -> ViewsSetF b
forall a. ViewName -> a -> ViewsSetF a -> ViewsSetF a
unsafeInsert ViewName
k b
newEl ViewsSetF b
acc

typeCheckViews
  :: WellTyped st
  => U.Contract' (TypeCheckedOp U.ExpandedOp)
  -> Notes st
  -> U.ViewsSet U.ExpandedOp
  -> TypeCheck U.ExpandedOp (ViewsSet st)
typeCheckViews :: forall (st :: T).
WellTyped st =>
Contract' (TypeCheckedOp ExpandedOp)
-> Notes st
-> ViewsSet ExpandedOp
-> TypeCheck ExpandedOp (ViewsSet st)
typeCheckViews = (Contract' (TypeCheckedOp ExpandedOp)
 -> Notes st
 -> ViewsSet ExpandedOp
 -> ReaderT
      (TypeCheckEnv ExpandedOp)
      (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
      (ViewsSet st))
-> Contract' (TypeCheckedOp ExpandedOp)
-> Notes st
-> ViewsSet ExpandedOp
-> TypeCheck ExpandedOp (ViewsSet st)
forall a b. Coercible a b => a -> b
coerce ((Contract' (TypeCheckedOp ExpandedOp)
  -> Notes st
  -> ViewsSet ExpandedOp
  -> ReaderT
       (TypeCheckEnv ExpandedOp)
       (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
       (ViewsSet st))
 -> Contract' (TypeCheckedOp ExpandedOp)
 -> Notes st
 -> ViewsSet ExpandedOp
 -> TypeCheck ExpandedOp (ViewsSet st))
-> (Contract' (TypeCheckedOp ExpandedOp)
    -> Notes st
    -> ViewsSet ExpandedOp
    -> ReaderT
         (TypeCheckEnv ExpandedOp)
         (ReaderT TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity))
         (ViewsSet st))
-> Contract' (TypeCheckedOp ExpandedOp)
-> Notes st
-> ViewsSet ExpandedOp
-> TypeCheck ExpandedOp (ViewsSet st)
forall a b. (a -> b) -> a -> b
$ TcInstrBase ExpandedOp
-> Contract' (TypeCheckedOp ExpandedOp)
-> Notes st
-> ViewsSet ExpandedOp
-> TypeCheck ExpandedOp (ViewsSet st)
forall (st :: T) op.
WellTyped st =>
TcInstrBase op
-> Contract' (TypeCheckedOp op)
-> Notes st
-> ViewsSet op
-> TypeCheck op (ViewsSet st)
typeCheckViews' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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)
-> MultiReaderT
     (MultiReaderIso
        (ReaderT
           (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity)))
     (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)
 -> MultiReaderT
      (MultiReaderIso
         (ReaderT
            (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity)))
      (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 ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
     (ExceptT (TcError' ExpandedOp) Identity)
     (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) (MultiReaderT
   '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
   (ExceptT (TcError' ExpandedOp) Identity)
   (Value t)
 -> TypeCheckResult ExpandedOp (Value t))
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
     (ExceptT (TcError' ExpandedOp) Identity)
     (Value t)
-> TypeCheckResult ExpandedOp (Value t)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (MultiReaderT
        '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
        (ExceptT (TcError' ExpandedOp) Identity))
     (Value t)
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, 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
   (MultiReaderT
      '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
      (ExceptT (TcError' ExpandedOp) Identity))
   (Value t)
 -> MultiReaderT
      '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
      (ExceptT (TcError' ExpandedOp) Identity)
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (MultiReaderT
        '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
        (ExceptT (TcError' ExpandedOp) Identity))
     (Value t)
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, 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 ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
     (ExceptT (TcError' ExpandedOp) Identity)
     (Value t)
-> ReaderT
     TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity) (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)) (MultiReaderT
   '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
   (ExceptT (TcError' ExpandedOp) Identity)
   (Value t)
 -> ReaderT
      TypeCheckOptions
      (ExceptT (TcError' ExpandedOp) Identity)
      (Value t))
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
     (ExceptT (TcError' ExpandedOp) Identity)
     (Value t)
-> ReaderT
     TypeCheckOptions (ExceptT (TcError' ExpandedOp) Identity) (Value t)
forall a b. (a -> b) -> a -> b
$
    TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (MultiReaderT
        '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
        (ExceptT (TcError' ExpandedOp) Identity))
     (Value t)
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, 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
   (MultiReaderT
      '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
      (ExceptT (TcError' ExpandedOp) Identity))
   (Value t)
 -> MultiReaderT
      '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
      (ExceptT (TcError' ExpandedOp) Identity)
      (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (MultiReaderT
        '[TypeCheckEnv ExpandedOp, TypeCheckOptions]
        (ExceptT (TcError' ExpandedOp) Identity))
     (Value t)
-> MultiReaderT
     '[TypeCheckEnv ExpandedOp, 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 ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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
-> MultiReaderT (TCEnvs op) (Except (TcError' op)) (Value t)
-> ReaderT TypeCheckOptions (Except (TcError' 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) (MultiReaderT (TCEnvs op) (Except (TcError' op)) (Value t)
 -> ReaderT TypeCheckOptions (Except (TcError' op)) (Value t))
-> MultiReaderT (TCEnvs op) (Except (TcError' op)) (Value t)
-> ReaderT TypeCheckOptions (Except (TcError' op)) (Value t)
forall a b. (a -> b) -> a -> b
$ TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (MultiReaderT (TCEnvs op) (Except (TcError' op)))
     (Value t)
-> MultiReaderT (TCEnvs op) (Except (TcError' op)) (Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (MultiReaderT (TCEnvs op) (Except (TcError' op)))
   (Value t)
 -> MultiReaderT (TCEnvs op) (Except (TcError' op)) (Value t))
-> ReaderT
     TypeCheckInstrEnv
     (MultiReaderT (TCEnvs op) (Except (TcError' op)))
     (Value t)
-> MultiReaderT (TCEnvs op) (Except (TcError' op)) (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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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' ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 (TCInstrEnvs op) Identity (TypeCheckedSeq op s))
-> (SomeTcInstr s
    -> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op s))
-> MultiReaderT
     (TCInstrEnvs op) (ExceptT (TcError' op) Identity) (SomeTcInstr s)
-> MultiReaderT (TCInstrEnvs op) 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
-> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op s)
forall a. a -> MultiReaderT (TCInstrEnvs op) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq op s
 -> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op s))
-> TypeCheckedSeq op s
-> MultiReaderT (TCInstrEnvs op) 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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     a
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 = TcInstrBase op
-> [op]
-> HST inp
-> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op inp)
TcInstrBase op -> TcInstr op [op]
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp xs
Instr (x : xs) xs
forall (a :: T) (out :: [T]). Instr (a : out) out
DROP Instr inp xs -> HST xs -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 :: Peano) (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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDropHelper inp
forall (n :: Peano) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp n, Drop n inp ~ out) =>
PeanoNatural n -> HST out -> TCDropHelper inp
TCDropHelper PeanoNatural 'Z
forall (n :: Peano). (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)
TypeCheckInstr op (TCDropHelper '[])
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 inp
forall (n :: Peano) (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 :: Peano) (m :: Peano).
(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 (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 inp (x : x : xs) -> HST (x : x : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 :: Peano) (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)
TypeCheckInstr op (TCDupNHelper '[])
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 inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCDupNHelper inp)
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural ('S 'Z) -> HST (x : inp) -> TCDupNHelper (x : xs)
forall (n :: Peano) (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 :: Peano). (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 m))
-> HST (x : x : xs) -> TCDupNHelper (x : xs)
forall (n :: Peano) (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 m))
forall (n :: Peano) (m :: Peano).
(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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 inp (x : x : xs)
Instr (x : x : xs) (x : x : xs)
forall (a :: T) (b :: T) (s :: [T]). Instr (a : b : s) (b : a : s)
SWAP Instr inp (x : x : xs) -> HST (x : x : xs) -> SomeTcInstrOut inp
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 :: Peano) (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)
TypeCheckInstr op (TCDigHelper '[])
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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDigHelper (x : xs)
forall (n :: Peano) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDIG n inp out s) =>
PeanoNatural n -> HST out -> TCDigHelper inp
TCDigHelper PeanoNatural 'Z
forall (n :: Peano). (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 :: Peano) (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 :: Peano) (m :: Peano).
(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 :: Peano) (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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDugHelper (x : xs)
forall (n :: Peano) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUG n inp out s) =>
PeanoNatural n -> HST out -> TCDugHelper inp
TCDugHelper PeanoNatural 'Z
forall (n :: Peano). (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 :: Peano) (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 :: Peano) (m :: Peano).
(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)
MultiReaderT
  (TCInstrEnvs op) (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 -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (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 a.
(TypeCheckEnv op -> TypeCheckEnv op)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (n :: Peano) 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 (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (TypeCheckMode op1) (f (TypeCheckMode op2))
-> p (TypeCheckEnv op1) (f (TypeCheckEnv 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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 inp ('TOption x : xs)
-> HST ('TOption x : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
elMt ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp Instr xs s' -> Instr (n : xs) s' -> Instr ('TOption n : xs) s'
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 [op1] -> [op1] -> InstrAbstract [] op1
forall op1. [op1] -> [op1] -> InstrAbstract [] op1
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 inp ('TPair x x : xs)
-> HST ('TPair x x : xs) -> SomeTcInstrOut inp
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 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
      SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp (n1 : n2 : xs)
-> HST (n1 : n2 : xs) -> SomeTcInstrOut inp
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 :: Peano) (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)
-> TypeCheckInstr op (TCPairNHelper (x : x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : xs)
 -> TypeCheckInstr op (TCPairNHelper (x : x : xs)))
-> TCPairNHelper (x : x : xs)
-> TypeCheckInstr op (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 :: Peano) (inp :: [T]).
(SingI (PairN n inp), ConstraintPairN n inp) =>
PeanoNatural n -> HST (PairN n inp) -> TCPairNHelper inp
TCPairNHelper PeanoNatural ('S ('S 'Z))
forall (n :: Peano). (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
  (TCInstrEnvs op)
  (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 a b.
ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  a
-> (a
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         b)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     b
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)
-> TypeCheckInstr op (TCPairNHelper (x : x : x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : x : xs)
 -> TypeCheckInstr op (TCPairNHelper (x : x : x : xs)))
-> TCPairNHelper (x : x : x : xs)
-> TypeCheckInstr op (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 :: Peano) (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 :: Peano) (m :: Peano).
(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 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
  (TCInstrEnvs op)
  (ExceptT (TcError' op) Identity)
  (TCPairNHelper inp)
forall a. TypeCheckInstr op a
notEnoughItemsOnStack'

  (U.UNPAIRN Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 :: Peano) (pair :: T) (s :: [T]).
ConstraintUnpairN n pair =>
PeanoNatural n -> Instr (pair : s) (UnpairN n pair ++ s)
UNPAIRN PeanoNatural n
s Instr inp (UnpairN n ('TPair a b) ++ xs)
-> HST (UnpairN n ('TPair a b) ++ xs) -> SomeTcInstrOut inp
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 (x : xs)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUnpairNHelper (x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper (x : xs)
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCUnpairNHelper (x : xs)))
-> TCUnpairNHelper (x : xs)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUnpairNHelper (x : 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 :: Peano) (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 :: Peano). (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
  (TCInstrEnvs op)
  (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 a b.
ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  a
-> (a
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         b)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     b
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 n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (TCUnpairNHelper ('TPair n1 n2 : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 ('S m)))
-> HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
forall (n :: Peano) (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 :: Peano) (m :: Peano).
(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 ('S ('S m)) ('TPair a b) ++ xs)
-> HST (n1 : (UnpairN ('S ('S m)) ('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) ++ rest)
HST (UnpairN ('S ('S m)) ('TPair a b) ++ xs)
out
              HST (x : xs)
_ -> MultiReaderT
  (TCInstrEnvs op)
  (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 (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> MultiReaderT
      (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a)
-> TcTypeError
-> MultiReaderT (TCInstrEnvs op) (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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp (n1 : xs) -> HST (n1 : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp (n2 : xs) -> HST (n2 : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
bMt ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 inp ('TOr x t : xs)
-> HST ('TOr x t : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
aMt ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 inp ('TOr t x : xs)
-> HST ('TOr t x : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
lt ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
rt ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => 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' @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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp Instr (n1 : xs) s'
-> Instr (n2 : xs) s' -> Instr ('TOr n1 n2 : xs) s'
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 [op1] -> [op1] -> InstrAbstract [] op1
forall op1. [op1] -> [op1] -> InstrAbstract [] op1
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
elMt ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 (x : 'TList x : xs)
-> TypeCheckInstr op (SomeTcInstr (x : 'TList x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : 'TList x : xs)
 -> TypeCheckInstr op (SomeTcInstr (x : 'TList x : xs)))
-> SomeTcInstr (x : 'TList x : xs)
-> TypeCheckInstr op (SomeTcInstr (x : 'TList x : 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 : '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 inp ('TList x : xs)
-> HST ('TList x : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((SingT x
SingT ('TList x)
ln, Dict (WellTyped ('TList x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TList x), Dict (WellTyped ('TList x)))
-> HST xs -> HST ('TList 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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp Instr (n : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s'
Instr (n : 'TList n : xs) s'
-> Instr xs s' -> Instr ('TList n : xs) s'
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 [op1] -> [op1] -> InstrAbstract [] op1
forall op1. [op1] -> [op1] -> InstrAbstract [] op1
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (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)
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (Comparable t => SomeTcInstr inp)
-> TypeCheckInstr op (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]).
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 -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v)  ->
      Ty
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mk ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (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)
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (Comparable t => SomeTcInstr inp)
-> TypeCheckInstr op (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 (b :: T) (a :: T) (inp :: [T]).
(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 -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v)  ->
      Ty
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mk ((forall (t :: T).
  SingI t =>
  Notes t -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (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)
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (Comparable t => SomeTcInstr inp)
-> TypeCheckInstr op (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 (b :: T) (a :: T) (inp :: [T]).
(SingI b, Comparable a, ForbidBigMap 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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
SingT n
vns ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp (VarAnn -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. VarAnn -> f op -> InstrAbstract f 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) -> TypeCheckInstr op (HST ('TList v' : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TList v' : xs) -> TypeCheckInstr op (HST ('TList v' : xs)))
-> HST ('TList v' : xs) -> TypeCheckInstr op (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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
SingT n
vns ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp (VarAnn -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. VarAnn -> f op -> InstrAbstract f 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)
-> TypeCheckInstr op (HST ('TOption v' : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TOption v' : xs)
 -> TypeCheckInstr op (HST ('TOption v' : xs)))
-> HST ('TOption v' : xs)
-> TypeCheckInstr op (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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp (VarAnn -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. VarAnn -> f op -> InstrAbstract f 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)
-> TypeCheckInstr op (HST ('TMap n1 v' : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TMap n1 v' : xs)
 -> TypeCheckInstr op (HST ('TMap n1 v' : xs)))
-> HST ('TMap n1 v' : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
l ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 :: Peano) (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 inp (GetN ix x : xs)
-> HST (GetN ix x : xs) -> SomeTcInstrOut inp
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)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCGetNHelper (x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> MultiReaderT
     (TCInstrEnvs op)
     (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 :: Peano) (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 :: Peano). (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
HST xs
rest)
      go Word
1 ((STPair Sing n1
leftNotes Sing n2
_, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCGetNHelper (x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (GetN ('S 'Z) x : xs) -> TCGetNHelper (x : xs)
forall (n :: Peano) (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 :: Peano). (n ~ 'S 'Z) => PeanoNatural n
One (HST (GetN ('S 'Z) x : xs) -> TCGetNHelper (x : xs))
-> HST (GetN ('S 'Z) x : xs) -> TCGetNHelper (x : 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
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 :: Peano) (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 :: Peano) (m :: Peano).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ (PeanoNatural ix -> PeanoNatural ('S ix)
forall (n :: Peano) (m :: Peano).
(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
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCGetNHelper (x : xs))
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCGetNHelper (x : xs)))
-> TcTypeError
-> MultiReaderT
     (TCInstrEnvs op)
     (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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 :: Peano) (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 inp (UpdateN ix x x : xs)
-> HST (UpdateN ix x x : xs) -> SomeTcInstrOut inp
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 : rest)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : rest)
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCUpdateNHelper (val : pair : rest)))
-> TCUpdateNHelper (val : pair : rest)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z
-> HST (UpdateN 'Z val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
forall (n :: Peano) (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 :: Peano). (n ~ 'Z) => PeanoNatural n
Zero (HST (UpdateN 'Z val pair : rest)
 -> TCUpdateNHelper (val : pair : rest))
-> HST (UpdateN 'Z val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
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 rest -> HST (x : rest)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST rest
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 : pair : rest)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : rest)
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCUpdateNHelper (val : pair : rest)))
-> TCUpdateNHelper (val : pair : rest)
-> MultiReaderT
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (UpdateN ('S 'Z) val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
forall (n :: Peano) (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 :: Peano). (n ~ 'S 'Z) => PeanoNatural n
One (HST (UpdateN ('S 'Z) val pair : rest)
 -> TCUpdateNHelper (val : pair : rest))
-> HST (UpdateN ('S 'Z) val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
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 rest -> HST ('TPair val n2 : rest)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST rest
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 :: Peano) (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 :: Peano) (m :: Peano).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ (PeanoNatural ix -> PeanoNatural ('S ix)
forall (n :: Peano) (m :: Peano).
(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 x -> SingT ('TPair n1 x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
leftNotes Sing x
SingT x
updatedRightNotes, Dict (WellTyped ('TPair n1 x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair n1 x), Dict (WellTyped ('TPair n1 x)))
-> HST xs -> HST ('TPair n1 x : 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
     (TCInstrEnvs op)
     (ExceptT (TcError' op) Identity)
     (TCUpdateNHelper (val : pair : rest))
forall a. TcTypeError -> TypeCheckInstr op a
failWithErr' (TcTypeError
 -> MultiReaderT
      (TCInstrEnvs op)
      (ExceptT (TcError' op) Identity)
      (TCUpdateNHelper (val : pair : rest)))
-> TcTypeError
-> MultiReaderT
     (TCInstrEnvs op)
     (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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp Instr xs s' -> Instr xs s' -> Instr ('TBool : xs) s'
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 [op1] -> [op1] -> InstrAbstract [] op1
forall op1. [op1] -> [op1] -> InstrAbstract [] op1
forall (f :: * -> *) op. f op -> f op -> InstrAbstract f op
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp [op]
is HST xs
rs) [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. f op -> InstrAbstract f op
U.LOOP ((SomeTcInstr xs -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SomeTcInstr xs -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp xs -> HST xs -> SomeTcInstrOut inp
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp xs -> HST xs -> SomeTcInstrOut inp
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 inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp [op]
is HST (n1 : xs)
ait) [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. f op -> InstrAbstract f op
U.LOOP_LEFT ((SomeTcInstr (n1 : xs) -> TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SomeTcInstr (n1 : xs) -> TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp (n2 : xs) -> HST (n2 : xs) -> SomeTcInstrOut inp
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp (n2 : xs) -> HST (n2 : xs) -> SomeTcInstrOut inp
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 (f :: * -> *) op.
VarAnn -> Ty -> Ty -> f op -> InstrAbstract f 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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 (f :: * -> *) op.
VarAnn -> Ty -> Ty -> f op -> InstrAbstract f 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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
v ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
b ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 n1 n2 : xs)))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs)))
-> (WellTyped n2 =>
    TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs)))
-> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ SomeTcInstr (x : 'TLambda n1 n2 : xs)
-> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : 'TLambda n1 n2 : xs)
 -> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : xs)))
-> SomeTcInstr (x : 'TLambda n1 n2 : xs)
-> TypeCheckInstr op (SomeTcInstr (x : 'TLambda n1 n2 : 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 : '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 inp (n2 : xs) -> HST (n2 : xs) -> SomeTcInstrOut inp
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
lt ((SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n1 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
rt ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
b ((SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n2 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 (x : 'TLambda ('TPair n1 n2) n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TLambda ('TPair n1 n2) n2 : 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
:/ 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 inp ('TLambda n2 n2 : xs)
-> HST ('TLambda n2 n2 : xs) -> SomeTcInstrOut inp
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. f op -> InstrAbstract f 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 (x : xs) -> TypeCheckedSeq op (x : xs)
forall op (inp :: [T]). SomeTcInstr inp -> TypeCheckedSeq op inp
WellTypedSeq (SomeTcInstr (x : xs) -> TypeCheckedSeq op (x : xs))
-> SomeTcInstr (x : xs) -> TypeCheckedSeq op (x : xs)
forall a b. (a -> b) -> a -> b
$ HST inp
HST (x : xs)
inp HST (x : xs) -> SomeTcInstrOut (x : xs) -> SomeTcInstr (x : xs)
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 :: Peano) (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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TcInstrBase op
tcOp (Word -> [TypeCheckedOp op] -> TypeCheckedInstr op
forall (f :: * -> *) op. Word -> f op -> InstrAbstract f 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 :: Peano) (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 :: Peano). (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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT (TypeCheckEnv op) (ReaderT TypeCheckOptions Identity))
     a
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 :: Peano) (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 :: Peano) (m :: Peano).
(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 (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : xs)))
-> SomeTcInstr (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 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
:/ (forall (out :: [T]). Instr inp out) -> SomeTcInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeTcInstrOut inp
AnyOutInstr Instr inp out
Instr (x : xs) out
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 (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
$
        SomeTcInstr (x : xs) -> TypeCheckInstr op (SomeTcInstr (x : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : xs) -> TypeCheckInstr op (SomeTcInstr (x : xs)))
-> SomeTcInstr (x : xs) -> TypeCheckInstr op (SomeTcInstr (x : 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
:/ 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 inp (t : xs) -> HST (t : xs) -> 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
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp (x : xs) -> HST (x : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
-> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
 -> TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
-> TypeCheckInstr op (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 ('TBytes : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBytes : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBytes : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TBytes : xs)))
-> SomeTcInstr ('TBytes : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TBytes : 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
:/ 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 inp ('TOption t : xs)
-> HST ('TOption t : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : xs)))
-> SomeTcInstr (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 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 : 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 inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TOption 'TNat : xs)
-> HST ('TOption 'TNat : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing ('TOption 'TNat)
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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) ('TOption 'TMutez : xs)
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TNat : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TNat : xs)))
-> SomeTcInstr ('TNat : xs)
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBls12381Fr : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TBls12381Fr : xs)))
-> SomeTcInstr ('TBls12381Fr : xs)
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (SomeTcInstr ('TBls12381G1 : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBls12381G1 : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TBls12381G1 : xs)))
-> SomeTcInstr ('TBls12381G1 : xs)
-> TypeCheckInstr op (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)
-> TypeCheckInstr op (SomeTcInstr ('TBls12381G2 : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBls12381G2 : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TBls12381G2 : xs)))
-> SomeTcInstr ('TBls12381G2 : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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
vn, (SingT x
STBytes, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract [] op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBytes : '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 ('TBytes : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBytes : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBytes : '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 ('TBytes : 'TNat : xs) (ArithRes Lsl 'TBytes '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 ('TBytes : '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
:| [(Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])]
  (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
vn, (SingT x
STBytes, Dict (WellTyped x)
_) ::&
             (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> InstrAbstract [] op
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBytes : '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 ('TBytes : 'TNat : xs))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op ('TBytes : 'TNat : xs)))
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 'TNat : xs))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op ('TBytes : '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 ('TBytes : 'TNat : xs) (ArithRes Lsr 'TBytes '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 ('TBytes : '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
:| [(Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])]
  (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
vn, (SingT x
STBytes, Dict (WellTyped x)
_) ::&
            (SingT 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
$
    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
     ('TBytes : 'TBytes : xs) (ArithRes Or 'TBytes 'TBytes : 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 ('TBytes : 'TBytes : 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"])
      , (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bytes"])
      ]
  (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
vn, (SingT x
STBytes, Dict (WellTyped x)
_) ::&
             (SingT 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
$
    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
     ('TBytes : 'TBytes : xs) (ArithRes And 'TBytes 'TBytes : 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 ('TBytes : 'TBytes : 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"])
      , (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bytes"])
      ]
  (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
vn, (SingT x
STBytes, Dict (WellTyped x)
_) ::&
             (SingT 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
$
    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
     ('TBytes : 'TBytes : xs) (ArithRes Xor 'TBytes 'TBytes : 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 ('TBytes : 'TBytes : 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"])
      , (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bytes"])
      ]
  (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)
-> TypeCheckInstr op (SomeTcInstr ('TNat : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TNat : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TNat : xs)))
-> SomeTcInstr ('TNat : xs)
-> TypeCheckInstr op (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]).
(SingI n, 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)
-> TypeCheckInstr op (SomeTcInstr ('TBool : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBool : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TBool : xs)))
-> SomeTcInstr ('TBool : xs)
-> TypeCheckInstr op (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]).
(SingI n, 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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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]).
(SingI n, 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
vn, (SingT x
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
$
    SomeTcInstr ('TBytes : xs)
-> TypeCheckInstr op (SomeTcInstr ('TBytes : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TBytes : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TBytes : xs)))
-> SomeTcInstr ('TBytes : xs)
-> TypeCheckInstr op (SomeTcInstr ('TBytes : 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 ('TBytes : xs) (UnaryArithRes Not 'TBytes : xs)
forall (n :: T) (s :: [T]).
(SingI n, 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 ('TBytes : 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
:| [])
      , (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
      ]
  (U.NOT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 (f :: * -> *) op. VarAnn -> InstrAbstract f 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 (x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : x : xs)))
-> SomeTcInstr (x : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : x : 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 : x : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
Comparable 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 inp ('TInt : xs) -> HST ('TInt : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TInt
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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)
-> TypeCheckInstr op (SomeTcInstr ('TInt : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TInt : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TInt : xs)))
-> SomeTcInstr ('TInt : xs)
-> TypeCheckInstr op (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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TInt : xs) -> HST ('TInt : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TInt
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, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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) ('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 inp ('TInt : xs) -> HST ('TInt : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TInt
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TInt : xs) -> HST ('TInt : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TInt
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
$ OneItem (NonEmpty Text) -> NonEmpty Text
forall x. One x => OneItem x -> x
one Text
OneItem (NonEmpty Text)
"nat" NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| [OneItem (NonEmpty Text) -> NonEmpty Text
forall x. One x => OneItem x -> x
one Text
OneItem (NonEmpty Text)
"bytes", OneItem (NonEmpty Text) -> NonEmpty Text
forall x. One x => OneItem x -> x
one Text
OneItem (NonEmpty Text)
"bls12_381_fr"]
  (U.INT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.NAT VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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) ('TNat : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TNat : s)
AnnNAT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TNat : xs) -> HST ('TNat : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TNat
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.NAT 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.NAT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
forall (a :: [T]). TypeCheckInstrNoExcept op (TypeCheckedSeq op a)
notEnoughItemsOnStack

  (U.BYTES VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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) ('TBytes : xs)
forall (n :: T) (s :: [T]).
ToBytesArithOp n =>
AnnVar -> Instr (n : s) ('TBytes : s)
AnnBYTES (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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.BYTES VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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) ('TBytes : xs)
forall (n :: T) (s :: [T]).
ToBytesArithOp n =>
AnnVar -> Instr (n : s) ('TBytes : s)
AnnBYTES (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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.BYTES 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
:| [] ]
  (U.BYTES VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 (x : 'TAddress : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TAddress : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : 'TAddress : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : 'TAddress : xs)))
-> SomeTcInstr (x : 'TAddress : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TAddress : 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
:/ 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 inp ('TOption t : xs)
-> HST ('TOption t : xs) -> 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
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 :: Peano).
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
-> TypeCheckInstr op (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 -> TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
 -> TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
-> (forall (t :: T).
    SingI t =>
    Notes t -> TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
-> TypeCheckInstr op (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 ('TAddress : xs)
-> TypeCheckInstr op (SomeTcInstr ('TAddress : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TAddress : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TAddress : xs)))
-> SomeTcInstr ('TAddress : xs)
-> TypeCheckInstr op (SomeTcInstr ('TAddress : 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
:/ 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 inp ('TOption ('TContract t) : xs)
-> HST ('TOption ('TContract t) : xs) -> SomeTcInstrOut inp
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> (SingI n => TypeCheckInstrNoExcept op (TypeCheckedSeq op inp))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 n)
Dict) ->
            SomeTcInstr (x : 'TMutez : 'TContract n : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TMutez : 'TContract n : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : 'TMutez : 'TContract n : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : 'TMutez : 'TContract n : xs)))
-> SomeTcInstr (x : 'TMutez : 'TContract n : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 'TMutez : 'TContract n : 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 : '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 inp ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TOperation
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 ('TOption 'TKeyHash : xs)
-> TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TOption 'TKeyHash : xs)
 -> TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : xs)))
-> SomeTcInstr ('TOption 'TKeyHash : xs)
-> TypeCheckInstr op (SomeTcInstr ('TOption 'TKeyHash : 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 ('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 inp ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TOperation
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
      SomeParamType
paramType <- Either (TcError' op) SomeParamType
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     SomeParamType
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either (TcError' op) SomeParamType
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      SomeParamType)
-> Either (TcError' op) SomeParamType
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     SomeParamType
forall a b. (a -> b) -> a -> b
$ (TcTypeError -> TcError' op)
-> Either TcTypeError SomeParamType
-> Either (TcError' op) SomeParamType
forall a b c. (a -> b) -> Either a c -> Either b c
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 (ParameterType -> Either TcTypeError SomeParamType)
-> ParameterType -> Either TcTypeError SomeParamType
forall a b. (a -> b) -> a -> b
$ Contract' op -> ParameterType
forall op. Contract' op -> ParameterType
U.contractParameter Contract' op
contract
      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 (m :: * -> *) a.
Monad m =>
m a -> ReaderT TypeCheckInstrEnv m a
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
$
          (TypeCheckEnv op -> TypeCheckEnv op)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     SomeContract
forall a.
(TypeCheckEnv op -> TypeCheckEnv op)
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
-> ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity))
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local ((TypeCheckMode op -> Identity (TypeCheckMode op))
-> TypeCheckEnv op -> Identity (TypeCheckEnv op)
forall op1 op2 (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (TypeCheckMode op1) (f (TypeCheckMode op2))
-> p (TypeCheckEnv op1) (f (TypeCheckEnv 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
.~ SomeParamType -> TypeCheckMode op
forall op. SomeParamType -> TypeCheckMode op
TypeCheckContract SomeParamType
paramType) (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
$
          TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
forall op.
TcInstrBase op -> Contract' op -> TypeCheck op SomeContract
doTypeCheckContract' op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 ('TOption 'TKeyHash : 'TMutez : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
        (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TOption 'TKeyHash : 'TMutez : x : 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
:/ 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 inp ('TOperation : 'TAddress : xs)
-> HST ('TOperation : 'TAddress : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TOperation
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)
::& (Sing 'TAddress
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TContract 'TUnit : xs)
-> HST ('TContract 'TUnit : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing ('TContract 'TUnit)
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TTimestamp
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TMutez
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TMutez
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TNat : xs) -> HST ('TNat : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TNat
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TNat
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBool : xs) -> HST ('TBool : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBool
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBytes
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TKeyHash : xs)
-> HST ('TKeyHash : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TKeyHash
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TBool : xs) -> HST ('TBool : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TBool
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TAddress
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TAddress
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TAddress : xs)
-> HST ('TAddress : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TAddress
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TChainId
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TNat
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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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
::: ((Sing 'TAddress
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 Instr inp out
Instr ('TNever : xs) out
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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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))
-> TypeCheckInstr op (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))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
-> (Comparable x => SomeTcInstr (x : 'TNat : xs))
-> TypeCheckInstr op (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 inp ('TOption ('TTicket x) : xs)
-> HST ('TOption ('TTicket x) : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing ('TOption ('TTicket x))
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))
-> TypeCheckInstr op (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))
 -> TypeCheckInstr op (SomeTcInstr (x : 'TNat : xs)))
-> (Comparable x => SomeTcInstr (x : 'TNat : xs))
-> TypeCheckInstr op (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 inp ('TTicket x : xs)
-> HST ('TTicket x : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing ('TTicket x)
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
-> HST ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
-> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing ('TPair 'TAddress ('TPair n 'TNat))
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 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 -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 inp ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
-> HST ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
-> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing ('TOption ('TPair ('TTicket n) ('TTicket n)))
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 ('TPair ('TTicket n) ('TTicket n) : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs)))
-> SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr ('TPair ('TTicket n) ('TTicket n) : 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
     ('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 inp ('TOption ('TTicket n) : xs)
-> HST ('TOption ('TTicket n) : xs) -> SomeTcInstrOut inp
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 :: Peano).
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 inp ('TOr 'TBytes 'TBool : xs)
-> HST ('TOr 'TBytes 'TBool : xs) -> SomeTcInstrOut inp
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 Nat
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 => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a => TypeCheckInstr op (SomeTcInstr inp))
 -> TypeCheckInstr op (SomeTcInstr inp))
-> (SingI a => TypeCheckInstr op (SomeTcInstr inp))
-> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$
      SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp)
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeTcInstr inp -> TypeCheckInstr op (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 :: Peano) (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
::: ((Sing ('TSaplingState a)
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 Peano -> TypeCheckInstr op (SomeTcInstr inp))
-> SomeSing Peano -> TypeCheckInstr op (SomeTcInstr inp)
forall a b. (a -> b) -> a -> b
$ Nat -> SomeSing Peano
Peano.someSingNat Nat
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)
forall (a :: Peano) (b :: Peano).
SingNat a -> SingNat b -> Maybe (a :~: b)
testEquality Sing n
SingNat n
s1 Sing n
SingNat n
s2 of
          Just n :~: n
Refl ->
            SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs)
-> TypeCheckInstr
     op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs)
 -> TypeCheckInstr
      op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs)
-> TypeCheckInstr
     op (SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
HST ('TSaplingTransaction n : 'TSaplingState n : xs)
inp HST ('TSaplingTransaction n : 'TSaplingState n : xs)
-> SomeTcInstrOut ('TSaplingTransaction n : 'TSaplingState n : xs)
-> SomeTcInstr ('TSaplingTransaction n : 'TSaplingState n : xs)
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 :: Peano) (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 :: Peano). 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)
TypeCheckInstrNoExcept op (TypeCheckedSeq op '[])
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 (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : xs)))
-> SomeTcInstr (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 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
-> 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 inp ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TOperation
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 (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : xs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
      (SomeTcInstr (x : xs)))
-> SomeTcInstr (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     (SomeTcInstr (x : 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
-> 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 inp ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeTcInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: ((Sing 'TOperation
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 (TCInstrEnvs op) 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)
TcTypeError -> TypeCheckInstr op (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 (TCInstrEnvs op) 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 (TCInstrEnvs op) (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 :: Peano).
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 a b.
ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  a
-> (a
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         b)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     b
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 ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  r
TypeCheckInstr op r
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 a b.
ReaderT
  TypeCheckInstrEnv
  (ReaderT
     (TypeCheckEnv op)
     (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
  a
-> (a
    -> ReaderT
         TypeCheckInstrEnv
         (ReaderT
            (TypeCheckEnv op)
            (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
         b)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     b
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
TypeCheckInstr op 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 (OneItem [TypeCheckedOp op] -> [TypeCheckedOp op]
forall x. One x => OneItem x -> x
one (OneItem [TypeCheckedOp op] -> [TypeCheckedOp op])
-> OneItem [TypeCheckedOp op] -> [TypeCheckedOp op]
forall a b. (a -> b) -> a -> b
$ [IllTypedInstr op] -> TypeCheckedOp op
forall op. [IllTypedInstr op] -> TypeCheckedOp op
IllTypedOp ([IllTypedInstr op] -> TypeCheckedOp op)
-> [IllTypedInstr op] -> TypeCheckedOp op
forall a b. (a -> b) -> a -> b
$ (op -> IllTypedInstr op) -> [op] -> [IllTypedInstr op]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map 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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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))
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (SomeTcInstrOut (cond : rs))
-> TypeCheckInstr op (SomeTcInstr (cond : rs))
forall a b.
(a -> b)
-> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) a
-> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) b
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
:/) (MultiReaderT
   (TCInstrEnvs op)
   (Except (TcError' op))
   (SomeTcInstrOut (cond : rs))
 -> TypeCheckInstr op (SomeTcInstr (cond : rs)))
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (SomeTcInstrOut (cond : rs))
-> TypeCheckInstr op (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 (Except (TcError' op))))
     (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 (Except (TcError' op))))
      (out :~: out))
-> Either TcTypeError (out :~: out)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (Except (TcError' op))))
     (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 (Except (TcError' op))))
     (SomeTcInstrOut (cond : rs))
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (Except (TcError' op))))
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT
         (TypeCheckEnv op)
         (ReaderT TypeCheckOptions (Except (TcError' op))))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (Except (TcError' op))))
     (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)
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (SomeTcInstrOut (cond : rs))
forall a.
a -> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> MultiReaderT
      (TCInstrEnvs op)
      (Except (TcError' op))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (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)
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (SomeTcInstrOut (cond : rs))
forall a.
a -> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> MultiReaderT
      (TCInstrEnvs op)
      (Except (TcError' op))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (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)
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (SomeTcInstrOut (cond : rs))
forall a.
a -> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstrOut (cond : rs)
 -> MultiReaderT
      (TCInstrEnvs op)
      (Except (TcError' op))
      (SomeTcInstrOut (cond : rs)))
-> SomeTcInstrOut (cond : rs)
-> MultiReaderT
     (TCInstrEnvs op)
     (Except (TcError' op))
     (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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 (f :: * -> *) op. f op -> InstrAbstract f 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 a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (ExceptT (TcError' op) Identity)))
     a
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 : rs) rs -> Instr (c : rs) rs
forall (c :: T) (out :: [T]).
IterOp c =>
Instr (IterOpEl c : out) out -> Instr (c : out) out
ITER Instr (IterOpEl c : rs) rs
Instr (IterOpEl c : rs) out
subI Instr (c : rs) rs -> HST rs -> SomeTcInstrOut (c : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST rs
HST out
o
    AnyOutInstr forall (out :: [T]). Instr (IterOpEl c : rs) out
subI ->
      SomeTcInstr (c : rs) -> TypeCheckInstr op (SomeTcInstr (c : rs))
forall a.
a
-> MultiReaderT (TCInstrEnvs op) (ExceptT (TcError' op) Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeTcInstr (c : rs) -> TypeCheckInstr op (SomeTcInstr (c : rs)))
-> SomeTcInstr (c : rs) -> TypeCheckInstr op (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 : rs) rs -> Instr (c : rs) rs
forall (c :: T) (out :: [T]).
IterOp c =>
Instr (IterOpEl c : out) out -> Instr (c : out) out
ITER Instr (IterOpEl c : rs) rs
forall (out :: [T]). Instr (IterOpEl c : rs) out
subI Instr (c : rs) rs -> HST rs -> SomeTcInstrOut (c : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeTcInstrOut inp
::: HST rs
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 =>
 TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it]))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it]))
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it]))
-> (IsNotInView =>
    TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it]))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
forall a.
(TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> MultiReaderT (TCInstrEnvs op) Identity a
-> MultiReaderT (TCInstrEnvs op) Identity a
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) (TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
 -> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it]))
-> TypeCheckInstrNoExcept op (TypeCheckedSeq op '[it])
-> TypeCheckInstrNoExcept op (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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 =>
 TypeCheckInstrNoExcept
   op (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op '[it, 'TLambda it ot])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  TypeCheckInstrNoExcept
    op (TypeCheckedSeq op '[it, 'TLambda it ot]))
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> (IsNotInView =>
    TypeCheckInstrNoExcept
      op (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op '[it, 'TLambda it ot])
forall a b. (a -> b) -> a -> b
$
      (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op '[it, 'TLambda it ot])
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op '[it, 'TLambda it ot])
forall a.
(TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> MultiReaderT (TCInstrEnvs op) Identity a
-> MultiReaderT (TCInstrEnvs op) Identity a
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) (TypeCheckInstrNoExcept
   op (TypeCheckedSeq op '[it, 'TLambda it ot])
 -> TypeCheckInstrNoExcept
      op (TypeCheckedSeq op '[it, 'TLambda it ot]))
-> TypeCheckInstrNoExcept
     op (TypeCheckedSeq op '[it, 'TLambda it ot])
-> TypeCheckInstrNoExcept
     op (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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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 ()
-> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op ts)
-> MultiReaderT (TCInstrEnvs op) Identity (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 -> TypeCheckInstr op ())
-> TypeCheckInstr op ()
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 m. Monoid m => (Element [op] -> m) -> [op] -> m
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 -> TypeCheckInstr op ())
 -> TypeCheckInstr op ())
-> (InstrAbstract [] op -> TypeCheckInstr op ())
-> TypeCheckInstr op ()
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 (Except (TcError' op))))
     ()
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) (MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op ts)
 -> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op ts))
-> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op ts)
-> MultiReaderT (TCInstrEnvs op) Identity (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))
-> MultiReaderT (TCInstrEnvs op) Identity (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))
 -> MultiReaderT (TCInstrEnvs op) Identity (TypeCheckedSeq op ts))
-> (SomeTcInstr inp -> TypeCheckInstr op (SomeTcInstr ts))
-> MultiReaderT (TCInstrEnvs op) Identity (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)
-> MultiReaderT
     (TCInstrEnvs op) (Except (TcError' op)) (SomeTcInstrOut ts)
-> TypeCheckInstr op (SomeTcInstr ts)
forall a b.
(a -> b)
-> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) a
-> MultiReaderT (TCInstrEnvs op) (Except (TcError' op)) b
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
:/) (MultiReaderT
   (TCInstrEnvs op) (Except (TcError' op)) (SomeTcInstrOut ts)
 -> TypeCheckInstr op (SomeTcInstr ts))
-> MultiReaderT
     (TCInstrEnvs op) (Except (TcError' op)) (SomeTcInstrOut ts)
-> TypeCheckInstr op (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 (Except (TcError' op))))
     (SomeTcInstrOut ts)
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (Except (TcError' op))))
     a
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 '[ot] -> RemFail Instr inp '[ot]
forall {k} (instr :: k -> k -> *) (i :: k) (o :: k).
instr i o -> RemFail instr i o
RfNormal Instr inp out
Instr inp '[ot]
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 (Except (TcError' op))))
     (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 (Except (TcError' op))))
     (SomeTcInstrOut ts)
forall a.
a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv op)
        (ReaderT TypeCheckOptions (Except (TcError' op))))
     a
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 Instr inp o'
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 a.
(TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     a
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 ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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 a b.
(a -> b)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     b
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 a.
(TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     a
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT
        (TypeCheckEnv ExpandedOp) (ReaderT TypeCheckOptions Identity))
     a
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 ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept
     ExpandedOp (TypeCheckedSeq ExpandedOp inp)
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
<&> \case
      WellTypedSeq SomeTcInstr inp
instr -> SomeTcInstr inp -> TypeCheckedSeq ExpandedOp inp
forall op (inp :: [T]). SomeTcInstr inp -> TypeCheckedSeq op inp
WellTypedSeq (SomeTcInstr inp -> TypeCheckedSeq ExpandedOp inp)
-> SomeTcInstr inp -> TypeCheckedSeq ExpandedOp inp
forall a b. (a -> b) -> a -> b
$ (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 Instr inp out -> Instr inp out
forall (out :: [T]). Instr inp out -> Instr inp out
forall (inp :: [T]) (out :: [T]). Instr inp out -> Instr inp out
Nested SomeTcInstr inp
instr
      MixedSeq Nesting
nest SomeTcInstr inp
instr TcError' ExpandedOp
err [IllTypedInstr ExpandedOp]
rest -> Nesting
-> SomeTcInstr inp
-> TcError' ExpandedOp
-> [IllTypedInstr ExpandedOp]
-> TypeCheckedSeq ExpandedOp inp
forall op (inp :: [T]).
Nesting
-> SomeTcInstr inp
-> TcError' op
-> [IllTypedInstr op]
-> TypeCheckedSeq op inp
MixedSeq (Nesting -> Nesting
forall a. Enum a => a -> a
succ Nesting
nest) SomeTcInstr inp
instr TcError' ExpandedOp
err [IllTypedInstr ExpandedOp]
rest
      IllTypedSeq TcError' ExpandedOp
err [IllTypedInstr ExpandedOp]
op -> TcError' ExpandedOp
-> [IllTypedInstr ExpandedOp] -> TypeCheckedSeq ExpandedOp inp
forall op (inp :: [T]).
TcError' op -> [IllTypedInstr op] -> TypeCheckedSeq op inp
IllTypedSeq TcError' ExpandedOp
err [[IllTypedInstr ExpandedOp] -> IllTypedInstr ExpandedOp
forall op. [IllTypedInstr op] -> IllTypedInstr op
IllTypedNest [IllTypedInstr ExpandedOp]
op]

----------------------------------------------------------------------------
-- 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 op -> HST inp -> TypeCheckInstrNoExcept op (TypeCheckedSeq op inp)
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)