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

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

import Prelude hiding (EQ, GT, LT)

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

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

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

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

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

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

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

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

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

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

typeCheckContractImpl
  :: U.Contract
  -> TypeCheck SomeContract
typeCheckContractImpl :: Contract -> TypeCheck SomeContract
typeCheckContractImpl uContract :: Contract
uContract@(U.Contract wholeParam :: ParameterType
wholeParam@(U.ParameterType Ty
mParam RootAnn
rootAnn) Ty
mStorage [ExpandedOp]
pCode EntriesOrder
entriesOrder [View' ExpandedOp]
uViews) = do
  NonEmpty ExpandedOp
_ <- ReaderT
  TypeCheckOptions
  (ExceptT TCError (State TypeCheckEnv))
  (NonEmpty ExpandedOp)
-> (NonEmpty ExpandedOp
    -> ReaderT
         TypeCheckOptions
         (ExceptT TCError (State TypeCheckEnv))
         (NonEmpty ExpandedOp))
-> Maybe (NonEmpty ExpandedOp)
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError (State TypeCheckEnv))
     (NonEmpty ExpandedOp)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TCError
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError (State TypeCheckEnv))
     (NonEmpty ExpandedOp)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
 -> ReaderT
      TypeCheckOptions
      (ExceptT TCError (State TypeCheckEnv))
      (NonEmpty ExpandedOp))
-> TCError
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError (State TypeCheckEnv))
     (NonEmpty ExpandedOp)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"no instructions in contract code" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
EmptyCode)
                NonEmpty ExpandedOp
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError (State TypeCheckEnv))
     (NonEmpty ExpandedOp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ExpandedOp] -> Maybe (NonEmpty ExpandedOp)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty [ExpandedOp]
pCode)
  Ty
-> (forall (t :: T). SingI t => Notes t -> TypeCheck SomeContract)
-> TypeCheck SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mParam ((forall (t :: T). SingI t => Notes t -> TypeCheck SomeContract)
 -> TypeCheck SomeContract)
-> (forall (t :: T). SingI t => Notes t -> TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
paramNote :: Notes param) ->
    Ty
-> (forall (t :: T). SingI t => Notes t -> TypeCheck SomeContract)
-> TypeCheck SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mStorage ((forall (t :: T). SingI t => Notes t -> TypeCheck SomeContract)
 -> TypeCheck SomeContract)
-> (forall (t :: T). SingI t => Notes t -> TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
storageNote :: Notes st) -> do
      forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @st ((WellTyped t => TypeCheck SomeContract) -> TypeCheck SomeContract)
-> (WellTyped t => TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
        forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @param ((WellTyped t => TypeCheck SomeContract) -> TypeCheck SomeContract)
-> (WellTyped t => TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
          Dict (ParameterScope t)
Dict <- (BadTypeForScope -> TypeCheck (Dict (ParameterScope t)))
-> (Dict (ParameterScope t) -> TypeCheck (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> TypeCheck (Dict (ParameterScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @param Text
"parameter") Dict (ParameterScope t) -> TypeCheck (Dict (ParameterScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either BadTypeForScope (Dict (ParameterScope t))
 -> TypeCheck (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> TypeCheck (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 -> TypeCheck (Dict (StorageScope t)))
-> (Dict (StorageScope t) -> TypeCheck (Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> TypeCheck (Dict (StorageScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @st Text
"storage") Dict (StorageScope t) -> TypeCheck (Dict (StorageScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either BadTypeForScope (Dict (StorageScope t))
 -> TypeCheck (Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> TypeCheck (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 '[ContractInp1 t t]
inp = (forall {k} (a :: k). SingI a => Sing a
forall (a :: T). SingI a => Sing a
sing @('TPair param st), Dict (WellTyped (ContractInp1 t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT (ContractInp1 t t), Dict (WellTyped (ContractInp1 t t)))
-> HST '[] -> HST '[ContractInp1 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 '[ContractInp1 t t]
codeRes <-
            TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ContractInp1 t t])
-> TypeCheck (TypeCheckedSeq '[ContractInp1 t t])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
   (TypeCheckedSeq '[ContractInp1 t t])
 -> TypeCheck (TypeCheckedSeq '[ContractInp1 t t]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ContractInp1 t t])
-> TypeCheck (TypeCheckedSeq '[ContractInp1 t t])
forall a b. (a -> b) -> a -> b
$
            TypeCheckInstrNoExcept (TypeCheckedSeq '[ContractInp1 t t])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ContractInp1 t t])
forall a. TypeCheckInstrNoExcept a -> TypeCheckInstr a
liftNoExcept (TypeCheckInstrNoExcept (TypeCheckedSeq '[ContractInp1 t t])
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TypeCheckedSeq '[ContractInp1 t t]))
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ContractInp1 t t])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ContractInp1 t t])
forall a b. (a -> b) -> a -> b
$
            TcInstrHandler
-> [ExpandedOp]
-> HST '[ContractInp1 t t]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ContractInp1 t t])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl
              ((IsNotInView =>
 ExpandedInstr
 -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
  ExpandedInstr
  -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> ExpandedInstr
 -> HST inp
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (IsNotInView =>
    ExpandedInstr
    -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter
  TypeCheckInstrEnv
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
  (Maybe (Dict IsNotInView))
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  TypeCheckInstrEnv
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
  (Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView (Maybe (Dict IsNotInView)
 -> TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall a b. (a -> b) -> a -> b
$ Dict IsNotInView -> Maybe (Dict IsNotInView)
forall a. a -> Maybe a
Just Dict IsNotInView
forall (a :: Constraint). a => Dict a
Dict) (TypeCheckInstrNoExcept (TypeCheckedSeq inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (ExpandedInstr
    -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b c. SuperComposition a b c => a -> b -> c
... ExpandedInstr
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
TcInstrHandler
typeCheckInstr)
              [ExpandedOp]
pCode
              HST '[ContractInp1 t t]
inp
          instr :: SomeInstr '[ContractInp1 t t]
instr@(HST '[ContractInp1 t t]
_ :/ SomeInstrOut '[ContractInp1 t t]
instrOut) <-
            ([TypeCheckedOp]
 -> TCError -> TypeCheck (SomeInstr '[ContractInp1 t t]))
-> (SomeInstr '[ContractInp1 t t]
    -> TypeCheck (SomeInstr '[ContractInp1 t t]))
-> TypeCheckedSeq '[ContractInp1 t t]
-> TypeCheck (SomeInstr '[ContractInp1 t t])
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither [TypeCheckedOp]
-> TCError -> TypeCheck (SomeInstr '[ContractInp1 t t])
forall a. [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedCodeTypeCheck SomeInstr '[ContractInp1 t t]
-> TypeCheck (SomeInstr '[ContractInp1 t t])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq '[ContractInp1 t t]
codeRes

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

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

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

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

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

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

typeCheckViewImpl :: WellTyped st => Notes st -> U.View -> TypeCheck (SomeView st)
typeCheckViewImpl :: forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
storageNote
  uView :: View' ExpandedOp
uView@U.View
  { viewArgument :: forall op. View' op -> Ty
U.viewArgument = AsUType (Notes t
argNote :: Notes param)
  , viewReturn :: forall op. View' op -> Ty
U.viewReturn = AsUType (Notes t
returnNote :: Notes ret)
  , viewCode :: forall op. View' op -> [op]
U.viewCode = [ExpandedOp]
uInstr
  , viewName :: forall op. View' op -> ViewName
U.viewName = ViewName
viewName
  }
  = forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @param ((WellTyped t => TypeCheck (SomeView st))
 -> TypeCheck (SomeView st))
-> (WellTyped t => TypeCheck (SomeView st))
-> TypeCheck (SomeView st)
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @ret ((WellTyped t => TypeCheck (SomeView st))
 -> TypeCheck (SomeView st))
-> (WellTyped t => TypeCheck (SomeView st))
-> TypeCheck (SomeView 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))
    -> TypeCheck (Dict (ViewableScope t)))
-> TypeCheck (Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope -> TypeCheck (Dict (ViewableScope t)))
-> (Dict (ViewableScope t) -> TypeCheck (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> TypeCheck (Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @param Text
"parameter") Dict (ViewableScope t) -> TypeCheck (Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    Dict (ViewableScope t)
Dict <-
      forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope ret)
      Either BadTypeForScope (Dict (ViewableScope t))
-> (Either BadTypeForScope (Dict (ViewableScope t))
    -> TypeCheck (Dict (ViewableScope t)))
-> TypeCheck (Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope -> TypeCheck (Dict (ViewableScope t)))
-> (Dict (ViewableScope t) -> TypeCheck (Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> TypeCheck (Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @ret Text
"return") Dict (ViewableScope t) -> TypeCheck (Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    TypeCheckedSeq '[ 'TPair t st]
codeRes <-
      TypeCheckInstrEnv
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ 'TPair t st])
-> TypeCheck (TypeCheckedSeq '[ 'TPair t st])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
   TypeCheckInstrEnv
   (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
   (TypeCheckedSeq '[ 'TPair t st])
 -> TypeCheck (TypeCheckedSeq '[ 'TPair t st]))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ 'TPair t st])
-> TypeCheck (TypeCheckedSeq '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
      TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ 'TPair t st])
forall a. TypeCheckInstrNoExcept a -> TypeCheckInstr a
liftNoExcept (TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t st])
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TypeCheckedSeq '[ 'TPair t st]))
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TypeCheckedSeq '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
      TcInstrHandler
-> [ExpandedOp]
-> HST '[ 'TPair t st]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t st])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr [ExpandedOp]
uInstr HST '[ 'TPair t st]
inp
    HST '[ 'TPair t st]
_ :/ SomeInstrOut '[ 'TPair t st]
instrOut <-
      ([TypeCheckedOp]
 -> TCError -> TypeCheck (SomeInstr '[ 'TPair t st]))
-> (SomeInstr '[ 'TPair t st]
    -> TypeCheck (SomeInstr '[ 'TPair t st]))
-> TypeCheckedSeq '[ 'TPair t st]
-> TypeCheck (SomeInstr '[ 'TPair t st])
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither (View' ExpandedOp
-> [TypeCheckedOp]
-> TCError
-> TypeCheck (SomeInstr '[ 'TPair t st])
forall a.
View' ExpandedOp -> [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedViewsTypeCheck View' ExpandedOp
uView) SomeInstr '[ 'TPair t st] -> TypeCheck (SomeInstr '[ 'TPair t st])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq '[ 'TPair t st]
codeRes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  (U.DROPN Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go Word
nTotal HST inp
inputHST TypeCheckInstr (TCDropHelper inp)
-> (TCDropHelper inp -> SomeInstr inp)
-> TypeCheckInstr (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCDropHelper PeanoNatural n
s HST out
out -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp (Drop n inp)
forall (n :: Peano) (inp :: [T]).
RequireLongerOrSameLength inp n =>
PeanoNatural n -> Instr inp (Drop n inp)
DROPN PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDropHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TCDropHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDropHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
0, HST inp
i) -> TCDropHelper inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDropHelper inp)
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 TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
  (TCDropHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

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

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

  (U.DUPN VarAnn
vn Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go Word
nTotal HST inp
inputHST TypeCheckInstr (TCDupNHelper inp)
-> (TCDupNHelper inp -> SomeInstr inp)
-> TypeCheckInstr (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural n -> Instr inp out
forall (n :: 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 -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDupNHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go = ((Word, HST inp)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TCDupNHelper inp))
-> Word
-> HST inp
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDupNHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
_, HST inp
SNil) -> ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
  (TCDupNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

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

        -- Don't bind whatever variable annotation is here because DUP n doesn't
        -- duplicate variable annotations. This is consistent with tezos-client.
        (Word
1, i :: HST inp
i@((SingT x
an :: SingT a, Dict (WellTyped x)
dict) ::& HST xs
_)) -> do
          Dict (DupableScope x)
Dict <-
            forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (DupableScope x))
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
            forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope a)
          TCDupNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDupNHelper (x : xs))
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 (TCDupNHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail TypeCheckInstr (TCDupNHelper xs)
-> (TCDupNHelper xs -> TCDupNHelper inp)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDupNHelper inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper s :: PeanoNatural n
s@(Succ PeanoNatural m
_) ((SingT x, Dict (WellTyped x))
a ::& HST xs
resTail)) ->
            PeanoNatural ('S ('S (Decrement n)))
-> HST (x : x : xs) -> TCDupNHelper (x : xs)
forall (n :: 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 (Decrement 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)

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

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

  (U.DIG Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go Word
nTotal HST inp
inputHST TypeCheckInstr (TCDigHelper inp)
-> (TCDigHelper inp -> SomeInstr inp)
-> TypeCheckInstr (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDigHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp out
forall (n :: 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 -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDigHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go = ((Word, HST inp) -> TypeCheckInstr (TCDigHelper inp))
-> Word -> HST inp -> TypeCheckInstr (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) -> TypeCheckInstr (TCDigHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

        (Word
0, i :: HST inp
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_)) -> TCDigHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDigHelper (x : xs))
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 (TCDigHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail TypeCheckInstr (TCDigHelper xs)
-> (TCDigHelper xs -> TCDigHelper (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (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) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go Word
nTotal HST inp
inputHST TypeCheckInstr (TCDugHelper inp)
-> (TCDugHelper inp -> SomeInstr inp)
-> TypeCheckInstr (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDugHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp out
forall (n :: 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 -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
    where
      go :: forall inp. SingI inp
        => Word
        -> HST inp
        -> TypeCheckInstr (TCDugHelper inp)
      go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go = ((Word, HST inp) -> TypeCheckInstr (TCDugHelper inp))
-> Word -> HST inp -> TypeCheckInstr (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 TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCDugHelper (x : xs))
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 (TCDugHelper (x : xs))
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
iTail) TypeCheckInstr (TCDugHelper (x : xs))
-> (TCDugHelper (x : xs) -> TCDugHelper (x : x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (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)
_ -> TypeCheckInstr (TCDugHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      unexpectedType :: TypeCheckInstr a
      unexpectedType :: forall a. TypeCheckInstr a
unexpectedType = TCTypeError -> TypeCheckInstr a
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr a)
-> TCTypeError -> TypeCheckInstr a
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Word -> Text
pairWithElems Word
nTotal Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  (U.GETN VarAnn
_ Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
  (U.GETN VarAnn
getNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
    Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
ix0 HST inp
HST (x : xs)
inp TypeCheckInstr (TCGetNHelper (x : xs))
-> (TCGetNHelper (x : xs) -> SomeInstr inp)
-> TypeCheckInstr (SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
      TCGetNHelper PeanoNatural ix
s HST (GetN ix pair : rest)
out ->
        HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural ix -> Instr (x : xs) (GetN ix x : xs)
forall (ix :: 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 (x : xs) (GetN ix x : xs)
-> HST (GetN ix x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (GetN ix x : xs)
HST (GetN ix pair : rest)
out
    where
      go :: forall x xs. Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
      go :: forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
0 ((SingT x
a, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (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
rest)
      go Word
1 ((STPair Sing n1
leftNotes Sing n2
_, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (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
rest
      go Word
ix ((STPair Sing n1
_ Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
        Word -> HST (n2 : xs) -> TypeCheckInstr (TCGetNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go (Word
ix Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
2) ((Sing n2
SingT n2
rightNotes, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) TypeCheckInstr (TCGetNHelper (n2 : xs))
-> (TCGetNHelper (n2 : xs) -> TCGetNHelper (x : xs))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCGetNHelper (x : 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
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (TCGetNHelper (x : xs))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
 -> ReaderT
      TypeCheckInstrEnv
      (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
      (TCGetNHelper (x : xs)))
-> TCTypeError
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (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 (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n1 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n2 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ HST inp -> VarAnn -> TypeCheckInstr (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
  (U.UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n1
-> (SingI n1 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n1 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n2 => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ HST inp -> VarAnn -> TypeCheckInstr (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
  (U.UPDATE VarAnn
varAnn,
   (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STSet Sing n
s, Dict (WellTyped x)
_) ::& HST xs
_) ->
    Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ HST inp -> VarAnn -> TypeCheckInstr (SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
       (inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
 inp ~ (updKey : updParams : c : rs),
 MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  (U.SAPLING_EMPTY_STATE VarAnn
vn Natural
n, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
    (\(SomeSing (Sing a
s :: Sing a)) -> Sing a
-> (SingI a => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (SingI a => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
      SomeInstr inp -> TypeCheckInstr (SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp -> TypeCheckInstr (SomeInstr inp))
-> SomeInstr inp -> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Sing a -> Instr inp ('TSaplingState a : inp)
forall (n :: 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) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TSaplingState a)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TSaplingState a))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TSaplingState a), Dict (WellTyped ('TSaplingState a)))
-> HST inp -> HST ('TSaplingState a : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
    ) (SomeSing Peano -> TypeCheckInstr (SomeInstr inp))
-> SomeSing Peano -> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ Natural -> SomeSing Peano
Peano.someSingNat Natural
n

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

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

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

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

    failWithErr :: TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
    failWithErr :: forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr = ExpandedInstr
-> TypeCheckInstr (SomeInstr a)
-> TypeCheckInstrNoExcept (TypeCheckedSeq a)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr a)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq a))
-> (TCTypeError -> TypeCheckInstr (SomeInstr a))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError -> TypeCheckInstr (SomeInstr a)
forall a. TCTypeError -> TypeCheckInstr a
failWithErr'

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

    notEnoughItemsOnStack :: TypeCheckInstrNoExcept (TypeCheckedSeq a)
    notEnoughItemsOnStack :: forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack = TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr TCTypeError
NotEnoughItemsOnStack

    notEnoughItemsOnStack' :: TypeCheckInstr a
    notEnoughItemsOnStack' :: forall a. TypeCheckInstr a
notEnoughItemsOnStack' = TCTypeError -> TypeCheckInstr a
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' TCTypeError
NotEnoughItemsOnStack

    withNotInView :: U.ExpandedInstr -> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
    withNotInView :: forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
instr IsNotInView => TypeCheckInstr r
act = (TypeCheckEnv -> TypeCheckMode)
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     TypeCheckMode
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets TypeCheckEnv -> TypeCheckMode
tcMode ReaderT
  TypeCheckInstrEnv
  (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
  TypeCheckMode
-> (TypeCheckMode -> TypeCheckInstr r) -> TypeCheckInstr r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      -- we provide the not-in-view constraint in the isolated mode
      TypeCheckMode
TypeCheckTest -> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
forall r. (IsNotInView => r) -> r
giveNotInView IsNotInView => TypeCheckInstr r
act
      TypeCheckMode
_ -> Getting
  (Maybe (Dict IsNotInView))
  TypeCheckInstrEnv
  (Maybe (Dict IsNotInView))
-> ReaderT
     TypeCheckInstrEnv
     (ReaderT TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
     (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 TypeCheckOptions (ExceptT TCError (State TypeCheckEnv)))
  (Maybe (Dict IsNotInView))
-> (Maybe (Dict IsNotInView) -> TypeCheckInstr r)
-> TypeCheckInstr r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Just Dict IsNotInView
Dict -> TypeCheckInstr r
IsNotInView => TypeCheckInstr r
act
        Maybe (Dict IsNotInView)
Nothing -> TCTypeError -> TypeCheckInstr r
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr r)
-> TCTypeError -> TypeCheckInstr r
forall a b. (a -> b) -> a -> b
$
          ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
instr Text
"This instruction cannot be used on the top level of a view"

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

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

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

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

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

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

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