-- SPDX-FileCopyrightText: 2020 Tocqueville Group
--
-- SPDX-License-Identifier: LicenseRef-MIT-TQ

-- | Module, providing functions for conversion from
-- instruction and value representation from @Michelson.Type@ module
-- to strictly-typed GADT-based representation from @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 satsify 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 Michelson.TypeCheck.Instr
    ( typeCheckContract
    , typeCheckContractAndStorage
    , typeCheckInstr
    , typeCheckList
    , typeCheckListNoExcept
    , typeCheckParameter
    , typeCheckStorage
    , typeCheckTopLevelType
    , typeCheckValue
    , typeVerifyContract
    , typeVerifyParameter
    , typeVerifyStorage
    , typeVerifyTopLevelType
    ) where

import Prelude hiding (EQ, GT, LT)

import Control.Monad.Except (MonadError, catchError, liftEither, throwError)
import Data.Default (def)
import Data.Generics (everything, mkQ)
import Data.Singletons (Sing, demote, withSingI, withSomeSing)
import Data.Typeable ((:~:)(..))
import Fmt (pretty)
import Named ((!))

import Michelson.ErrorPos
import Michelson.TypeCheck.Error
import Michelson.TypeCheck.Ext
import Michelson.TypeCheck.Helpers
import Michelson.TypeCheck.TypeCheck
import Michelson.TypeCheck.TypeCheckedSeq
  (IllTypedInstr(..), TypeCheckedInstr, TypeCheckedOp(..), TypeCheckedSeq(..), someInstrToOp,
  tcsEither)
import Michelson.TypeCheck.Types
import Michelson.TypeCheck.Value
import Michelson.Typed.Value

import Michelson.Typed hiding (Branch(..))
import Util.Peano
import Util.PeanoNatural
import Util.Sing (SingI1(..))
import Util.Type (onFirst, type (++))

import qualified Michelson.Untyped as U
import Michelson.Untyped.Annotation (FieldTag, VarAnn, VarTag, annQ, convAnn, orAnn)

-- | 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 <- Value -> TypeCheckResult (Value st)
forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeVerifyStorage @st Value
uStorage
  pure $ Contract cp st -> Value st -> SomeContractAndStorage
forall (cp :: T) (cp :: T).
(StorageScope cp, ParameterScope cp) =>
Contract cp cp -> Value cp -> 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 :: 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 x.
 Demote T
 -> Demote T -> ReaderT TypeCheckOptions (Except TCError) x)
-> ReaderT TypeCheckOptions (Except TCError) (cp :~: cp)
forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. Demote T -> Demote T -> m x) -> m (a :~: b)
requireEq @cp' @cp (TopLevelType
-> T -> T -> ReaderT TypeCheckOptions (Except TCError) x
forall any. TopLevelType -> T -> T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
  st :~: st
Refl <- (forall x.
 Demote T
 -> Demote T -> ReaderT TypeCheckOptions (Except TCError) x)
-> ReaderT TypeCheckOptions (Except TCError) (st :~: st)
forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. Demote T -> Demote T -> m x) -> m (a :~: b)
requireEq @st' @st (TopLevelType
-> T -> T -> ReaderT TypeCheckOptions (Except TCError) x
forall any. TopLevelType -> T -> T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
  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 -> T -> T -> TypeCheckResult any
    mkErr :: TopLevelType -> T -> T -> TypeCheckResult any
mkErr TopLevelType
tyDesc T
got T
expected =
      TCError -> TypeCheckResult any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError -> TypeCheckResult any) -> TCError -> TypeCheckResult 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 -> ("expected" :! T) -> ("got" :! T) -> TCTypeError
UnexpectedTopLevelType TopLevelType
tyDesc
            (("expected" :! T) -> ("got" :! T) -> TCTypeError)
-> Param ("expected" :! T) -> ("got" :! T) -> TCTypeError
forall p fn fn'. WithParam p fn fn' => fn -> Param p -> fn'
! IsLabel "expected" (T -> Param ("expected" :! T))
T -> Param ("expected" :! T)
#expected T
expected
            (("got" :! T) -> TCTypeError) -> Param ("got" :! T) -> TCTypeError
forall p fn fn'. WithParam p fn fn' => fn -> Param p -> fn'
! IsLabel "got" (T -> Param ("got" :! T))
T -> Param ("got" :! T)
#got T
got

withWTP :: forall t a. SingI t => (WellTyped t => TypeCheck a) -> TypeCheck a
withWTP :: (WellTyped t => TypeCheck a) -> TypeCheck a
withWTP WellTyped t => TypeCheck a
fn = case SingI t => Either NotWellTyped (Dict (WellTyped t))
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 T
t BadTypeForScope
cause) -> 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
    (Text
"Not a well typed value: '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> T -> Text
forall b a. (Show a, IsString b) => a -> b
show T
t Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"' because it " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> BadTypeForScope -> Text
forall a b. (Buildable a, FromBuilder b) => a -> b
pretty BadTypeForScope
cause) Maybe TCTypeError
forall a. Maybe a
Nothing

withWTPInstr_ :: forall t a. SingI t => U.ExpandedInstr -> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ :: ExpandedInstr
-> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ ExpandedInstr
v SomeHST
t WellTyped t => TypeCheckInstr a
fn = case SingI t => Either NotWellTyped (Dict (WellTyped t))
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
    InstrCallStack
loc <- ReaderT InstrCallStack TypeCheck InstrCallStack
forall r (m :: * -> *). MonadReader r m => m r
ask
    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
-> InstrCallStack
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
v SomeHST
t InstrCallStack
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'_ :: ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ ExpandedInstr
v SomeHST
t WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp)
fn = case SingI t => Either NotWellTyped (Dict (WellTyped t))
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
    InstrCallStack
loc <- ReaderT InstrCallStack TypeCheckNoExcept InstrCallStack
forall r (m :: * -> *). MonadReader r m => m r
ask
    let err :: TCError
err = ExpandedInstr
-> SomeHST
-> InstrCallStack
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
v SomeHST
t InstrCallStack
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 (U.Contract wholeParam :: ParameterType
wholeParam@(U.ParameterType Ty
mParam RootAnn
rootAnn) Ty
mStorage [ExpandedOp]
pCode EntriesOrder
entriesOrder) = 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 a. SingI t => (WellTyped t => TypeCheck a) -> TypeCheck a
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 a. SingI t => (WellTyped t => TypeCheck a) -> TypeCheck a
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 (Text -> BadTypeForScope -> TypeCheck (Dict (ParameterScope t))
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
$ CheckScope (ParameterScope t) =>
Either BadTypeForScope (Dict (ParameterScope t))
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 (Text -> BadTypeForScope -> TypeCheck (Dict (StorageScope t))
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
$ CheckScope (StorageScope t) =>
Either BadTypeForScope (Dict (StorageScope t))
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(StorageScope st)
          let param :: Annotation tag
param = [annQ|parameter|]
          let store :: Annotation tag
store = [annQ|storage|]
          let inpNote :: Notes ('TPair t t)
inpNote = TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes t
-> Notes t
-> Notes ('TPair t t)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def VarAnn
forall k (tag :: k). Annotation tag
param VarAnn
forall k (tag :: k). Annotation tag
store Notes t
paramNote Notes t
storageNote
          let inp :: HST '[ 'TPair t t]
inp = (Notes ('TPair t t)
inpNote, Dict (WellTyped ('TPair t t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall a. Default a => a
def) (Notes ('TPair t t), Dict (WellTyped ('TPair t t)), VarAnn)
-> HST '[] -> HST '[ 'TPair t t]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST '[]
SNil

          TypeCheckedSeq '[ 'TPair t t]
codeRes <- InstrCallStack
-> ReaderT InstrCallStack TypeCheck (TypeCheckedSeq '[ 'TPair t t])
-> TypeCheck (TypeCheckedSeq '[ 'TPair t t])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT InstrCallStack
forall a. Default a => a
def (ReaderT InstrCallStack TypeCheck (TypeCheckedSeq '[ 'TPair t t])
 -> TypeCheck (TypeCheckedSeq '[ 'TPair t t]))
-> ReaderT InstrCallStack TypeCheck (TypeCheckedSeq '[ 'TPair t t])
-> TypeCheck (TypeCheckedSeq '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
                     TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t t])
-> ReaderT InstrCallStack TypeCheck (TypeCheckedSeq '[ 'TPair t t])
forall a. TypeCheckInstrNoExcept a -> TypeCheckInstr a
liftNoExcept (TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t t])
 -> ReaderT
      InstrCallStack TypeCheck (TypeCheckedSeq '[ 'TPair t t]))
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t t])
-> ReaderT InstrCallStack TypeCheck (TypeCheckedSeq '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
                     TcInstrHandler
-> [ExpandedOp]
-> HST '[ 'TPair t t]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t t])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr [ExpandedOp]
pCode HST '[ 'TPair t t]
inp
          TypeCheckedSeq '[ 'TPair t t]
codeRes TypeCheckedSeq '[ 'TPair t t]
-> (TypeCheckedSeq '[ 'TPair t t] -> TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. a -> (a -> b) -> b
& ([TypeCheckedOp] -> TCError -> TypeCheck SomeContract)
-> (SomeInstr '[ 'TPair t t] -> TypeCheck SomeContract)
-> TypeCheckedSeq '[ 'TPair t t]
-> TypeCheck SomeContract
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither
            ([TypeCheckedOp] -> TCError -> TypeCheck SomeContract
onFailedTypeCheck)
            (Notes (ContractOut1 t)
-> SomeInstr '[ 'TPair t t] -> TypeCheck SomeContract
forall (st :: T) (param :: T).
(ParameterScope param, StorageScope st, WellTyped st) =>
Notes (ContractOut1 st)
-> SomeInstr (ContractInp param st) -> TypeCheck SomeContract
onSuccessfulTypeCheck (TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes ('TList 'TOperation)
-> Notes t
-> Notes (ContractOut1 t)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def VarAnn
forall a. Default a => a
def VarAnn
forall a. Default a => a
def Notes ('TList 'TOperation)
forall (t :: T). SingI t => Notes t
starNotes Notes t
storageNote))
  where
    hasTypeError :: forall (t :: T) a. SingI t => Text -> BadTypeForScope -> TypeCheck a
    hasTypeError :: Text -> BadTypeForScope -> TypeCheck a
hasTypeError Text
name BadTypeForScope
reason = 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 (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 ((SingKind T, SingI t) => Demote T
forall k (a :: k). (SingKind k, SingI a) => Demote k
demote @t) BadTypeForScope
reason

    onFailedTypeCheck :: [TypeCheckedOp] -> TCError -> TypeCheck SomeContract
    onFailedTypeCheck :: [TypeCheckedOp] -> TCError -> TypeCheck SomeContract
onFailedTypeCheck [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 SomeContract
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 -> Contract' op
U.Contract
             { contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
             , contractStorage :: Ty
contractStorage = Ty
mStorage
             , contractCode :: [TypeCheckedOp]
contractCode = [TypeCheckedOp]
ops
             , entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
             }
        else TCError
err

    onSuccessfulTypeCheck
      :: forall st param
      . (ParameterScope param, StorageScope st, WellTyped st)
      => Notes (ContractOut1 st)
      -> SomeInstr (ContractInp param st)
      -> TypeCheck SomeContract
    onSuccessfulTypeCheck :: Notes (ContractOut1 st)
-> SomeInstr (ContractInp param st) -> TypeCheck SomeContract
onSuccessfulTypeCheck Notes (ContractOut1 st)
outNote i :: SomeInstr (ContractInp param st)
i@(HST (ContractInp param st)
inp' :/ SomeInstrOut (ContractInp param st)
instrOut) = SomeInstr (ContractInp param st)
-> TypeCheck SomeContract -> TypeCheck SomeContract
forall (inp :: [T]).
SomeInstr inp -> TypeCheck SomeContract -> TypeCheck SomeContract
wrapErrorsIfVerbose SomeInstr (ContractInp param st)
i (TypeCheck SomeContract -> TypeCheck SomeContract)
-> TypeCheck SomeContract -> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
      let (Notes param
paramNotesRaw, Notes st
cStoreNotes) = case HST (ContractInp param st)
inp' of
            (NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ Notes p
cpNotes Notes q
stNotes, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
SNil -> (Notes param
Notes p
cpNotes, Notes st
Notes q
stNotes)
      ParamNotes param
cParamNotes <-
        Either TCError (ParamNotes param)
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError (State TypeCheckEnv))
     (ParamNotes param)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError (ParamNotes param)
 -> ReaderT
      TypeCheckOptions
      (ExceptT TCError (State TypeCheckEnv))
      (ParamNotes param))
-> Either TCError (ParamNotes param)
-> ReaderT
     TypeCheckOptions
     (ExceptT TCError (State TypeCheckEnv))
     (ParamNotes param)
forall a b. (a -> b) -> a -> b
$
        Notes param -> RootAnn -> Either ParamEpError (ParamNotes param)
forall (t :: T).
Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)
mkParamNotes Notes param
paramNotesRaw RootAnn
rootAnn Either ParamEpError (ParamNotes param)
-> (ParamEpError -> TCError) -> Either TCError (ParamNotes param)
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)
      case SomeInstrOut (ContractInp param st)
instrOut of
        Instr (ContractInp param st) 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 HST out -> Either TCTypeError (out :~: '[ContractOut1 st])
forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @(ContractOut1 st) HST out
out of
            Right out :~: '[ContractOut1 st]
Refl -> do
              let (Notes x
outN, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
SNil = HST out
out
              Notes (ContractOut1 st)
_ <- Notes (ContractOut1 st)
-> Notes (ContractOut1 st)
-> Either AnnConvergeError (Notes (ContractOut1 st))
forall (t :: T).
Notes t -> Notes t -> Either AnnConvergeError (Notes t)
converge Notes (ContractOut1 st)
outN Notes (ContractOut1 st)
outNote
                      Either AnnConvergeError (Notes (ContractOut1 st))
-> (AnnConvergeError -> TCError)
-> Either TCError (Notes (ContractOut1 st))
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst`
                  ((Text -> Maybe TCTypeError -> TCError
TCContractError Text
"contract output type violates convention:") (Maybe TCTypeError -> TCError)
-> (AnnConvergeError -> Maybe TCTypeError)
-> AnnConvergeError
-> TCError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> (AnnConvergeError -> TCTypeError)
-> AnnConvergeError
-> Maybe TCTypeError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnnConvergeError -> TCTypeError
AnnError)
              pure $ Contract param st -> SomeContract
forall (cp :: T) (st :: T). Contract cp st -> SomeContract
SomeContract Contract :: forall (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode cp st
-> ParamNotes cp -> Notes st -> EntriesOrder -> Contract cp st
Contract
                { cCode :: ContractCode param st
cCode = Instr (ContractInp param st) out
ContractCode param st
instr
                , ParamNotes param
cParamNotes :: ParamNotes param
cParamNotes :: ParamNotes param
cParamNotes
                , Notes st
cStoreNotes :: Notes st
cStoreNotes :: Notes st
cStoreNotes
                , cEntriesOrder :: EntriesOrder
cEntriesOrder = EntriesOrder
entriesOrder
                }
            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 (ContractInp param st) 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 param st -> SomeContract
forall (cp :: T) (st :: T). Contract cp st -> SomeContract
SomeContract Contract :: forall (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode cp st
-> ParamNotes cp -> Notes st -> EntriesOrder -> Contract cp st
Contract
            { cCode :: ContractCode param st
cCode = ContractCode param st
forall (out :: [T]). Instr (ContractInp param st) out
instr
            , ParamNotes param
cParamNotes :: ParamNotes param
cParamNotes :: ParamNotes param
cParamNotes
            , Notes st
cStoreNotes :: Notes st
cStoreNotes :: Notes st
cStoreNotes
            , cEntriesOrder :: EntriesOrder
cEntriesOrder = EntriesOrder
entriesOrder
            }

    wrapErrorsIfVerbose :: SomeInstr inp -> TypeCheck SomeContract -> TypeCheck SomeContract
    wrapErrorsIfVerbose :: SomeInstr inp -> TypeCheck SomeContract -> TypeCheck SomeContract
wrapErrorsIfVerbose SomeInstr inp
instr TypeCheck SomeContract
action =
      TypeCheck SomeContract
action TypeCheck SomeContract
-> (TCError -> TypeCheck SomeContract) -> TypeCheck SomeContract
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` ([TypeCheckedOp] -> TCError -> TypeCheck SomeContract
onFailedTypeCheck [SomeInstr inp -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr inp
instr])

-- | Function @typeCheckList@ converts list of Michelson instructions
-- given in representation from @Michelson.Type@ module to representation
-- in strictly typed GADT.
--
-- Types are checked along the way which is neccessary 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 :: [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 @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 :: [ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept = InstrCallStack
-> ReaderT InstrCallStack TypeCheckNoExcept (TypeCheckedSeq inp)
-> TypeCheckNoExcept (TypeCheckedSeq inp)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT InstrCallStack
forall a. Default a => a
def (ReaderT InstrCallStack TypeCheckNoExcept (TypeCheckedSeq inp)
 -> TypeCheckNoExcept (TypeCheckedSeq inp))
-> ([ExpandedOp]
    -> HST inp
    -> ReaderT InstrCallStack 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 InstrCallStack 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 @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 :: Value -> TypeCheckInstr (Value t)
typeCheckValue = Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl @t Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr

typeVerifyParameter
  :: SingI t
  => TcOriginatedContracts -> U.Value -> TypeCheckResult (Value t)
typeVerifyParameter :: 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 :: 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 :: 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, (SingKind T, SingI t) => Demote T
forall k (a :: k). (SingKind k, SingI a) => Demote k
demote @t)) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$ InstrCallStack
-> ReaderT InstrCallStack TypeCheck (Value t)
-> TypeCheck (Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT InstrCallStack
forall a. Default a => a
def (ReaderT InstrCallStack TypeCheck (Value t) -> TypeCheck (Value t))
-> ReaderT InstrCallStack TypeCheck (Value t)
-> TypeCheck (Value t)
forall a b. (a -> b) -> a -> b
$
    Maybe TcOriginatedContracts
-> TcInstrHandler
-> Value
-> ReaderT InstrCallStack TypeCheck (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
$ \(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
<$> Maybe TcOriginatedContracts
-> Value -> ReaderT TypeCheckOptions (Except TCError) (Value a)
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 :: 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 `lift ... typeCheckListNoExcept`.
tcList
  :: (SingI inp)
  => [U.ExpandedOp] -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList :: [ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
ops HST inp
stack = ReaderT TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> ReaderT
     TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ [ExpandedOp]
-> HST inp
-> ReaderT
     TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept [ExpandedOp]
ops HST inp
stack

-- | Function @typeCheckInstr@ converts a single Michelson instruction
-- given in representation from @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 neccessary.
--
-- 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 :: ExpandedInstr
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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) (s :: [T]). Instr (a : s) s
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) (s :: [T]).
(RequireLongerOrSameLength s n, NFData (Sing n)) =>
PeanoNatural n -> Instr s (Drop n s)
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 :: Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go = ((Word, HST inp) -> TypeCheckInstr (TCDropHelper inp))
-> Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
0, HST inp
i) -> TCDropHelper inp -> TypeCheckInstr (TCDropHelper inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDropHelper inp
forall (a :: Peano) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp a, Drop a inp ~ out) =>
PeanoNatural a -> HST out -> TCDropHelper inp
TCDropHelper PeanoNatural 'Z
forall (n :: Peano). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)

        (Word
_, HST inp
SNil) -> TypeCheckInstr (TCDropHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

        (Word
n, ((Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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)
-> TypeCheckInstr (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 (a :: Peano) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp a, Drop a inp ~ out) =>
PeanoNatural a -> 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 :: (Notes x, Dict (WellTyped x), VarAnn)
a@(Notes x
n :: Notes t, Dict (WellTyped x)
d, VarAnn
_vn2) ::& 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 <-
      ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (DupableScope x))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
      CheckScope (DupableScope x) =>
Either BadTypeForScope (Dict (DupableScope x))
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
:/ Instr (x : xs) (x : x : xs)
forall (a :: T) (n :: [T]).
DupableScope a =>
Instr (a : n) (a : a : n)
DUP 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
::: ((Notes x
n, Dict (WellTyped x)
d, VarAnn
vn1) (Notes x, Dict (WellTyped x), VarAnn)
-> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes x, Dict (WellTyped x), VarAnn)
a (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ PeanoNatural n -> Instr inp out
forall (n :: Peano) (inp :: [T]) (out :: [T]) (a :: T).
(ConstraintDUPN n inp out a, DupableScope a, NFData (Sing n)) =>
PeanoNatural n -> Instr inp out
DUPN 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 :: Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go = ((Word, HST inp) -> TypeCheckInstr (TCDupNHelper inp))
-> Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
        (Word
_, HST inp
SNil) -> TypeCheckInstr (TCDupNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

        (Word
0, HST inp
_) ->
          ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> TypeCheckInstr (TCDupNHelper inp)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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@((Notes x
an :: Notes a, Dict (WellTyped x)
dict, VarAnn
_) ::& HST xs
_)) -> do
          Dict (DupableScope x)
Dict <-
            ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (DupableScope x))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
            CheckScope (DupableScope x) =>
Either BadTypeForScope (Dict (DupableScope x))
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope a)
          TCDupNHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (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]) (a :: T).
(SingI out, ConstraintDUPN n inp out a, DupableScope a) =>
PeanoNatural n -> HST out -> TCDupNHelper inp
TCDupNHelper PeanoNatural ('S 'Z)
forall (n :: Peano). (n ~ 'S 'Z) => PeanoNatural n
One ((Notes x
an, Dict (WellTyped x)
dict, VarAnn
vn) (Notes x, Dict (WellTyped x), VarAnn) -> HST inp -> HST (x : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
i))

        (Word
n, ((Notes x, Dict (WellTyped x), VarAnn)
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)
-> TypeCheckInstr (TCDupNHelper inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper s :: PeanoNatural n
s@(Succ PeanoNatural m
_) ((Notes x, Dict (WellTyped x), VarAnn)
a ::& HST xs
resTail)) ->
            PeanoNatural ('S ('S (Decrement n)))
-> HST (x : x : xs) -> TCDupNHelper (x : xs)
forall (n :: Peano) (inp :: [T]) (out :: [T]) (a :: T).
(SingI out, ConstraintDUPN n inp out a, DupableScope a) =>
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) ((Notes x, Dict (WellTyped x), VarAnn)
a (Notes x, Dict (WellTyped x), VarAnn)
-> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes x, Dict (WellTyped x), VarAnn)
b (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
resTail)

  (ExpandedInstr
U.SWAP, (Notes x, Dict (WellTyped x), VarAnn)
a ::& (Notes x, Dict (WellTyped x), VarAnn)
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
::: ((Notes x, Dict (WellTyped x), VarAnn)
b (Notes x, Dict (WellTyped x), VarAnn)
-> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes x, Dict (WellTyped x), VarAnn)
a (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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]) (n :: T).
(ConstraintDIG n inp out n, NFData (Sing n)) =>
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 :: 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@((Notes x, Dict (WellTyped x), VarAnn)
_ ::& HST xs
_)) -> TCDigHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (TCDigHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDigHelper (x : xs)
forall (a :: Peano) (inp :: [T]) (out :: [T]) (a :: T).
(SingI out, ConstraintDIG a inp out a) =>
PeanoNatural a -> HST out -> TCDigHelper inp
TCDigHelper PeanoNatural 'Z
forall (n :: Peano). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)

        (Word
n, ((Notes x, Dict (WellTyped x), VarAnn)
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 InstrCallStack TypeCheck (TCDigHelper (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDigHelper PeanoNatural n
s ((Notes x, Dict (WellTyped x), VarAnn)
a ::& HST xs
resTail)) ->
            PeanoNatural ('S n) -> HST (x : x : xs) -> TCDigHelper (x : xs)
forall (a :: Peano) (inp :: [T]) (out :: [T]) (a :: T).
(SingI out, ConstraintDIG a inp out a) =>
PeanoNatural a -> 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) ((Notes x, Dict (WellTyped x), VarAnn)
a (Notes x, Dict (WellTyped x), VarAnn)
-> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes x, Dict (WellTyped x), VarAnn)
b (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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]) (t :: T).
(ConstraintDUG n inp out t, NFData (Sing n)) =>
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 :: 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@((Notes x, Dict (WellTyped x), VarAnn)
_ ::& HST xs
_)) -> TCDugHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (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]) (a :: T).
(SingI out, ConstraintDUG n inp out a) =>
PeanoNatural n -> HST out -> TCDugHelper inp
TCDugHelper PeanoNatural 'Z
forall (n :: Peano). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)

        (Word
n, ((Notes x, Dict (WellTyped x), VarAnn)
a ::& (Notes x, Dict (WellTyped x), VarAnn)
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) ((Notes x, Dict (WellTyped x), VarAnn)
a (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
iTail) TypeCheckInstr (TCDugHelper (x : xs))
-> (TCDugHelper (x : xs) -> TCDugHelper (x : x : xs))
-> ReaderT InstrCallStack TypeCheck (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]) (a :: T).
(SingI out, ConstraintDUG n inp out a) =>
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) ((Notes x, Dict (WellTyped x), VarAnn)
b (Notes x, Dict (WellTyped x), VarAnn) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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 <- Value -> TypeCheckInstr (Value t)
forall (t :: T). SingI t => Value -> TypeCheckInstr (Value t)
typeCheckValue @t Value
mval
      Dict (ConstantScope t)
proofScope <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (ConstantScope t))
-> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope t))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (ConstantScope t)))
-> Either BadTypeForScope (Dict (ConstantScope t))
-> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope t))
forall a b. (a -> b) -> a -> b
$ CheckScope (ConstantScope t) =>
Either BadTypeForScope (Dict (ConstantScope t))
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope t)
      case Dict (ConstantScope t)
proofScope of
        Dict (ConstantScope t)
Dict -> forall a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
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
:/ Value t -> Instr inp (t : inp)
forall (t :: T) (s :: [T]).
ConstantScope t =>
Value' Instr t -> Instr s (t : s)
PUSH 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
nt, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes t, Dict (WellTyped t), VarAnn) -> HST inp -> HST (t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.SOME TypeAnn
tn VarAnn
vn, (Notes x
an, Dict (WellTyped x)
Dict, VarAnn
_) ::& 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 : xs) ('TOption x : xs)
forall (a :: T) (a :: [T]). Instr (a : a) ('TOption a : a)
SOME 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
::: ((TypeAnn -> Notes x -> Notes ('TOption x)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
tn Notes x
an, Dict (WellTyped ('TOption x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption x), Dict (WellTyped ('TOption x)), VarAnn)
-> HST xs -> HST ('TOption x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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 a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
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
:/ Instr inp ('TOption t : inp)
forall (a :: T) (s :: [T]). SingI a => Instr s ('TOption a : s)
NONE 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
::: ((TypeAnn -> Notes t -> Notes ('TOption t)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
tn Notes t
elNotes, Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption t), Dict (WellTyped ('TOption t)), VarAnn)
-> HST inp -> HST ('TOption t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ Instr inp ('TUnit : inp)
forall (s :: [T]). Instr s ('TUnit : s)
UNIT Instr inp ('TUnit : inp) -> HST ('TUnit : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((TypeAnn -> Notes 'TUnit
NTUnit TypeAnn
tn, Dict (WellTyped 'TUnit)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TUnit, Dict (WellTyped 'TUnit), VarAnn)
-> HST inp -> HST ('TUnit : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
inp)

  (U.IF_NONE [ExpandedOp]
mp [ExpandedOp]
mq, (STOption{}, (ons :: Notes ('TOption a)), Dict (WellTyped x)
Dict, VarAnn
ovn) ::&+ HST xs
rs) -> do
    let (Notes n
an, VarAnn
avn) = Notes ('TOption n) -> VarAnn -> (Notes n, VarAnn)
forall (a :: T). Notes ('TOption a) -> VarAnn -> (Notes a, VarAnn)
deriveNsOption Notes ('TOption n)
ons VarAnn
ovn
    forall (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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]) (s' :: [T]) (a :: T).
Instr s s' -> Instr (a : s) s' -> Instr ('TOption a : s) s'
IF_NONE forall op. [op] -> [op] -> InstrAbstract op
U.IF_NONE [ExpandedOp]
mp [ExpandedOp]
mq HST xs
rs ((Notes n
an, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
avn) (Notes n, Dict (WellTyped n), VarAnn) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs) HST inp
HST ('TOption n : xs)
inp

  (U.IF_NONE [ExpandedOp]
_ [ExpandedOp]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Notes x
an :: Notes a, Dict (WellTyped x)
_, VarAnn
avn) ::& (Notes x
bn :: Notes b, Dict (WellTyped x)
_, VarAnn
bvn) ::& 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
    let (VarAnn
vn', RootAnn
pfn', RootAnn
qfn') = RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> VarAnn
-> (VarAnn, RootAnn, RootAnn)
deriveSpecialFNs RootAnn
pfn RootAnn
qfn VarAnn
avn VarAnn
bvn VarAnn
vn
    forall a.
SingI ('TPair x x) =>
(WellTyped ('TPair x x) => TypeCheckInstr a) -> TypeCheckInstr a
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
:/ TypeAnn
-> RootAnn -> RootAnn -> Instr (x : x : xs) ('TPair x x : xs)
forall (a :: T) (b :: T) (s :: [T]).
TypeAnn -> RootAnn -> RootAnn -> Instr (a : b : s) ('TPair a b : s)
AnnPAIR TypeAnn
tn 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
::: ((TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes x
-> Notes x
-> Notes ('TPair x x)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
tn RootAnn
pfn' RootAnn
qfn' VarAnn
avn VarAnn
bvn Notes x
an Notes x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn') (Notes ('TPair x x), Dict (WellTyped ('TPair x x)), VarAnn)
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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, (NTPair TypeAnn
_ RootAnn
fn1 RootAnn
fn2 VarAnn
vn1 VarAnn
vn2 Notes p
n1 Notes q
n2, Dict (WellTyped x)
Dict, VarAnn
vn) ::& 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
      -- We purposefully ignore the result of `convergeDestrAnns` here.
      -- We're only interested in checking that the instruction's field ann matches the pair's field ann,
      -- we don't need to "unify" them.
      RootAnn
_ <- ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError RootAnn
-> ReaderT InstrCallStack TypeCheck RootAnn
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
UnpairArgument) (RootAnn -> RootAnn -> Either AnnConvergeError RootAnn
convergeDestrAnns RootAnn
fn1 RootAnn
instrFn1)
      RootAnn
_ <- ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError RootAnn
-> ReaderT InstrCallStack TypeCheck RootAnn
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
UnpairArgument) (RootAnn -> RootAnn -> Either AnnConvergeError RootAnn
convergeDestrAnns RootAnn
fn2 RootAnn
instrFn2)

      let vn1' :: VarAnn
vn1' = VarAnn -> RootAnn -> VarAnn -> VarAnn -> VarAnn
deriveSpecialVN VarAnn
instrVn1 RootAnn
fn1 VarAnn
vn VarAnn
vn1
      let vn2' :: VarAnn
vn2' = VarAnn -> RootAnn -> VarAnn -> VarAnn -> VarAnn
deriveSpecialVN VarAnn
instrVn2 RootAnn
fn2 VarAnn
vn VarAnn
vn2
      pure $
        HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ VarAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Instr ('TPair p q : xs) (p : q : xs)
forall (a :: T) (b :: T) (s :: [T]).
VarAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Instr ('TPair a b : s) (a : b : s)
AnnUNPAIR VarAnn
instrVn1 VarAnn
instrVn2 RootAnn
instrFn1 RootAnn
instrFn2 Instr ('TPair p q : xs) (p : q : xs)
-> HST (p : q : xs) -> SomeInstrOut ('TPair p q : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
:::
          ( (Notes p
n1, Dict (WellTyped p)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn1') (Notes p, Dict (WellTyped p), VarAnn)
-> HST (q : xs) -> HST (p : q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::&
            (Notes q
n2, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn2') (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::&
            HST xs
rs
          )

  (U.UNPAIR {}, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:/ PeanoNatural n -> Instr inp (PairN n inp)
forall (n :: Peano) (inp :: [T]).
ConstraintPairN n inp =>
PeanoNatural n -> Instr inp (PairN n inp)
PAIRN 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) -> HST (PairN n inp)
forall (a :: T) (inp :: [T]). HST (a : inp) -> HST (a : inp)
addVarAnn HST (PairN n inp)
out
    where
      go :: forall inp. Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
      go :: 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
-> TypeCheckInstr (TCPairNHelper inp)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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
              (Notes x
an :: Notes a, Dict (WellTyped x)
_, VarAnn
_) ::& (Notes x
bn :: Notes b, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
hstTail -> do
                forall a.
SingI ('TPair x x) =>
(WellTyped ('TPair x x) => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) => TypeCheckInstr (TCPairNHelper inp))
 -> TypeCheckInstr (TCPairNHelper inp))
-> (WellTyped ('TPair x x) => TypeCheckInstr (TCPairNHelper inp))
-> TypeCheckInstr (TCPairNHelper inp)
forall a b. (a -> b) -> a -> b
$ do
                  TCPairNHelper (x : x : xs)
-> ReaderT InstrCallStack TypeCheck (TCPairNHelper (x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : xs)
 -> ReaderT InstrCallStack TypeCheck (TCPairNHelper (x : x : xs)))
-> TCPairNHelper (x : x : xs)
-> ReaderT InstrCallStack TypeCheck (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
$
                    (Notes x -> Notes x -> Notes ('TPair x x)
forall (a :: T) (b :: T). Notes a -> Notes b -> Notes ('TPair a b)
mkNotes Notes x
an Notes x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall k (tag :: k). Annotation tag
U.noAnn) (Notes ('TPair x x), Dict (WellTyped ('TPair x x)), VarAnn)
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
hstTail
              HST inp
_ -> TypeCheckInstr (TCPairNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
        | Bool
otherwise =
            case HST inp
hst of
              (Notes x
an :: Notes a, Dict (WellTyped x)
_, VarAnn
_) ::& hstTail :: HST xs
hstTail@((Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 -> TypeCheckInstr (TCPairNHelper inp))
-> TypeCheckInstr (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
_)) ((Notes x
bn :: Notes b, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
hstTail') -> do
                    forall a.
SingI ('TPair x x) =>
(WellTyped ('TPair x x) => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) => TypeCheckInstr (TCPairNHelper inp))
 -> TypeCheckInstr (TCPairNHelper inp))
-> (WellTyped ('TPair x x) => TypeCheckInstr (TCPairNHelper inp))
-> TypeCheckInstr (TCPairNHelper inp)
forall a b. (a -> b) -> a -> b
$ do
                      TCPairNHelper (x : x : x : xs)
-> ReaderT
     InstrCallStack TypeCheck (TCPairNHelper (x : x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : x : xs)
 -> ReaderT
      InstrCallStack TypeCheck (TCPairNHelper (x : x : x : xs)))
-> TCPairNHelper (x : x : x : xs)
-> ReaderT
     InstrCallStack TypeCheck (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
$
                        (Notes x -> Notes x -> Notes ('TPair x x)
forall (a :: T) (b :: T). Notes a -> Notes b -> Notes ('TPair a b)
mkNotes Notes x
an Notes x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall k (tag :: k). Annotation tag
U.noAnn) (Notes ('TPair x x), Dict (WellTyped ('TPair x x)), VarAnn)
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
hstTail'
              HST inp
_ -> TypeCheckInstr (TCPairNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'

      mkNotes :: forall a b. Notes a -> Notes b -> Notes ('TPair a b)
      mkNotes :: Notes a -> Notes b -> Notes ('TPair a b)
mkNotes Notes a
an Notes b
bn =
        TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes a
-> Notes b
-> Notes ('TPair a b)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn
          RootAnn
forall k (tag :: k). Annotation tag
U.noAnn RootAnn
forall k (tag :: k). Annotation tag
U.noAnn
          VarAnn
forall k (tag :: k). Annotation tag
U.noAnn VarAnn
forall k (tag :: k). Annotation tag
U.noAnn
          Notes a
an Notes b
bn

      -- | If a @PAIR n@ instruction has a variable annotation,
      -- the var annotation should be added ONLY to the top-most @pair@ value.
      --
      -- > /* [ nat : nat : nat ] */ ;
      -- > PAIR @aa 3
      -- > /* [ @aa pair nat nat nat ] */ ;
      addVarAnn :: forall a inp. HST (a ': inp) -> HST (a ': inp)
      addVarAnn :: HST (a : inp) -> HST (a : inp)
addVarAnn = \case
        (Notes x
an, Dict (WellTyped x)
dict, VarAnn
_) ::& HST xs
hstTail -> (Notes x
an, Dict (WellTyped x)
dict, VarAnn
varAnn) (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
hstTail

  (U.UNPAIRN Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
  (U.UNPAIRN Word
nTotal, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 :: 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
-> TypeCheckInstr (TCUnpairNHelper (x : xs))
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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
              (NTPair TypeAnn
_ RootAnn
aFieldAnn RootAnn
bFieldAnn VarAnn
_ VarAnn
_ Notes p
aNotes Notes q
bNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest -> do
                TCUnpairNHelper ('TPair p q : xs)
-> ReaderT
     InstrCallStack TypeCheck (TCUnpairNHelper ('TPair p q : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair p q : xs)
 -> ReaderT
      InstrCallStack TypeCheck (TCUnpairNHelper ('TPair p q : xs)))
-> TCUnpairNHelper ('TPair p q : xs)
-> ReaderT
     InstrCallStack TypeCheck (TCUnpairNHelper ('TPair p q : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S 'Z))
-> HST (UnpairN ('S ('S 'Z)) ('TPair p q) ++ xs)
-> TCUnpairNHelper ('TPair p q : xs)
forall (rest :: Peano) (a :: T) (b :: T) (rest :: [T]).
(SingI (UnpairN rest ('TPair a b) ++ rest),
 ConstraintUnpairN rest ('TPair a b)) =>
PeanoNatural rest
-> HST (UnpairN rest ('TPair a b) ++ rest)
-> TCUnpairNHelper ('TPair a b : rest)
TCUnpairNHelper PeanoNatural ('S ('S 'Z))
forall (n :: Peano). (n ~ 'S ('S 'Z)) => PeanoNatural n
Two (HST (UnpairN ('S ('S 'Z)) ('TPair p q) ++ xs)
 -> TCUnpairNHelper ('TPair p q : xs))
-> HST (UnpairN ('S ('S 'Z)) ('TPair p q) ++ xs)
-> TCUnpairNHelper ('TPair p q : xs)
forall a b. (a -> b) -> a -> b
$
                  (Notes p
aNotes, Dict (WellTyped p)
forall (a :: Constraint). a => Dict a
Dict, RootAnn -> VarAnn
forall k1 k2 (tag1 :: k1) (tag2 :: k2).
Annotation tag1 -> Annotation tag2
convAnn @FieldTag @VarTag RootAnn
aFieldAnn)
                  (Notes p, Dict (WellTyped p), VarAnn)
-> HST (q : xs) -> HST (p : q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes q
bNotes, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, RootAnn -> VarAnn
forall k1 k2 (tag1 :: k1) (tag2 :: k2).
Annotation tag1 -> Annotation tag2
convAnn @FieldTag @VarTag RootAnn
bFieldAnn)
                  (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest
              HST (x : xs)
_ -> TypeCheckInstr (TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr a
unexpectedType
        | Bool
otherwise =
            case HST (x : xs)
hst of
              (NTPair TypeAnn
_ RootAnn
aFieldAnn RootAnn
_ VarAnn
_ VarAnn
_ Notes p
aNotes Notes q
bNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest -> do
                Word -> HST (q : xs) -> TypeCheckInstr (TCUnpairNHelper (q : 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) ((Notes q
bNotes, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall k (tag :: k). Annotation tag
U.noAnn) (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest) TypeCheckInstr (TCUnpairNHelper (q : xs))
-> (TCUnpairNHelper (q : xs)
    -> TypeCheckInstr (TCUnpairNHelper (x : xs)))
-> TypeCheckInstr (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 p ('TPair a b) : xs)
-> ReaderT
     InstrCallStack
     TypeCheck
     (TCUnpairNHelper ('TPair p ('TPair a b) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair p ('TPair a b) : xs)
 -> ReaderT
      InstrCallStack
      TypeCheck
      (TCUnpairNHelper ('TPair p ('TPair a b) : xs)))
-> TCUnpairNHelper ('TPair p ('TPair a b) : xs)
-> ReaderT
     InstrCallStack
     TypeCheck
     (TCUnpairNHelper ('TPair p ('TPair a b) : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S ('S m)))
-> HST (UnpairN ('S ('S ('S m))) ('TPair p ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair p ('TPair a b) : xs)
forall (rest :: Peano) (a :: T) (b :: T) (rest :: [T]).
(SingI (UnpairN rest ('TPair a b) ++ rest),
 ConstraintUnpairN rest ('TPair a b)) =>
PeanoNatural rest
-> HST (UnpairN rest ('TPair a b) ++ rest)
-> TCUnpairNHelper ('TPair a b : rest)
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 p ('TPair a b)) ++ xs)
 -> TCUnpairNHelper ('TPair p ('TPair a b) : xs))
-> HST (UnpairN ('S ('S ('S m))) ('TPair p ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair p ('TPair a b) : xs)
forall a b. (a -> b) -> a -> b
$
                      (Notes p
aNotes, Dict (WellTyped p)
forall (a :: Constraint). a => Dict a
Dict, RootAnn -> VarAnn
forall k1 k2 (tag1 :: k1) (tag2 :: k2).
Annotation tag1 -> Annotation tag2
convAnn @FieldTag @VarTag RootAnn
aFieldAnn) (Notes p, Dict (WellTyped p), VarAnn)
-> HST (UnpairN n ('TPair a b) ++ xs)
-> HST (p : (UnpairN n ('TPair a b) ++ xs))
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST (UnpairN n ('TPair a b) ++ xs)
HST (UnpairN n ('TPair a b) ++ rest)
out
              HST (x : xs)
_ -> TypeCheckInstr (TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr a
unexpectedType

      unexpectedType :: TypeCheckInstr a
      unexpectedType :: 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{}, NTPair TypeAnn
_ RootAnn
pfn RootAnn
_ VarAnn
pvn VarAnn
_ Notes p
pns Notes q
_, Dict (WellTyped x)
Dict, VarAnn
pairVN) ::&+ 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
    -- We purposefully ignore the result of `convergeDestrAnns` here.
    -- We're only interested in checking that the instruction's field ann matches the pair's field ann,
    -- we don't need to "unify" them.
    RootAnn
_ <- ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError RootAnn
-> ReaderT InstrCallStack TypeCheck RootAnn
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
CarArgument) (RootAnn -> RootAnn -> Either AnnConvergeError RootAnn
convergeDestrAnns RootAnn
fn RootAnn
pfn)
    let vn' :: VarAnn
vn' = VarAnn -> RootAnn -> VarAnn -> VarAnn -> VarAnn
deriveSpecialVN VarAnn
vn RootAnn
pfn VarAnn
pairVN VarAnn
pvn
    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
:/ VarAnn -> RootAnn -> Instr ('TPair p n : xs) (p : xs)
forall (a :: T) (b :: T) (s :: [T]).
VarAnn -> RootAnn -> Instr ('TPair a b : s) (a : s)
AnnCAR VarAnn
vn RootAnn
fn Instr ('TPair p n : xs) (p : xs)
-> HST (p : xs) -> SomeInstrOut ('TPair p n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes p
pns, Dict (WellTyped p)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn') (Notes p, Dict (WellTyped p), VarAnn) -> HST xs -> HST (p : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CAR VarAnn
_ RootAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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{}, NTPair TypeAnn
_ RootAnn
_ RootAnn
qfn VarAnn
_ VarAnn
qvn Notes p
_ Notes q
qns, Dict (WellTyped x)
Dict, VarAnn
pairVN) ::&+ 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
    -- We purposefully ignore the result of `convergeDestrAnns` here.
    -- We're only interested in checking that the instruction's field ann matches the pair's field ann,
    -- we don't need to "unify" them.
    RootAnn
_ <- ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError RootAnn
-> ReaderT InstrCallStack TypeCheck RootAnn
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
CdrArgument) (RootAnn -> RootAnn -> Either AnnConvergeError RootAnn
convergeDestrAnns RootAnn
fn RootAnn
qfn)
    let vn' :: VarAnn
vn' = VarAnn -> RootAnn -> VarAnn -> VarAnn -> VarAnn
deriveSpecialVN VarAnn
vn RootAnn
qfn VarAnn
pairVN VarAnn
qvn
    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
:/ VarAnn -> RootAnn -> Instr ('TPair n q : xs) (q : xs)
forall (a :: T) (b :: T) (s :: [T]).
VarAnn -> RootAnn -> Instr ('TPair a b : s) (b : s)
AnnCDR VarAnn
vn RootAnn
fn Instr ('TPair n q : xs) (q : xs)
-> HST (q : xs) -> SomeInstrOut ('TPair n q : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes q
qns, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn') (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.CDR VarAnn
_ RootAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Notes x
an :: Notes l, Dict (WellTyped x)
Dict, VarAnn
avn) ::& 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
      let (VarAnn
vn', RootAnn
pfn', RootAnn
qfn') = RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> VarAnn
-> (VarAnn, RootAnn, RootAnn)
deriveSpecialFNs RootAnn
pfn RootAnn
qfn VarAnn
avn VarAnn
forall k (tag :: k). Annotation tag
U.noAnn VarAnn
vn
      forall a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
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 :: Notes ('TOr x t)
ns = TypeAnn
-> RootAnn -> RootAnn -> Notes x -> Notes t -> Notes ('TOr x t)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn -> RootAnn -> Notes p -> Notes p -> Notes ('TOr p p)
NTOr TypeAnn
tn RootAnn
pfn' RootAnn
qfn' Notes x
an 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
:/ TypeAnn -> RootAnn -> RootAnn -> Instr (x : xs) ('TOr x t : xs)
forall (b :: T) (a :: T) (s :: [T]).
SingI b =>
TypeAnn -> RootAnn -> RootAnn -> Instr (a : s) ('TOr a b : s)
AnnLEFT TypeAnn
tn RootAnn
pfn RootAnn
qfn 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
::: ((Notes ('TOr x t)
ns, Dict (WellTyped ('TOr x t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn') (Notes ('TOr x t), Dict (WellTyped ('TOr x t)), VarAnn)
-> HST xs -> HST ('TOr x t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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, (Notes x
bn :: Notes r, Dict (WellTyped x)
Dict, VarAnn
bvn) ::& 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
      let (VarAnn
vn', RootAnn
pfn', RootAnn
qfn') = RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> VarAnn
-> (VarAnn, RootAnn, RootAnn)
deriveSpecialFNs RootAnn
pfn RootAnn
qfn VarAnn
forall k (tag :: k). Annotation tag
U.noAnn VarAnn
bvn VarAnn
vn
      forall a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
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 :: Notes ('TOr t x)
ns = TypeAnn
-> RootAnn -> RootAnn -> Notes t -> Notes x -> Notes ('TOr t x)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn -> RootAnn -> Notes p -> Notes p -> Notes ('TOr p p)
NTOr TypeAnn
tn RootAnn
pfn' RootAnn
qfn' Notes t
an Notes 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
:/ TypeAnn -> RootAnn -> RootAnn -> Instr (x : xs) ('TOr t x : xs)
forall (a :: T) (b :: T) (s :: [T]).
SingI a =>
TypeAnn -> RootAnn -> RootAnn -> Instr (b : s) ('TOr a b : s)
AnnRIGHT TypeAnn
tn RootAnn
pfn RootAnn
qfn 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
::: ((Notes ('TOr t x)
ns, Dict (WellTyped ('TOr t x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn') (Notes ('TOr t x), Dict (WellTyped ('TOr t x)), VarAnn)
-> HST xs -> HST ('TOr t x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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 lt rt, Notes x
ons, Dict (WellTyped x)
_, VarAnn
ovn) ::&+ HST xs
rs) -> do
    case Notes ('TOr n n) -> VarAnn -> (Notes n, Notes n, VarAnn, VarAnn)
forall (a :: T) (b :: T).
Notes ('TOr a b) -> VarAnn -> (Notes a, Notes b, VarAnn, VarAnn)
deriveNsOr Notes x
Notes ('TOr n n)
ons VarAnn
ovn of
      (Notes n
an :: Notes a, Notes n
bn :: Notes b, VarAnn
avn, VarAnn
bvn) -> Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
lt ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
rt ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
        forall (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @a ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs))
forall a b. (a -> b) -> a -> b
$
          forall (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @b ((WellTyped n =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs)))
-> (WellTyped n =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n n : xs))
forall a b. (a -> b) -> a -> b
$ do
            let
              ait :: HST (n : xs)
ait = (Notes n
an, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
avn) (Notes n, Dict (WellTyped n), VarAnn) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs
              bit :: HST (n : xs)
bit = (Notes n
bn, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
bvn) (Notes n, Dict (WellTyped n), VarAnn) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs
            (forall (s' :: [T]).
 Instr (n : xs) s' -> Instr (n : xs) s' -> Instr ('TOr n n : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST (n : xs)
-> HST (n : xs)
-> HST ('TOr n n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n 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 : xs) s' -> Instr (n : xs) s' -> Instr ('TOr n n : xs) s'
forall (a :: T) (s :: [T]) (s' :: [T]) (b :: T).
Instr (a : s) s' -> Instr (b : s) s' -> Instr ('TOr a b : s) s'
IF_LEFT forall op. [op] -> [op] -> InstrAbstract op
U.IF_LEFT [ExpandedOp]
mp [ExpandedOp]
mq HST (n : xs)
ait HST (n : xs)
bit HST inp
HST ('TOr n n : xs)
inp

  (U.IF_LEFT [ExpandedOp]
_ [ExpandedOp]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 a.
SingI ('TList t) =>
(WellTyped ('TList t) => TypeCheckInstr a) -> TypeCheckInstr a
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
:/ Instr inp ('TList t : inp)
forall (p :: T) (s :: [T]). SingI p => Instr s ('TList p : s)
NIL 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
::: ((TypeAnn -> Notes t -> Notes ('TList t)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TList t)
NTList TypeAnn
tn Notes t
elNotes, Dict (WellTyped ('TList t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TList t), Dict (WellTyped ('TList t)), VarAnn)
-> HST inp -> HST ('TList t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
i)

  (U.CONS VarAnn
vn, ((Notes x
an :: Notes a), Dict (WellTyped x)
_, VarAnn
_)
                ::& ((Notes x
ln :: Notes l), Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr
    case Each '[SingI] '[ 'TList x, x] =>
Either TCTypeError ('TList x :~: x)
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @('TList a) @l of
      Right 'TList x :~: x
Refl -> do
        (Notes x
n :: Notes t) <- ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError (Notes x)
-> ReaderT InstrCallStack TypeCheck (Notes x)
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ConsArgument) (Notes x -> Notes x -> Either AnnConvergeError (Notes x)
forall (t :: T).
Notes t -> Notes t -> Either AnnConvergeError (Notes t)
converge Notes x
ln (TypeAnn -> Notes x -> Notes ('TList x)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TList t)
NTList TypeAnn
forall a. Default a => a
def Notes x
an))
        forall a.
SingI x =>
(WellTyped x => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped x => TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstr (SomeInstr inp))
-> (WellTyped 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
:/ Instr (x : 'TList x : xs) ('TList x : xs)
forall (a :: T) (a :: [T]). Instr (a : 'TList a : a) ('TList a : a)
CONS 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
::: ((Notes x
n, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
      Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> TypeCheckInstr (SomeInstr inp)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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, (STList{}, Notes x
ns, Dict (WellTyped x)
Dict, VarAnn
vn) ::&+ HST xs
rs) -> do
    case Notes x
ns of
      NTList TypeAnn
_ (Notes t
an :: Notes t1) -> forall (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
        let ait :: HST (t : x : xs)
ait = (Notes t
an, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes t, Dict (WellTyped t), VarAnn)
-> HST (x : xs) -> HST (t : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes x
ns, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs
        (forall (s' :: [T]).
 Instr (t : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST (t : 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 (t : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s'
forall (a :: T) (s :: [T]) (s' :: [T]).
Instr (a : 'TList a : s) s'
-> Instr s s' -> Instr ('TList a : s) s'
IF_CONS forall op. [op] -> [op] -> InstrAbstract op
U.IF_CONS [ExpandedOp]
mp [ExpandedOp]
mq HST (t : x : xs)
ait HST xs
rs HST inp
HST ('TList n : xs)
inp

  (U.IF_CONS [ExpandedOp]
_ [ExpandedOp]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTList{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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, (NTSet{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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, (NTMap{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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, (NTString{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 a.
SingI ('TSet t) =>
(WellTyped ('TSet t) => TypeCheckInstr a) -> TypeCheckInstr a
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 InstrCallStack m, MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). SingI 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
:/ Instr inp ('TSet t : inp)
forall (e :: T) (s :: [T]).
(SingI e, Comparable e) =>
Instr s ('TSet e : s)
EMPTY_SET 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 Sing t
forall k (a :: k). SingI a => Sing a
sing, TypeAnn -> Notes t -> Notes ('TSet t)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TSet t)
NTSet TypeAnn
tn Notes t
vns, Dict (WellTyped ('TSet t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Sing ('TSet t), Notes ('TSet t), Dict (WellTyped ('TSet t)),
 VarAnn)
-> HST inp -> HST ('TSet t : inp)
forall (ys :: [T]) (x :: T) (xs :: [T]).
(ys ~ (x : xs), SingI x, SingI xs) =>
(Sing x, Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST ys
::&+ 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 a.
SingI ('TMap t t) =>
(WellTyped ('TMap t t) => TypeCheckInstr a) -> TypeCheckInstr a
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 InstrCallStack m, MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). SingI 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
:/ Instr inp ('TMap t t : inp)
forall (a :: T) (b :: T) (s :: [T]).
(SingI a, SingI b, Comparable a) =>
Instr s ('TMap a b : s)
EMPTY_MAP 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 (n :: T) (n :: T). Sing n -> Sing n -> SingT ('TMap n n)
STMap Sing t
forall k (a :: k). SingI a => Sing a
sing Sing t
forall k (a :: k). SingI a => Sing a
sing, TypeAnn -> Notes t -> Notes t -> Notes ('TMap t t)
forall (q :: T) (k :: T).
TypeAnn -> Notes q -> Notes k -> Notes ('TMap q k)
NTMap TypeAnn
tn Notes t
ktn Notes t
vns, Dict (WellTyped ('TMap t t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Sing ('TMap t t), Notes ('TMap t t), Dict (WellTyped ('TMap t t)),
 VarAnn)
-> HST inp -> HST ('TMap t t : inp)
forall (ys :: [T]) (x :: T) (xs :: [T]).
(ys ~ (x : xs), SingI x, SingI xs) =>
(Sing x, Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST ys
::&+ 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 a.
SingI ('TBigMap t t) =>
(WellTyped ('TBigMap t t) => TypeCheckInstr a) -> TypeCheckInstr a
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 InstrCallStack m, MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). SingI 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
:/ Instr inp ('TBigMap t t : inp)
forall (a :: T) (b :: T) (s :: [T]).
(SingI a, SingI b, Comparable a, HasNoBigMap b) =>
Instr s ('TBigMap a b : s)
EMPTY_BIG_MAP 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 (n :: T) (n :: T). Sing n -> Sing n -> SingT ('TBigMap n n)
STBigMap Sing t
forall k (a :: k). SingI a => Sing a
sing Sing t
forall k (a :: k). SingI a => Sing a
sing, TypeAnn -> Notes t -> Notes t -> Notes ('TBigMap t t)
forall (k :: T) (v :: T).
TypeAnn -> Notes k -> Notes v -> Notes ('TBigMap k v)
NTBigMap TypeAnn
tn Notes t
ktn Notes t
vns, Dict (WellTyped ('TBigMap t t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Sing ('TBigMap t t), Notes ('TBigMap t t),
 Dict (WellTyped ('TBigMap t t)), VarAnn)
-> HST inp -> HST ('TBigMap t t : inp)
forall (ys :: [T]) (x :: T) (xs :: [T]).
(ys ~ (x : xs), SingI x, SingI xs) =>
(Sing x, Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST ys
::&+ HST inp
i)

  (U.MAP VarAnn
vn [ExpandedOp]
mp, (STList l, NTList TypeAnn
_ (Notes t
vns :: Notes t1), Dict (WellTyped x)
Dict, VarAnn
_vn) ::&+ 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 (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped t =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped t =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$
      ([TypeCheckedOp] -> TypeCheckedInstr)
-> Notes (MapOpInp ('TList n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TList n : xs)
-> (forall (v' :: T).
    SingI v' =>
    Notes 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)
-> Notes (MapOpInp c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    Notes 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) Notes t
Notes (MapOpInp ('TList n))
vns ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TList n : xs)
inp
        (\(Notes v'
rn :: Notes t) HST xs
hst -> forall a.
SingI v' =>
(WellTyped v' => TypeCheckInstr a) -> TypeCheckInstr a
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
$ (TypeAnn -> Notes v' -> Notes ('TList v')
forall (t :: T). TypeAnn -> Notes t -> Notes ('TList t)
NTList TypeAnn
forall a. Default a => a
def Notes v'
rn, Dict (WellTyped ('TList v'))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TList v'), Dict (WellTyped ('TList v')), VarAnn)
-> HST xs -> HST ('TList v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
hst)

  (U.MAP VarAnn
vn [ExpandedOp]
mp, (STMap k v, NTMap TypeAnn
_ Notes k
kns Notes v
vns, Dict (WellTyped x)
Dict, VarAnn
_vn) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
    case TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes k
-> Notes v
-> Notes ('TPair k v)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def VarAnn
forall a. Default a => a
def VarAnn
forall a. Default a => a
def Notes k
kns Notes v
vns of
      (Notes ('TPair k v)
pns :: Notes ('TPair k v1)) ->
        forall (inp :: [T]).
SingI ('TPair k v) =>
(WellTyped ('TPair k v) =>
 TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @('TPair k v1) ((WellTyped ('TPair k v) =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs)))
-> (WellTyped ('TPair k v) =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs))
forall a b. (a -> b) -> a -> b
$
          ([TypeCheckedOp] -> TypeCheckedInstr)
-> Notes (MapOpInp ('TMap n n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TMap n n : xs)
-> (forall (v' :: T).
    SingI v' =>
    Notes v'
    -> HST xs -> TypeCheckInstr (HST (MapOpRes ('TMap n n) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingI1 (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> Notes (MapOpInp c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    Notes 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) Notes ('TPair k v)
Notes (MapOpInp ('TMap n n))
pns ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TMap n n : xs)
inp
             (\(Notes v'
rn :: Notes v) HST xs
hst -> forall a.
SingI ('TMap k v') =>
(WellTyped ('TMap k v') => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TMap k v) ((WellTyped ('TMap k v') => TypeCheckInstr (HST ('TMap n v' : xs)))
 -> TypeCheckInstr (HST ('TMap n v' : xs)))
-> (WellTyped ('TMap k v') =>
    TypeCheckInstr (HST ('TMap n v' : xs)))
-> TypeCheckInstr (HST ('TMap n v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TMap k v' : xs)
-> ReaderT InstrCallStack TypeCheck (HST ('TMap k v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TMap k v' : xs)
 -> ReaderT InstrCallStack TypeCheck (HST ('TMap k v' : xs)))
-> HST ('TMap k v' : xs)
-> ReaderT InstrCallStack TypeCheck (HST ('TMap k v' : xs))
forall a b. (a -> b) -> a -> b
$ (TypeAnn -> Notes k -> Notes v' -> Notes ('TMap k v')
forall (q :: T) (k :: T).
TypeAnn -> Notes q -> Notes k -> Notes ('TMap q k)
NTMap TypeAnn
forall a. Default a => a
def Notes k
kns Notes v'
rn, Dict (WellTyped ('TMap k v'))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TMap k v'), Dict (WellTyped ('TMap k v')), VarAnn)
-> HST xs -> HST ('TMap k v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
hst)

  (U.MAP VarAnn
_ [ExpandedOp]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:| [])
      ]

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

  (U.ITER [ExpandedOp]
is, (STSet (s :: Sing t1), NTSet TypeAnn
_ Notes t
en, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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
$
      Notes (IterOpEl ('TSet n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TSet n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
Notes (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Notes t
Notes (IterOpEl ('TSet n))
en ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TSet n : xs)
inp

  (U.ITER [ExpandedOp]
is, (STList (l :: Sing t1), NTList TypeAnn
_ Notes t
en, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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
$
      Notes (IterOpEl ('TList n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TList n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
Notes (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Notes t
Notes (IterOpEl ('TList n))
en ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TList n : xs)
inp

  (U.ITER [ExpandedOp]
is, (STMap k v, NTMap TypeAnn
_ Notes k
kns Notes v
vns, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
    case TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes k
-> Notes v
-> Notes ('TPair k v)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def RootAnn
forall a. Default a => a
def VarAnn
forall a. Default a => a
def VarAnn
forall a. Default a => a
def Notes k
kns Notes v
vns of
      (Notes ('TPair k v)
en :: Notes ('TPair a b)) ->
        forall (inp :: [T]).
SingI ('TPair k v) =>
(WellTyped ('TPair k v) =>
 TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @('TPair a b) ((WellTyped ('TPair k v) =>
  TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs)))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs)))
-> (WellTyped ('TPair k v) =>
    TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs))
forall a b. (a -> b) -> a -> b
$ Notes (IterOpEl ('TMap n n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TMap n n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
Notes (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Notes ('TPair k v)
Notes (IterOpEl ('TMap n n))
en ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TMap n n : xs)
inp

  (U.ITER [ExpandedOp]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STSet s, NTSet TypeAnn
_ Notes t
notesK, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
    Notes (MemOpKey ('TSet n))
-> 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 InstrCallStack m, MonadError TCError m) =>
Notes (MemOpKey c) -> HST inp -> VarAnn -> m (SomeInstr inp)
memImpl Notes t
Notes (MemOpKey ('TSet n))
notesK HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
varNotes,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STMap k v, NTMap TypeAnn
_ Notes k
notesK Notes v
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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
$
    Notes (MemOpKey ('TMap n n))
-> 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 InstrCallStack m, MonadError TCError m) =>
Notes (MemOpKey c) -> HST inp -> VarAnn -> m (SomeInstr inp)
memImpl Notes k
Notes (MemOpKey ('TMap n n))
notesK HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
varNotes,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STBigMap k v, NTBigMap TypeAnn
_ Notes k
notesK Notes v
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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
$
    Notes (MemOpKey ('TBigMap n n))
-> 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 InstrCallStack m, MonadError TCError m) =>
Notes (MemOpKey c) -> HST inp -> VarAnn -> m (SomeInstr inp)
memImpl Notes k
Notes (MemOpKey ('TBigMap n n))
notesK HST inp
inp VarAnn
varNotes
  (U.MEM VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STMap k v, NTMap TypeAnn
_ Notes k
notesK (Notes v
notesV :: Notes v), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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 : 'TMap n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMap n n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n n : xs))
forall a b. (a -> b) -> a -> b
$ forall a.
SingI v =>
(WellTyped v => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped v => TypeCheckInstr (SomeInstr (x : 'TMap n n : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TMap n n : xs)))
-> (WellTyped v => TypeCheckInstr (SomeInstr (x : 'TMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n n : xs))
forall a b. (a -> b) -> a -> b
$
      Notes (GetOpKey ('TMap n n))
-> HST inp
-> Notes (GetOpVal ('TMap n n))
-> 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 InstrCallStack m,
 MonadError TCError m) =>
Notes (GetOpKey c)
-> HST inp -> Notes (GetOpVal c) -> VarAnn -> m (SomeInstr inp)
getImpl Notes k
Notes (GetOpKey ('TMap n n))
notesK HST inp
inp Notes v
Notes (GetOpVal ('TMap n n))
notesV VarAnn
varNotes
  (U.GET VarAnn
varNotes,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STBigMap k v, NTBigMap TypeAnn
_ Notes k
notesK (Notes v
notesV :: Notes v), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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 : 'TBigMap n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TBigMap n n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TBigMap n n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TBigMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TBigMap n n : xs))
forall a b. (a -> b) -> a -> b
$ forall a.
SingI v =>
(WellTyped v => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped v =>
  TypeCheckInstr (SomeInstr (x : 'TBigMap n n : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TBigMap n n : xs)))
-> (WellTyped v =>
    TypeCheckInstr (SomeInstr (x : 'TBigMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n n : xs))
forall a b. (a -> b) -> a -> b
$
      Notes (GetOpKey ('TBigMap n n))
-> HST inp
-> Notes (GetOpVal ('TBigMap n n))
-> 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 InstrCallStack m,
 MonadError TCError m) =>
Notes (GetOpKey c)
-> HST inp -> Notes (GetOpVal c) -> VarAnn -> m (SomeInstr inp)
getImpl Notes k
Notes (GetOpKey ('TBigMap n n))
notesK HST inp
inp Notes v
Notes (GetOpVal ('TBigMap n n))
notesV VarAnn
varNotes

  (U.GET VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:/ PeanoNatural ix -> Instr (x : xs) (GetN ix x : xs)
forall (ix :: Peano) (pair :: T) (s :: [T]).
ConstraintGetN ix pair =>
PeanoNatural ix -> Instr (pair : s) (GetN ix pair : s)
GETN 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 :: Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
0 ((Notes x
a, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> ReaderT InstrCallStack TypeCheck (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z -> HST (GetN 'Z x : xs) -> TCGetNHelper (x : xs)
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)
TCGetNHelper PeanoNatural 'Z
forall (n :: Peano). (n ~ 'Z) => PeanoNatural n
Zero ((Notes x
a, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
getNVarAnn) (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest)
      go Word
1 ((NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ Notes p
leftNotes Notes q
_, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest) =
        TCGetNHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
 -> ReaderT InstrCallStack TypeCheck (TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT InstrCallStack TypeCheck (TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (GetN ('S 'Z) x : xs) -> TCGetNHelper (x : xs)
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)
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
$ (Notes p
leftNotes, Dict (WellTyped p)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
getNVarAnn) (Notes p, Dict (WellTyped p), VarAnn) -> HST xs -> HST (p : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest
      go Word
ix ((NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ Notes p
_ Notes q
rightNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest) =
        Word -> HST (q : xs) -> TypeCheckInstr (TCGetNHelper (q : 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) ((Notes q
rightNotes, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall k (tag :: k). Annotation tag
U.noAnn) (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest) TypeCheckInstr (TCGetNHelper (q : xs))
-> (TCGetNHelper (q : xs) -> TCGetNHelper (x : xs))
-> TypeCheckInstr (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 p q) : rest)
-> TCGetNHelper ('TPair p q : rest)
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)
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 p q) : rest)
out
      go Word
_ HST (x : xs)
_ = TCTypeError -> TypeCheckInstr (TCGetNHelper (x : xs))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr (TCGetNHelper (x : xs)))
-> TCTypeError -> TypeCheckInstr (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,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STMap k v, (NTMap TypeAnn
_ Notes k
notesK (Notes v
notesV :: Notes v)), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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
$ Notes (UpdOpKey ('TMap n n))
-> HST inp
-> Notes (UpdOpParams ('TMap n n))
-> 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 InstrCallStack m,
 MonadError TCError m) =>
Notes (UpdOpKey c)
-> HST inp -> Notes (UpdOpParams c) -> VarAnn -> m (SomeInstr inp)
updImpl Notes k
Notes (UpdOpKey ('TMap n n))
notesK HST inp
inp (TypeAnn -> Notes v -> Notes ('TOption v)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn Notes v
notesV) VarAnn
varAnn
  (U.UPDATE VarAnn
varAnn,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STBigMap k v, NTBigMap TypeAnn
_ Notes k
notesK (Notes v
notesV :: Notes v), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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
$ Notes (UpdOpKey ('TBigMap n n))
-> HST inp
-> Notes (UpdOpParams ('TBigMap n n))
-> 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 InstrCallStack m,
 MonadError TCError m) =>
Notes (UpdOpKey c)
-> HST inp -> Notes (UpdOpParams c) -> VarAnn -> m (SomeInstr inp)
updImpl Notes k
Notes (UpdOpKey ('TBigMap n n))
notesK HST inp
inp (TypeAnn -> Notes v -> Notes ('TOption v)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn Notes v
notesV) VarAnn
varAnn
  (U.UPDATE VarAnn
varAnn,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STSet s, NTSet TypeAnn
_ (Notes t
notesK :: Notes k), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$ Notes (UpdOpKey ('TSet n))
-> HST inp
-> Notes (UpdOpParams ('TSet n))
-> 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 InstrCallStack m,
 MonadError TCError m) =>
Notes (UpdOpKey c)
-> HST inp -> Notes (UpdOpParams c) -> VarAnn -> m (SomeInstr inp)
updImpl Notes t
Notes (UpdOpKey ('TSet n))
notesK HST inp
inp (TypeAnn -> Notes 'TBool
NTBool TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn) VarAnn
varAnn

  (U.UPDATE VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:/ PeanoNatural ix -> Instr (x : x : xs) (UpdateN ix x x : xs)
forall (ix :: Peano) (val :: T) (pair :: T) (s :: [T]).
ConstraintUpdateN ix pair =>
PeanoNatural ix -> Instr (val : pair : s) (UpdateN ix val pair : s)
UPDATEN 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 :: Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go Word
0 ((Notes x
valNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& (Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
rest) =
        TCUpdateNHelper (val : pair : xs)
-> ReaderT
     InstrCallStack TypeCheck (TCUpdateNHelper (val : pair : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : xs)
 -> ReaderT
      InstrCallStack TypeCheck (TCUpdateNHelper (val : pair : xs)))
-> TCUpdateNHelper (val : pair : xs)
-> ReaderT
     InstrCallStack TypeCheck (TCUpdateNHelper (val : pair : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z
-> HST (UpdateN 'Z val pair : xs)
-> TCUpdateNHelper (val : pair : xs)
forall (s' :: Peano) (val :: T) (pair :: T) (rest :: [T]).
(SingI (UpdateN s' val pair : rest), ConstraintUpdateN s' pair) =>
PeanoNatural s'
-> HST (UpdateN s' val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
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
$
          (Notes x
valNotes, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
updateNVarAnn) (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest
      go Word
1 ((Notes x
valNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& (NTPair TypeAnn
pairTA RootAnn
leftFA RootAnn
rightFA VarAnn
leftVA VarAnn
rightVA Notes p
_ Notes q
rightNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest) =
        TCUpdateNHelper (val : pair : xs)
-> ReaderT
     InstrCallStack TypeCheck (TCUpdateNHelper (val : pair : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : xs)
 -> ReaderT
      InstrCallStack TypeCheck (TCUpdateNHelper (val : pair : xs)))
-> TCUpdateNHelper (val : pair : xs)
-> ReaderT
     InstrCallStack TypeCheck (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 (s' :: Peano) (val :: T) (pair :: T) (rest :: [T]).
(SingI (UpdateN s' val pair : rest), ConstraintUpdateN s' pair) =>
PeanoNatural s'
-> HST (UpdateN s' val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
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
$
          (TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes x
-> Notes q
-> Notes ('TPair x q)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
pairTA RootAnn
leftFA RootAnn
rightFA VarAnn
leftVA VarAnn
rightVA Notes x
valNotes Notes q
rightNotes, Dict (WellTyped ('TPair x q))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
updateNVarAnn) (Notes ('TPair x q), Dict (WellTyped ('TPair x q)), VarAnn)
-> HST xs -> HST ('TPair x q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest
      go Word
ix ((Notes x, Dict (WellTyped x), VarAnn)
val ::& (NTPair TypeAnn
pairTA RootAnn
leftFA RootAnn
rightFA VarAnn
leftVA VarAnn
rightVA Notes p
leftNotes Notes q
rightNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
rest) =
        Word
-> HST (x : q : xs)
-> TypeCheckInstr (TCUpdateNHelper (x : q : 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) ((Notes x, Dict (WellTyped x), VarAnn)
val (Notes x, Dict (WellTyped x), VarAnn)
-> HST (q : xs) -> HST (x : q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes q
rightNotes, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall k (tag :: k). Annotation tag
U.noAnn) (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rest) TypeCheckInstr (TCUpdateNHelper (x : q : xs))
-> (TCUpdateNHelper (x : q : xs)
    -> TCUpdateNHelper (val : pair : rest))
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&>
          \(TCUpdateNHelper PeanoNatural ix
ixSing ((Notes x
updatedRightNotes, Dict (WellTyped x)
Dict, VarAnn
_) ::& HST xs
outRest)) ->
            PeanoNatural ('S ('S ix))
-> HST (UpdateN ('S ('S ix)) val ('TPair p q) : xs)
-> TCUpdateNHelper (val : 'TPair p q : xs)
forall (s' :: Peano) (val :: T) (pair :: T) (rest :: [T]).
(SingI (UpdateN s' val pair : rest), ConstraintUpdateN s' pair) =>
PeanoNatural s'
-> HST (UpdateN s' val pair : rest)
-> TCUpdateNHelper (val : pair : rest)
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 p q) : xs)
 -> TCUpdateNHelper (val : 'TPair p q : xs))
-> HST (UpdateN ('S ('S ix)) val ('TPair p q) : xs)
-> TCUpdateNHelper (val : 'TPair p q : xs)
forall a b. (a -> b) -> a -> b
$
              (TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes x
-> Notes ('TPair p x)
forall (p :: T) (p :: T).
TypeAnn
-> RootAnn
-> RootAnn
-> VarAnn
-> VarAnn
-> Notes p
-> Notes p
-> Notes ('TPair p p)
NTPair TypeAnn
pairTA RootAnn
leftFA RootAnn
rightFA VarAnn
leftVA VarAnn
rightVA Notes p
leftNotes Notes x
updatedRightNotes, Dict (WellTyped ('TPair p x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
updateNVarAnn) (Notes ('TPair p x), Dict (WellTyped ('TPair p x)), VarAnn)
-> HST xs -> HST ('TPair p x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
outRest
      go Word
_ HST (val : pair : rest)
_ = TCTypeError -> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
 -> TypeCheckInstr (TCUpdateNHelper (val : pair : rest)))
-> TCTypeError
-> TypeCheckInstr (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,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STMap k v, (NTMap TypeAnn
_ Notes k
notesK (Notes v
notesV :: Notes v)), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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 : x : 'TMap n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TMap n n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TMap n n : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : x : 'TMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TMap n n : xs))
forall a b. (a -> b) -> a -> b
$
      forall a.
SingI v =>
(WellTyped v => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped v =>
  TypeCheckInstr (SomeInstr (x : x : 'TMap n n : xs)))
 -> TypeCheckInstr (SomeInstr (x : x : 'TMap n n : xs)))
-> (WellTyped v =>
    TypeCheckInstr (SomeInstr (x : x : 'TMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n n : xs))
forall a b. (a -> b) -> a -> b
$
        Notes (UpdOpKey ('TMap n n))
-> HST inp
-> Notes (UpdOpParams ('TMap n n))
-> 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 InstrCallStack m, MonadError TCError m) =>
Notes (UpdOpKey c)
-> HST inp -> Notes (UpdOpParams c) -> VarAnn -> m (SomeInstr inp)
getUpdImpl Notes k
Notes (UpdOpKey ('TMap n n))
notesK HST inp
inp (TypeAnn -> Notes v -> Notes ('TOption v)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn Notes v
notesV) VarAnn
varAnn
  (U.GET_AND_UPDATE VarAnn
varAnn,
   (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (STBigMap k v, (NTBigMap TypeAnn
_ Notes k
notesK (Notes v
notesV :: Notes v)), Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
k ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
v ((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 : x : 'TBigMap n n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TBigMap n n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TBigMap n n : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : x : 'TBigMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : x : 'TBigMap n n : xs))
forall a b. (a -> b) -> a -> b
$
      forall a.
SingI v =>
(WellTyped v => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped v =>
  TypeCheckInstr (SomeInstr (x : x : 'TBigMap n n : xs)))
 -> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n n : xs)))
-> (WellTyped v =>
    TypeCheckInstr (SomeInstr (x : x : 'TBigMap n n : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n n : xs))
forall a b. (a -> b) -> a -> b
$
        Notes (UpdOpKey ('TBigMap n n))
-> HST inp
-> Notes (UpdOpParams ('TBigMap n n))
-> 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 InstrCallStack m, MonadError TCError m) =>
Notes (UpdOpKey c)
-> HST inp -> Notes (UpdOpParams c) -> VarAnn -> m (SomeInstr inp)
getUpdImpl Notes k
Notes (UpdOpKey ('TBigMap n n))
notesK HST inp
inp (TypeAnn -> Notes v -> Notes ('TOption v)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn Notes v
notesV) VarAnn
varAnn
  (U.GET_AND_UPDATE VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBool{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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]) (s' :: [T]).
Instr s s' -> Instr s s' -> Instr ('TBool : s) s'
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]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBool{}, Dict (WellTyped x)
_, VarAnn
_) ::& (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 (SingI 'TBool => Sing 'TBool
forall k (a :: k). 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 (s :: [T]). Instr s ('TBool : s) -> Instr ('TBool : s) s
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 InstrCallStack 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 (s :: [T]). Instr s ('TBool : s) -> Instr ('TBool : s) s
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]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 :: Sing x
os@STOr{}, Notes x
ons, Dict (WellTyped x)
Dict, VarAnn
ovn) ::&+ HST xs
rs) -> do
    case Notes ('TOr n n) -> VarAnn -> (Notes n, Notes n, VarAnn, VarAnn)
forall (a :: T) (b :: T).
Notes ('TOr a b) -> VarAnn -> (Notes a, Notes b, VarAnn, VarAnn)
deriveNsOr Notes x
Notes ('TOr n n)
ons VarAnn
ovn of
      (Notes n
an :: Notes t, Notes n
bn :: Notes b, VarAnn
avn, VarAnn
bvn) -> do
        forall (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t ((WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ forall (inp :: [T]).
SingI n =>
(WellTyped n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @b ((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 : xs)
ait = (Notes n
an, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
avn) (Notes n, Dict (WellTyped n), VarAnn) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs
          TypeCheckInstrNoExcept (TypeCheckedSeq (n : xs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (n : 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 (n : xs) -> TypeCheckInstrNoExcept (TypeCheckedSeq (n : xs))
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is HST (n : xs)
ait) [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.LOOP_LEFT ((SomeInstr (n : xs) -> TypeCheckInstr (SomeInstr inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SomeInstr (n : xs) -> TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ \(HST (n : xs)
_ :/ SomeInstrOut (n : xs)
tp) ->
            case SomeInstrOut (n : xs)
tp of
              Instr (n : xs) out
subI ::: HST out
o -> do
                case (HST out
-> HST ('TOr n n : xs)
-> Either TCTypeError (out :~: ('TOr n n : xs))
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o (Sing x
Sing ('TOr n n)
os Sing ('TOr n n) -> HST xs -> HST ('TOr n n : 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 n n : xs)
Refl, ((Notes x
ons', Dict (WellTyped x)
Dict, VarAnn
ovn') ::& HST xs
rs')) -> do
                      let (Notes n
_, Notes n
bn', VarAnn
_, VarAnn
bvn') = Notes ('TOr n n) -> VarAnn -> (Notes n, Notes n, VarAnn, VarAnn)
forall (a :: T) (b :: T).
Notes ('TOr a b) -> VarAnn -> (Notes a, Notes b, VarAnn, VarAnn)
deriveNsOr Notes x
Notes ('TOr n n)
ons' VarAnn
ovn'
                      (Notes n, Dict (WellTyped n), VarAnn)
br <- ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError (Notes n, Dict (WellTyped n), VarAnn)
-> ReaderT
     InstrCallStack TypeCheck (Notes n, Dict (WellTyped n), VarAnn)
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp
                              (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration)
                              ((Notes n, Dict (WellTyped n), VarAnn)
-> (Notes n, Dict (WellTyped n), VarAnn)
-> Either AnnConvergeError (Notes n, Dict (WellTyped n), VarAnn)
forall (t :: T).
(Notes t, Dict (WellTyped t), VarAnn)
-> (Notes t, Dict (WellTyped t), VarAnn)
-> Either AnnConvergeError (Notes t, Dict (WellTyped t), VarAnn)
convergeHSTEl (Notes n
bn, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
bvn) (Notes n
bn', Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
bvn'))
                      pure $ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (n : xs) ('TOr n n : xs) -> Instr ('TOr n n : xs) (n : 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 (n : xs) out
Instr (n : xs) ('TOr n n : xs)
subI Instr ('TOr n n : xs) (n : xs)
-> HST (n : xs) -> SomeInstrOut ('TOr n n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes n, Dict (WellTyped n), VarAnn)
br (Notes n, Dict (WellTyped n), VarAnn) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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 InstrCallStack 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 (n : xs) out
subI -> do
                let br :: (Notes n, Dict (WellTyped n), VarAnn)
br = (Notes n
bn, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
bvn)
                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 (n : xs) ('TOr n n : xs) -> Instr ('TOr n n : xs) (n : 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 (n : xs) ('TOr n n : xs)
forall (out :: [T]). Instr (n : xs) out
subI Instr ('TOr n n : xs) (n : xs)
-> HST (n : xs) -> SomeInstrOut ('TOr n n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes n, Dict (WellTyped n), VarAnn)
br (Notes n, Dict (WellTyped n), VarAnn) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.LOOP_LEFT [ExpandedOp]
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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 (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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)
-> ExpandedInstr
-> [ExpandedOp]
-> VarAnn
-> Notes t
-> Notes t
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (it :: T) (ot :: T) (ts :: [T]).
(WellTyped it, WellTyped ot, SingI ts) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> VarAnn
-> Notes it
-> Notes 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) ExpandedInstr
uInstr [ExpandedOp]
is VarAnn
vn Notes t
ins Notes t
ons HST inp
i

  (U.EXEC VarAnn
vn, ((Notes x
tn :: Notes t1), Dict (WellTyped x)
_, VarAnn
_)
                              ::& ( STLambda v b
                                  , NTLambda TypeAnn
_ (Notes p
t1n :: Notes t1') (Notes q
t2n :: Notes t2')
                                  , Dict (WellTyped x)
_
                                  , VarAnn
_
                                  )
                              ::&+ 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
v ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
b ((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 : 'TLambda n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TLambda n n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TLambda n n : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TLambda n n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda n n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TLambda n n : xs))
forall a b. (a -> b) -> a -> b
$ do
    x :~: p
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (x :~: p)
-> ReaderT InstrCallStack TypeCheck (x :~: p)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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)
                  (Each '[SingI] '[x, p] => Either TCTypeError (x :~: p)
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t1')
    (x :~: p
Refl, Notes x
_) <- Either TCTypeError (x :~: p, Notes x)
-> ReaderT InstrCallStack TypeCheck (x :~: p, Notes x)
forall (m :: * -> *) a.
(MonadReader InstrCallStack m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (x :~: p, Notes x)
 -> ReaderT InstrCallStack TypeCheck (x :~: p, Notes x))
-> Either TCTypeError (x :~: p, Notes x)
-> ReaderT InstrCallStack TypeCheck (x :~: p, Notes x)
forall a b. (a -> b) -> a -> b
$ Notes x -> Notes p -> Either TCTypeError (x :~: p, Notes x)
forall (t1 :: T) (t2 :: T).
Each '[SingI] '[t1, t2] =>
Notes t1 -> Notes t2 -> Either TCTypeError (t1 :~: t2, Notes t1)
matchTypes Notes x
tn Notes p
t1n
    forall a.
SingI q =>
(WellTyped q => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t2' ((WellTyped q =>
  TypeCheckInstr (SomeInstr (x : 'TLambda n n : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TLambda n n : xs)))
-> (WellTyped q =>
    TypeCheckInstr (SomeInstr (x : 'TLambda n n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda n n : 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
:/ Instr (x : 'TLambda x q : xs) (q : xs)
forall (t1 :: T) (t2 :: T) (s :: [T]).
Instr (t1 : 'TLambda t1 t2 : s) (t2 : s)
EXEC Instr (x : 'TLambda x q : xs) (q : xs)
-> HST (q : xs) -> SomeInstrOut (x : 'TLambda x q : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes q
t2n, Dict (WellTyped q)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes q, Dict (WellTyped q), VarAnn) -> HST xs -> HST (q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
      where
        errM :: (MonadReader InstrCallStack m, MonadError TCError m) => Either TCTypeError a -> m a
        errM :: Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, ((Notes x
_ :: Notes a'), Dict (WellTyped x)
_, VarAnn
_)
                  ::& ( STLambda (STPair lt rt) b
                      , NTLambda TypeAnn
vann (NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ (Notes p
_ :: Notes a) (Notes q
nb :: Notes b)) Notes q
sc
                      , Dict (WellTyped x)
_
                      , VarAnn
_)
                  ::&+ 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
lt ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
rt ((SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Sing n
-> (SingI n => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall k (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
b ((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 : 'TLambda ('TPair n n) n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TLambda ('TPair n n) n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n n) n : xs))
 -> TypeCheckInstrNoExcept
      (TypeCheckedSeq (x : 'TLambda ('TPair n n) n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n n) n : xs))
-> TypeCheckInstrNoExcept
     (TypeCheckedSeq (x : 'TLambda ('TPair n n) n : xs))
forall a b. (a -> b) -> a -> b
$ do
    case TypeAnn -> Notes q -> Notes q -> Notes ('TLambda q q)
forall (p :: T) (q :: T).
TypeAnn -> Notes p -> Notes q -> Notes ('TLambda p q)
NTLambda TypeAnn
vann Notes q
nb Notes q
sc of
      (Notes ('TLambda q q)
l2n :: Notes ('TLambda t1 t2)) -> forall a.
SingI ('TLambda q q) =>
(WellTyped ('TLambda q q) => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TLambda t1 t2) ((WellTyped ('TLambda q q) =>
  TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n n) n : xs)))
 -> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n n) n : xs)))
-> (WellTyped ('TLambda q q) =>
    TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n n) n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n n) n : xs))
forall a b. (a -> b) -> a -> b
$ do

        x :~: p
proofArgEq <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (x :~: p)
-> ReaderT InstrCallStack TypeCheck (x :~: p)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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)
                      (Each '[SingI] '[x, p] => Either TCTypeError (x :~: p)
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @a' @a)
        Dict (ConstantScope p)
proofScope <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (ConstantScope p))
-> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope p))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 p))
 -> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope p)))
-> Either BadTypeForScope (Dict (ConstantScope p))
-> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope p))
forall a b. (a -> b) -> a -> b
$ CheckScope (ConstantScope p) =>
Either BadTypeForScope (Dict (ConstantScope p))
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope a)
        case (x :~: p
proofArgEq, Dict (ConstantScope p)
proofScope) of
          (x :~: p
Refl, Dict (ConstantScope p)
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 (b :: T) (a :: T) (c :: [T]).
(ConstantScope p, SingI b) =>
Instr (p : 'TLambda ('TPair p b) a : c) ('TLambda b a : c)
forall (a :: T) (b :: T) (a :: T) (c :: [T]).
(ConstantScope a, SingI b) =>
Instr (a : 'TLambda ('TPair a b) a : c) ('TLambda b a : c)
APPLY @a) Instr (p : 'TLambda ('TPair p q) q : xs) ('TLambda q q : xs)
-> HST ('TLambda q q : xs)
-> SomeInstrOut (p : 'TLambda ('TPair p q) q : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TLambda q q)
l2n, Dict (WellTyped ('TLambda q q))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TLambda q q), Dict (WellTyped ('TLambda q q)), VarAnn)
-> HST xs -> HST ('TLambda q q : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

  (U.APPLY VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Notes x, Dict (WellTyped x), VarAnn)
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
::: ((Notes x, Dict (WellTyped x), VarAnn)
a (Notes x, Dict (WellTyped x), VarAnn) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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', NFData (Sing n)) =>
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 :: 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
          InstrCallStack
pos <- ReaderT InstrCallStack TypeCheckNoExcept InstrCallStack
forall r (m :: * -> *). MonadReader r m => m r
ask
          let err :: TCError
err = ExpandedInstr
-> SomeHST
-> InstrCallStack
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) InstrCallStack
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
_, (Notes x, Dict (WellTyped x), VarAnn)
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 ((Notes x, Dict (WellTyped x), VarAnn)
hstHead (Notes x, Dict (WellTyped x), VarAnn) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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, HST inp
v) -> case (ExpandedInstr
u, HST inp
v) of -- Workaround for not exceeding -fmax-pmcheck-iterations limit
    (ExpandedInstr
U.FAILWITH, ((Notes x
_ :: Notes a, Dict (WellTyped x)
_, VarAnn
_) ::& 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 <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (ConstantScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope x))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (ConstantScope x)))
-> Either BadTypeForScope (Dict (ConstantScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (ConstantScope x))
forall a b. (a -> b) -> a -> b
$ CheckScope (ConstantScope x) =>
Either BadTypeForScope (Dict (ConstantScope x))
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]) (t :: [T]).
(SingI a, ConstantScope a) =>
Instr (a : s) t
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)), (Notes x
en, Dict (WellTyped x)
_, VarAnn
evn) ::& 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
        (x :~: t
Refl, Notes x
_) <- Either TCTypeError (x :~: t, Notes x)
-> ReaderT InstrCallStack TypeCheck (x :~: t, Notes x)
forall (m :: * -> *) a.
(MonadReader InstrCallStack m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (x :~: t, Notes x)
 -> ReaderT InstrCallStack TypeCheck (x :~: t, Notes x))
-> Either TCTypeError (x :~: t, Notes x)
-> ReaderT InstrCallStack TypeCheck (x :~: t, Notes x)
forall a b. (a -> b) -> a -> b
$ Notes x -> Notes t -> Either TCTypeError (x :~: t, Notes x)
forall (t1 :: T) (t2 :: T).
Each '[SingI] '[t1, t2] =>
Notes t1 -> Notes t2 -> Either TCTypeError (t1 :~: t2, Notes t1)
matchTypes Notes x
en Notes t
castToNotes
        forall a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
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
:/ Instr (t : xs) (t : xs)
forall (a :: T) (a :: [T]). SingI a => Instr (a : a) (a : a)
CAST 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
castToNotes, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn VarAnn -> VarAnn -> VarAnn
forall k (t :: k). Annotation t -> Annotation t -> Annotation t
`orAnn` VarAnn
evn) (Notes t, Dict (WellTyped t), VarAnn) -> HST xs -> HST (t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
      where
        errM :: (MonadReader InstrCallStack m, MonadError TCError m) => Either TCTypeError a -> m a
        errM :: Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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, (Notes x
an, Dict (WellTyped x)
Dict, VarAnn
_) ::& 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) (x : xs)
forall (a :: T) (a :: [T]). Instr (a : a) (a : a)
RENAME 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
::: ((Notes x
an, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
tn Notes t
tns of
          (Notes ('TOption t)
ns :: Notes ('TOption t1)) -> forall a.
SingI ('TOption t) =>
(WellTyped ('TOption t) => TypeCheckInstr a) -> TypeCheckInstr a
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 <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (UnpackedValScope t))
-> ReaderT InstrCallStack TypeCheck (Dict (UnpackedValScope t))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (UnpackedValScope t)))
-> Either BadTypeForScope (Dict (UnpackedValScope t))
-> ReaderT InstrCallStack TypeCheck (Dict (UnpackedValScope t))
forall a b. (a -> b) -> a -> b
$ CheckScope (UnpackedValScope t) =>
Either BadTypeForScope (Dict (UnpackedValScope t))
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
:/ Instr ('TBytes : xs) ('TOption t : xs)
forall (s :: T) (s :: [T]).
(UnpackedValScope s, SingI s) =>
Instr ('TBytes : s) ('TOption s : s)
UNPACK 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)
ns, Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption t), Dict (WellTyped ('TOption t)), VarAnn)
-> HST xs -> HST ('TOption t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.UNPACK {}, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Notes x
_ :: Notes a, Dict (WellTyped x)
_, VarAnn
_) ::& 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 <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (PackedValScope x))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (PackedValScope x))
forall a b. (a -> b) -> a -> b
$ CheckScope (PackedValScope x) =>
Either BadTypeForScope (Dict (PackedValScope x))
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
:/ Instr (x : xs) ('TBytes : xs)
forall (a :: T) (s :: [T]).
PackedValScope a =>
Instr (a : s) ('TBytes : s)
PACK 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
::: ((Notes 'TBytes
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBytes, Dict (WellTyped 'TBytes), VarAnn)
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 InstrCallStack m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl HST inp
inp VarAnn
vn
    (U.CONCAT VarAnn
vn, (NTString{}, Dict (WellTyped x)
_, VarAnn
_) ::& (NTString{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 InstrCallStack m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl HST inp
inp VarAnn
vn
    (U.CONCAT VarAnn
vn, (STList STBytes, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 STString, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::&
                 (NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::&
                 (NTString{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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, (NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::&
                 (NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::&
                 (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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', (NTInt{}, Dict (WellTyped x)
_, VarAnn
oldVn) ::& 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
      let vn :: VarAnn
vn = VarAnn
vn' VarAnn -> VarAnn -> VarAnn
forall k (t :: k). Annotation t -> Annotation t -> Annotation t
`orAnn` VarAnn
oldVn
      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 ('TInt : xs) ('TOption 'TNat : xs)
forall (s :: [T]). Instr ('TInt : s) ('TOption 'TNat : s)
ISNAT 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
::: ((Notes ('TOption 'TNat)
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped ('TOption 'TNat))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption 'TNat), Dict (WellTyped ('TOption 'TNat)), VarAnn)
-> HST xs -> HST ('TOption 'TNat : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.ISNAT VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
a, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ (Sing x
b, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 InstrCallStack m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
addImpl Sing x
a Sing 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, (Sing x
a, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ (Sing x
b, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 InstrCallStack m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
subImpl Sing x
a Sing 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.MUL VarAnn
vn, (Sing x
a, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ (Sing x
b, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 InstrCallStack m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
mulImpl Sing x
a Sing 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, (Sing x
a, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ (Sing x
b, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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 InstrCallStack m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
edivImpl Sing x
a Sing 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, (Sing x
STInt, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Abs 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Abs Instr ('TInt : xs) (UnaryArithRes Abs 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Abs n =>
Instr (n : n) (UnaryArithRes Abs n : n)
ABS HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.ABS VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STInt, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Neg 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg Instr ('TInt : xs) (UnaryArithRes Neg 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Neg n =>
Instr (n : n) (UnaryArithRes Neg n : n)
NEG HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.NEG VarAnn
vn, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TNat : xs) (UnaryArithRes Neg 'TNat : xs)
-> HST ('TNat : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TNat : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Neg Instr ('TNat : xs) (UnaryArithRes Neg 'TNat : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Neg n =>
Instr (n : n) (UnaryArithRes Neg n : n)
NEG HST inp
HST ('TNat : xs)
inp VarAnn
vn
    (U.NEG VarAnn
vn, (Sing x
STBls12381Fr, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TBls12381Fr : xs) (UnaryArithRes Neg 'TBls12381Fr : xs)
-> HST ('TBls12381Fr : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg Instr ('TBls12381Fr : xs) (UnaryArithRes Neg 'TBls12381Fr : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Neg n =>
Instr (n : n) (UnaryArithRes Neg n : n)
NEG HST inp
HST ('TBls12381Fr : xs)
inp VarAnn
vn
    (U.NEG VarAnn
vn, (Sing x
STBls12381G1, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TBls12381G1 : xs) (UnaryArithRes Neg 'TBls12381G1 : xs)
-> HST ('TBls12381G1 : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg Instr ('TBls12381G1 : xs) (UnaryArithRes Neg 'TBls12381G1 : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Neg n =>
Instr (n : n) (UnaryArithRes Neg n : n)
NEG HST inp
HST ('TBls12381G1 : xs)
inp VarAnn
vn
    (U.NEG VarAnn
vn, (Sing x
STBls12381G2, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TBls12381G2 : xs) (UnaryArithRes Neg 'TBls12381G2 : xs)
-> HST ('TBls12381G2 : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg Instr ('TBls12381G2 : xs) (UnaryArithRes Neg 'TBls12381G2 : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Neg n =>
Instr (n : n) (UnaryArithRes Neg n : n)
NEG HST inp
HST ('TBls12381G2 : xs)
inp VarAnn
vn
    (U.NEG VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TNat : 'TNat : xs) (ArithRes Lsl 'TNat 'TNat : xs)
-> HST ('TNat : 'TNat : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Lsl Instr ('TNat : 'TNat : xs) (ArithRes Lsl 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Lsl n m =>
Instr (n : m : s) (ArithRes Lsl n m : s)
LSL HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.LSL VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TNat : 'TNat : xs) (ArithRes Lsr 'TNat 'TNat : xs)
-> HST ('TNat : 'TNat : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Lsr Instr ('TNat : 'TNat : xs) (ArithRes Lsr 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Lsr n m =>
Instr (n : m : s) (ArithRes Lsr n m : s)
LSR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.LSR VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
              (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TBool : 'TBool : xs) (ArithRes Or 'TBool 'TBool : xs)
-> HST ('TBool : 'TBool : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Or Instr ('TBool : 'TBool : xs) (ArithRes Or 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Or n m =>
Instr (n : m : s) (ArithRes Or n m : s)
OR HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.OR VarAnn
vn, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
              (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TNat : 'TNat : xs) (ArithRes Or 'TNat 'TNat : xs)
-> HST ('TNat : 'TNat : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Or Instr ('TNat : 'TNat : xs) (ArithRes Or 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Or n m =>
Instr (n : m : s) (ArithRes Or n m : s)
OR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.OR VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STInt, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TInt : 'TNat : xs) (ArithRes And 'TInt 'TNat : xs)
-> HST ('TInt : 'TNat : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And Instr ('TInt : 'TNat : xs) (ArithRes And 'TInt 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
Instr (n : m : s) (ArithRes And n m : s)
AND HST inp
HST ('TInt : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.AND VarAnn
vn, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TNat : 'TNat : xs) (ArithRes And 'TNat 'TNat : xs)
-> HST ('TNat : 'TNat : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And Instr ('TNat : 'TNat : xs) (ArithRes And 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
Instr (n : m : s) (ArithRes And n m : s)
AND HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.AND VarAnn
vn, (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TBool : 'TBool : xs) (ArithRes And 'TBool 'TBool : xs)
-> HST ('TBool : 'TBool : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And Instr ('TBool : 'TBool : xs) (ArithRes And 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
Instr (n : m : s) (ArithRes And n m : s)
AND HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.AND VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TBool : 'TBool : xs) (ArithRes Xor 'TBool 'TBool : xs)
-> HST ('TBool : 'TBool : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Xor Instr ('TBool : 'TBool : xs) (ArithRes Xor 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Xor n m =>
Instr (n : m : s) (ArithRes Xor n m : s)
XOR HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.XOR VarAnn
vn, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+
               (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$
      Instr ('TNat : 'TNat : xs) (ArithRes Xor 'TNat 'TNat : xs)
-> HST ('TNat : 'TNat : xs)
-> VarAnn
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
forall k (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
       (t :: * -> *).
(ArithOp aop n m, WellTyped (ArithRes aop n m), inp ~ (n : m : s),
 MonadReader InstrCallStack t, MonadError TCError t) =>
Instr inp (ArithRes aop n m : s)
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Xor Instr ('TNat : 'TNat : xs) (ArithRes Xor 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Xor n m =>
Instr (n : m : s) (ArithRes Xor n m : s)
XOR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
    (U.XOR VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (Sing x
STNat, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TNat : xs) (UnaryArithRes Not 'TNat : xs)
-> HST ('TNat : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TNat : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Not Instr ('TNat : xs) (UnaryArithRes Not 'TNat : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Not n =>
Instr (n : n) (UnaryArithRes Not n : n)
NOT HST inp
HST ('TNat : xs)
inp VarAnn
vn
    (U.NOT VarAnn
vn, (Sing x
STBool, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TBool : xs) (UnaryArithRes Not 'TBool : xs)
-> HST ('TBool : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TBool : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImplAnnotated @Not Instr ('TBool : xs) (UnaryArithRes Not 'TBool : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Not n =>
Instr (n : n) (UnaryArithRes Not n : n)
NOT HST inp
HST ('TBool : xs)
inp VarAnn
vn
    (U.NOT VarAnn
vn, (Sing x
STInt, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Not 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImplAnnotated @Not Instr ('TInt : xs) (UnaryArithRes Not 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Not n =>
Instr (n : n) (UnaryArithRes Not n : n)
NOT HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.NOT VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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,
          (Notes x
an :: Notes aT, Dict (WellTyped x)
_, VarAnn
_)
      ::& (Notes x
bn :: Notes bT, Dict (WellTyped x)
_, VarAnn
_)
      ::& 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 Each '[SingI] '[x, x] => Either TCTypeError (x :~: x)
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @aT @bT of
        Right x :~: x
Refl -> do
          ReaderT InstrCallStack TypeCheck (Notes x)
-> ReaderT InstrCallStack TypeCheck ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT InstrCallStack TypeCheck (Notes x)
 -> ReaderT InstrCallStack TypeCheck ())
-> (Either AnnConvergeError (Notes x)
    -> ReaderT InstrCallStack TypeCheck (Notes x))
-> Either AnnConvergeError (Notes x)
-> ReaderT InstrCallStack TypeCheck ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either AnnConvergeError (Notes x)
-> ReaderT InstrCallStack TypeCheck (Notes x)
forall (m :: * -> *) a.
(MonadReader InstrCallStack m, MonadError TCError m) =>
Either AnnConvergeError a -> m a
errConv (Either AnnConvergeError (Notes x)
 -> ReaderT InstrCallStack TypeCheck ())
-> Either AnnConvergeError (Notes x)
-> ReaderT InstrCallStack TypeCheck ()
forall a b. (a -> b) -> a -> b
$ Notes x -> Notes x -> Either AnnConvergeError (Notes x)
forall (t :: T).
Notes t -> Notes t -> Either AnnConvergeError (Notes t)
converge Notes x
an Notes x
Notes x
bn
          Dict (ComparabilityScope x)
proofScope <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (ComparabilityScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (ComparabilityScope x))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (ComparabilityScope x)))
-> Either BadTypeForScope (Dict (ComparabilityScope x))
-> ReaderT InstrCallStack TypeCheck (Dict (ComparabilityScope x))
forall a b. (a -> b) -> a -> b
$ CheckScope (ComparabilityScope x) =>
Either BadTypeForScope (Dict (ComparabilityScope x))
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
:/ Instr (x : x : xs) ('TInt : xs)
forall (n :: T) (n :: [T]).
(Comparable n, SingI n) =>
Instr (n : n : n) ('TInt : n)
COMPARE 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
::: ((Notes 'TInt
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TInt, Dict (WellTyped 'TInt), VarAnn)
-> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

        Left TCTypeError
err -> do
          ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> TypeCheckInstr (SomeInstr inp)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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
      where
        errConv :: (MonadReader InstrCallStack m, MonadError TCError m) => Either AnnConvergeError a -> m a
        errConv :: Either AnnConvergeError a -> m a
errConv = ExpandedInstr
-> HST inp -> Maybe TypeContext -> Either AnnConvergeError a -> m a
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ComparisonArguments)

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

    (U.EQ VarAnn
vn, (NTInt{}, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Eq' 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Eq' Instr ('TInt : xs) (UnaryArithRes Eq' 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Eq' n =>
Instr (n : n) (UnaryArithRes Eq' n : n)
EQ HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.EQ VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTInt{}, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Neq 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Neq Instr ('TInt : xs) (UnaryArithRes Neq 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Neq n =>
Instr (n : n) (UnaryArithRes Neq n : n)
NEQ HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.NEQ VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTInt{}, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Lt 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Lt Instr ('TInt : xs) (UnaryArithRes Lt 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Lt n =>
Instr (n : n) (UnaryArithRes Lt n : n)
LT HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.LT VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTInt{}, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Gt 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Gt Instr ('TInt : xs) (UnaryArithRes Gt 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Gt n =>
Instr (n : n) (UnaryArithRes Gt n : n)
GT HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.GT VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTInt{}, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Le 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Le Instr ('TInt : xs) (UnaryArithRes Le 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Le n =>
Instr (n : n) (UnaryArithRes Le n : n)
LE HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.LE VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTInt{}, Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
 -> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
      Instr ('TInt : xs) (UnaryArithRes Ge 'TInt : xs)
-> HST ('TInt : xs)
-> VarAnn
-> TypeCheckInstr (SomeInstr ('TInt : xs))
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 -> VarAnn -> t (SomeInstr inp)
unaryArithImpl @Ge Instr ('TInt : xs) (UnaryArithRes Ge 'TInt : xs)
forall (n :: T) (n :: [T]).
UnaryArithOp Ge n =>
Instr (n : n) (UnaryArithRes Ge n : n)
GE HST inp
HST ('TInt : xs)
inp VarAnn
vn
    (U.GE VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TNat : xs) ('TInt : xs)
forall (n :: T) (arg :: [T]).
ToIntArithOp n =>
Instr (n : arg) ('TInt : arg)
INT 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
::: ((Notes 'TInt
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TInt, Dict (WellTyped 'TInt), VarAnn)
-> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.INT VarAnn
vn, (NTBls12381Fr{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TBls12381Fr : xs) ('TInt : xs)
forall (n :: T) (arg :: [T]).
ToIntArithOp n =>
Instr (n : arg) ('TInt : arg)
INT 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
::: ((Notes 'TInt
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TInt, Dict (WellTyped 'TInt), VarAnn)
-> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.INT VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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.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
$ do
      TypeCheckMode
mode <- (TypeCheckEnv -> TypeCheckMode)
-> ReaderT InstrCallStack TypeCheck 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 Sing t
_ 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 InstrCallStack TypeCheck (MkEntrypointCallRes t))
-> ReaderT InstrCallStack TypeCheck (MkEntrypointCallRes t)
forall a b. a -> (a -> b) -> b
& ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (MkEntrypointCallRes t)
-> ReaderT InstrCallStack TypeCheck (MkEntrypointCallRes t)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 (t :: T). TypeAnn -> Notes t -> Notes ('TContract t)
NTContract TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn Notes arg
argNotes of
                  (Notes ('TContract arg)
ntRes :: Notes ('TContract t1)) ->
                    forall a.
SingI ('TContract arg) =>
(WellTyped ('TContract arg) => TypeCheckInstr a)
-> TypeCheckInstr a
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
:/ SomeEntrypointCallT arg -> Instr inp ('TContract arg : inp)
forall (arg :: T) (s :: [T]).
ParameterScope arg =>
SomeEntrypointCallT arg -> Instr s ('TContract arg : s)
SELF @arg (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)
ntRes, Dict (WellTyped ('TContract arg))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TContract arg), Dict (WellTyped ('TContract arg)), VarAnn)
-> HST inp -> HST ('TContract arg : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
inp)
        TypeCheckMode
TypeCheckTest ->
          Text -> TypeCheckInstr (SomeInstr inp)
forall a. HasCallStack => Text -> a
error Text
"'SELF' appears in test typechecking."
        TypeCheckMode
TypeCheckPack ->
          Text -> TypeCheckInstr (SomeInstr inp)
forall a. HasCallStack => Text -> a
error Text
"'SELF' appears in packed data."
    (U.CONTRACT VarAnn
vn RootAnn
fn Ty
mt, (NTAddress{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT InstrCallStack TypeCheck (Dict (ParameterScope t))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT InstrCallStack TypeCheck (Dict (ParameterScope t))
forall a b. (a -> b) -> a -> b
$ CheckScope (ParameterScope t) =>
Either BadTypeForScope (Dict (ParameterScope t))
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 (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
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 (t :: T). TypeAnn -> Notes t -> Notes ('TContract t)
NTContract TypeAnn
forall a. Default a => a
def Notes t
tns
        EpName
epName <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError EpName
-> ReaderT InstrCallStack TypeCheck EpName
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck EpName)
-> Either TCTypeError EpName
-> ReaderT InstrCallStack TypeCheck 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 a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t =>
  ReaderT InstrCallStack TypeCheck (SomeInstr ('TAddress : xs)))
 -> ReaderT InstrCallStack TypeCheck (SomeInstr ('TAddress : xs)))
-> (WellTyped t =>
    ReaderT InstrCallStack TypeCheck (SomeInstr ('TAddress : xs)))
-> ReaderT InstrCallStack TypeCheck (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
:/ Notes t
-> EpName -> Instr ('TAddress : xs) ('TOption ('TContract t) : xs)
forall (p :: T) (p :: [T]).
ParameterScope p =>
Notes p
-> EpName -> Instr ('TAddress : p) ('TOption ('TContract p) : p)
CONTRACT 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))
ns, Dict (WellTyped ('TOption ('TContract t)))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption ('TContract t)),
 Dict (WellTyped ('TOption ('TContract t))), VarAnn)
-> HST xs -> HST ('TOption ('TContract t) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.CONTRACT {}, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, ((Notes x
_ :: Notes p'), Dict (WellTyped x)
_, VarAnn
_)
      ::& (NTMutez{}, Dict (WellTyped x)
_, VarAnn
_)
      ::& (STContract (s :: Sing p), Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ 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
$ do
      Dict (ParameterScope n)
proofScope <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either BadTypeForScope (Dict (ParameterScope n))
-> ReaderT InstrCallStack TypeCheck (Dict (ParameterScope n))
forall (t :: T) (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (Dict (ParameterScope n)))
-> Either BadTypeForScope (Dict (ParameterScope n))
-> ReaderT InstrCallStack TypeCheck (Dict (ParameterScope n))
forall a b. (a -> b) -> a -> b
$ CheckScope (ParameterScope n) =>
Either BadTypeForScope (Dict (ParameterScope n))
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope p)
      case (Each '[SingI] '[n, x] => Either TCTypeError (n :~: x)
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @p @p', Dict (ParameterScope n)
proofScope) of
        (Right n :~: x
Refl, Dict (ParameterScope n)
Dict) ->
          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 : 'TMutez : 'TContract x : xs) ('TOperation : xs)
forall (p :: T) (s :: [T]).
ParameterScope p =>
Instr (p : 'TMutez : 'TContract p : s) ('TOperation : s)
TRANSFER_TOKENS 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
::: ((Notes 'TOperation
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TOperation, Dict (WellTyped 'TOperation), VarAnn)
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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 InstrCallStack 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
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 STKeyHash, NTOption TypeAnn
_ NTKeyHash{}, Dict (WellTyped x)
_, VarAnn
_)
      ::&+ 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
:/ Instr ('TOption 'TKeyHash : xs) ('TOperation : xs)
forall (s :: [T]). Instr ('TOption 'TKeyHash : s) ('TOperation : s)
SET_DELEGATE 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
::: ((Notes 'TOperation
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TOperation, Dict (WellTyped 'TOperation), VarAnn)
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.SET_DELEGATE VarAnn
_,  (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 STKeyHash, NTOption TypeAnn
_ (_ :: Notes ('TKeyHash)), Dict (WellTyped x)
_, VarAnn
_)
      ::&+ (NTMutez{}, Dict (WellTyped x)
_, VarAnn
_)
      ::& (Notes x
gn :: Notes g, Dict (WellTyped x)
Dict, VarAnn
_) ::& 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
        (SomeContract
          (Contract
            (ContractCode cp st
contr :: ContractCode p' g')
            ParamNotes cp
paramNotes
            Notes st
storeNotes
            EntriesOrder
entriesOrder))
          <- TypeCheck SomeContract
-> ReaderT InstrCallStack TypeCheck SomeContract
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (TypeCheck SomeContract
 -> ReaderT InstrCallStack TypeCheck SomeContract)
-> TypeCheck SomeContract
-> ReaderT InstrCallStack TypeCheck 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 InstrCallStack TypeCheck (x :~: st)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (x :~: st))
-> Either TCTypeError (x :~: st)
-> ReaderT InstrCallStack TypeCheck (x :~: st)
forall a b. (a -> b) -> a -> b
$ Each '[SingI] '[x, st] => Either TCTypeError (x :~: st)
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @g @g'
        ReaderT InstrCallStack TypeCheck (Notes x)
-> ReaderT InstrCallStack TypeCheck ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT InstrCallStack TypeCheck (Notes x)
 -> ReaderT InstrCallStack TypeCheck ())
-> ReaderT InstrCallStack TypeCheck (Notes x)
-> ReaderT InstrCallStack TypeCheck ()
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> HST inp
-> Maybe TypeContext
-> Either AnnConvergeError (Notes x)
-> ReaderT InstrCallStack TypeCheck (Notes x)
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
uInstr HST inp
inp (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractStorage) (Notes x -> Notes x -> Either AnnConvergeError (Notes x)
forall (t :: T).
Notes t -> Notes t -> Either AnnConvergeError (Notes t)
converge Notes x
gn Notes x
Notes st
storeNotes)
        pure
          $ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Contract cp st
-> Instr
     ('TOption 'TKeyHash : 'TMutez : st : xs)
     ('TOperation : 'TAddress : xs)
forall (p :: T) (g :: T) (s :: [T]).
(ParameterScope p, StorageScope g) =>
Contract p g
-> Instr
     ('TOption 'TKeyHash : 'TMutez : g : s)
     ('TOperation : 'TAddress : s)
CREATE_CONTRACT (ContractCode cp st
-> ParamNotes cp -> Notes st -> EntriesOrder -> Contract cp st
forall (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode cp st
-> ParamNotes cp -> Notes st -> EntriesOrder -> Contract cp st
Contract ContractCode cp st
contr ParamNotes cp
paramNotes Notes st
storeNotes EntriesOrder
entriesOrder)
          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
::: ((Notes 'TOperation
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
ovn) (Notes 'TOperation, Dict (WellTyped 'TOperation), VarAnn)
-> HST ('TAddress : xs) -> HST ('TOperation : 'TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes 'TAddress
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
avn) (Notes 'TAddress, Dict (WellTyped 'TAddress), VarAnn)
-> HST xs -> HST ('TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.CREATE_CONTRACT {}, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTKeyHash{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TKeyHash : xs) ('TContract 'TUnit : xs)
forall (s :: [T]). Instr ('TKeyHash : s) ('TContract 'TUnit : s)
IMPLICIT_ACCOUNT 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
::: ((Notes ('TContract 'TUnit)
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped ('TContract 'TUnit))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TContract 'TUnit), Dict (WellTyped ('TContract 'TUnit)),
 VarAnn)
-> HST xs -> HST ('TContract 'TUnit : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.IMPLICIT_ACCOUNT VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:/ Instr inp ('TTimestamp : inp)
forall (s :: [T]). Instr s ('TTimestamp : s)
NOW Instr inp ('TTimestamp : inp)
-> HST ('TTimestamp : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TTimestamp
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TTimestamp)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TTimestamp, Dict (WellTyped 'TTimestamp), VarAnn)
-> HST inp -> HST ('TTimestamp : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ Instr inp ('TMutez : inp)
forall (s :: [T]). Instr s ('TMutez : s)
AMOUNT Instr inp ('TMutez : inp)
-> HST ('TMutez : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TMutez
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TMutez)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TMutez, Dict (WellTyped 'TMutez), VarAnn)
-> HST inp -> HST ('TMutez : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ Instr inp ('TMutez : inp)
forall (s :: [T]). Instr s ('TMutez : s)
BALANCE Instr inp ('TMutez : inp)
-> HST ('TMutez : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TMutez
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TMutez)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TMutez, Dict (WellTyped 'TMutez), VarAnn)
-> HST inp -> HST ('TMutez : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
inp)

    (U.VOTING_POWER VarAnn
vn, (NTKeyHash{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TKeyHash : xs) ('TNat : xs)
forall (s :: [T]). Instr ('TKeyHash : s) ('TNat : s)
VOTING_POWER 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
::: ((Notes 'TNat
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TNat, Dict (WellTyped 'TNat), VarAnn)
-> HST xs -> HST ('TNat : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (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
:/ Instr inp ('TNat : inp)
forall (s :: [T]). Instr s ('TNat : s)
TOTAL_VOTING_POWER Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TNat
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TNat, Dict (WellTyped 'TNat), VarAnn)
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
inp)

    (U.CHECK_SIGNATURE VarAnn
vn,
               (NTKey TypeAnn
_, Dict (WellTyped x)
_, VarAnn
_)
               ::& (NTSignature TypeAnn
_, Dict (WellTyped x)
_, VarAnn
_) ::& (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TKey : 'TSignature : 'TBytes : xs) ('TBool : xs)
forall (s :: [T]).
Instr ('TKey : 'TSignature : 'TBytes : s) ('TBool : s)
CHECK_SIGNATURE 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
::: ((Notes 'TBool
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBool)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBool, Dict (WellTyped 'TBool), VarAnn)
-> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.CHECK_SIGNATURE VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). Instr ('TBytes : s) ('TBytes : s)
SHA256 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
::: ((Notes 'TBytes
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBytes, Dict (WellTyped 'TBytes), VarAnn)
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.SHA256 VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). Instr ('TBytes : s) ('TBytes : s)
SHA512 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
::: ((Notes 'TBytes
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBytes, Dict (WellTyped 'TBytes), VarAnn)
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.SHA512 VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). Instr ('TBytes : s) ('TBytes : s)
BLAKE2B 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
::: ((Notes 'TBytes
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBytes, Dict (WellTyped 'TBytes), VarAnn)
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.BLAKE2B VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). Instr ('TBytes : s) ('TBytes : s)
SHA3 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
::: ((Notes 'TBytes
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBytes, Dict (WellTyped 'TBytes), VarAnn)
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.SHA3 VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTBytes{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). Instr ('TBytes : s) ('TBytes : s)
KECCAK 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
::: ((Notes 'TBytes
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBytes, Dict (WellTyped 'TBytes), VarAnn)
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.KECCAK VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTKey{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TKey : xs) ('TKeyHash : xs)
forall (s :: [T]). Instr ('TKey : s) ('TKeyHash : s)
HASH_KEY 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
::: ((Notes 'TKeyHash
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TKeyHash)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TKeyHash, Dict (WellTyped 'TKeyHash), VarAnn)
-> HST xs -> HST ('TKeyHash : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.HASH_KEY VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTList TypeAnn
_ (NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ (NTBls12381G1 TypeAnn
_)
                                                     (NTBls12381G2 TypeAnn
_)), Dict (WellTyped x)
_, VarAnn
_) ::& 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
  ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs) ('TBool : xs)
forall (s :: [T]).
Instr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : s) ('TBool : s)
PAIRING_CHECK 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
::: ((Notes 'TBool
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TBool)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TBool, Dict (WellTyped 'TBool), VarAnn)
-> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.PAIRING_CHECK VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:/ Instr inp ('TAddress : inp)
forall (s :: [T]). Instr s ('TAddress : s)
SOURCE Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TAddress
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TAddress, Dict (WellTyped 'TAddress), VarAnn)
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ Instr inp ('TAddress : inp)
forall (s :: [T]). Instr s ('TAddress : s)
SENDER Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TAddress
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TAddress, Dict (WellTyped 'TAddress), VarAnn)
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
inp)

    (U.ADDRESS VarAnn
vn, (NTContract{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 ('TContract t : xs) ('TAddress : xs)
forall (a :: T) (s :: [T]).
Instr ('TContract a : s) ('TAddress : s)
ADDRESS Instr ('TContract t : xs) ('TAddress : xs)
-> HST ('TAddress : xs) -> SomeInstrOut ('TContract t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TAddress
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TAddress, Dict (WellTyped 'TAddress), VarAnn)
-> HST xs -> HST ('TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)

    (U.ADDRESS VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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
:/ Instr inp ('TChainId : inp)
forall (s :: [T]). Instr s ('TChainId : s)
CHAIN_ID Instr inp ('TChainId : inp)
-> HST ('TChainId : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TChainId
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TChainId)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TChainId, Dict (WellTyped 'TChainId), VarAnn)
-> HST inp -> HST ('TChainId : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ Instr inp ('TNat : inp)
forall (s :: [T]). Instr s ('TNat : s)
LEVEL Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TNat
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TNat, Dict (WellTyped 'TNat), VarAnn)
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
:/ Instr inp ('TAddress : inp)
forall (s :: [T]). Instr s ('TAddress : s)
SELF_ADDRESS Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes 'TAddress
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes 'TAddress, Dict (WellTyped 'TAddress), VarAnn)
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST inp
inp)

    (ExpandedInstr
U.NEVER, (NTNever{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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]) (t :: [T]). Instr ('TNever : s) t
NEVER

    (U.TICKET VarAnn
vn, (stVal :: Sing v, Notes x
_, Dict (WellTyped x)
_, VarAnn
_) ::&+ (NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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 a.
SingI x =>
(WellTyped x => TypeCheckInstr a) -> TypeCheckInstr a
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 InstrCallStack 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
:/ Instr (x : 'TNat : xs) ('TTicket x : xs)
forall (a :: T) (a :: [T]).
Comparable a =>
Instr (a : 'TNat : a) ('TTicket a : a)
TICKET 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
::: ((Notes ('TTicket x)
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped ('TTicket x))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TTicket x), Dict (WellTyped ('TTicket x)), VarAnn)
-> HST xs -> HST ('TTicket x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.TICKET VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 :: (Notes x, Dict (WellTyped x), VarAnn)
ticket@(ntTicket :: Notes x
ntTicket@NTTicket{}, Dict (WellTyped x)
Dict, VarAnn
_) ::& 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 Notes x -> Sing x
forall (t :: T). SingI t => Notes t -> Sing t
notesSing Notes x
ntTicket of
        STTicket{} ->
          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
  ('TTicket t : xs) ('TPair 'TAddress ('TPair t 'TNat) : x : xs)
forall (a :: T) (a :: [T]).
Instr
  ('TTicket a : a)
  (RightComb '[ 'TAddress, a, 'TNat] : 'TTicket a : a)
READ_TICKET Instr
  ('TTicket t : xs) ('TPair 'TAddress ('TPair t 'TNat) : x : xs)
-> HST ('TPair 'TAddress ('TPair t 'TNat) : x : xs)
-> SomeInstrOut ('TTicket t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TPair 'TAddress ('TPair t 'TNat))
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped ('TPair 'TAddress ('TPair t 'TNat)))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TPair 'TAddress ('TPair t 'TNat)),
 Dict (WellTyped ('TPair 'TAddress ('TPair t 'TNat))), VarAnn)
-> HST (x : xs) -> HST ('TPair 'TAddress ('TPair t 'TNat) : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& (Notes x, Dict (WellTyped x), VarAnn)
ticket (Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.READ_TICKET VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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, (NTTicket{}, Dict (WellTyped x)
Dict, VarAnn
_) ::& (NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ NTNat{} NTNat{}, Dict (WellTyped x)
_, VarAnn
_) ::& 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
  ('TTicket t : 'TPair 'TNat 'TNat : xs)
  ('TOption ('TPair ('TTicket t) ('TTicket t)) : xs)
forall (a :: T) (a :: [T]).
Instr
  ('TTicket a : 'TPair 'TNat 'TNat : a)
  ('TOption ('TPair ('TTicket a) ('TTicket a)) : a)
SPLIT_TICKET Instr
  ('TTicket t : 'TPair 'TNat 'TNat : xs)
  ('TOption ('TPair ('TTicket t) ('TTicket t)) : xs)
-> HST ('TOption ('TPair ('TTicket t) ('TTicket t)) : xs)
-> SomeInstrOut ('TTicket t : 'TPair 'TNat 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TOption ('TPair ('TTicket t) ('TTicket t)))
forall (t :: T). SingI t => Notes t
starNotes, Dict (WellTyped ('TOption ('TPair ('TTicket t) ('TTicket t))))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption ('TPair ('TTicket t) ('TTicket t))),
 Dict (WellTyped ('TOption ('TPair ('TTicket t) ('TTicket t)))),
 VarAnn)
-> HST xs -> HST ('TOption ('TPair ('TTicket t) ('TTicket t)) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.SPLIT_TICKET VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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{}, NTPair TypeAnn
_ RootAnn
_ RootAnn
_ VarAnn
_ VarAnn
_ nt1 :: Notes p
nt1@NTTicket{} nt2 :: Notes q
nt2@NTTicket{}, Dict (WellTyped x)
Dict, VarAnn
_) ::&+ 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
        (p :~: q
Refl, Notes p
nt) <-
          ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (p :~: q, Notes p)
-> ReaderT InstrCallStack TypeCheck (p :~: q, Notes p)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 (p :~: q, Notes p)
 -> ReaderT InstrCallStack TypeCheck (p :~: q, Notes p))
-> Either TCTypeError (p :~: q, Notes p)
-> ReaderT InstrCallStack TypeCheck (p :~: q, Notes p)
forall a b. (a -> b) -> a -> b
$
            Notes p -> Notes q -> Either TCTypeError (p :~: q, Notes p)
forall (t1 :: T) (t2 :: T).
Each '[SingI] '[t1, t2] =>
Notes t1 -> Notes t2 -> Either TCTypeError (t1 :~: t2, Notes t1)
matchTypes Notes p
nt1 Notes q
nt2
        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
  ('TPair ('TTicket t) ('TTicket t) : xs)
  ('TOption ('TTicket t) : xs)
forall (a :: T) (s :: [T]).
Instr
  ('TPair ('TTicket a) ('TTicket a) : s) ('TOption ('TTicket a) : s)
JOIN_TICKETS Instr
  ('TPair ('TTicket t) ('TTicket t) : xs)
  ('TOption ('TTicket t) : xs)
-> HST ('TOption ('TTicket t) : xs)
-> SomeInstrOut ('TPair ('TTicket t) ('TTicket t) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((TypeAnn -> Notes p -> Notes ('TOption p)
forall (t :: T). TypeAnn -> Notes t -> Notes ('TOption t)
NTOption TypeAnn
forall k (tag :: k). Annotation tag
U.noAnn Notes p
nt, Dict (WellTyped ('TOption p))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TOption p), Dict (WellTyped ('TOption p)), VarAnn)
-> HST xs -> HST ('TOption p : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST xs
rs)
    (U.JOIN_TICKETS VarAnn
_, (Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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

    -- Could not get rid of the catch all clause due to this warning:
    -- @
    -- Pattern match checker exceeded (2000000) iterations in
    -- a case alternative. (Use -fmax-pmcheck-iterations=n
    -- to set the maximum number of iterations to n)
    -- @
    (ExpandedInstr, HST inp)
i ->
      Text -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a. HasCallStack => Text -> a
error (Text -> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> Text -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ Text
"Pattern matches should be exhaustive, but instead got: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (ExpandedInstr, HST inp) -> Text
forall b a. (Show a, IsString b) => a -> b
show (ExpandedInstr, HST inp)
i
  where
    withWTPInstr'
      :: forall t inp. SingI t
      => (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
      -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
    withWTPInstr' :: (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' = ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
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 :: (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr = ExpandedInstr
-> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
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 :: 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' :: TCTypeError -> TypeCheckInstr a
failWithErr' = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> TCTypeError -> TypeCheckInstr a
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 :: TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack = TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr TCTypeError
NotEnoughItemsOnStack

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

-- | 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 (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@((Notes x, Dict (WellTyped x), VarAnn)
_ ::& 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 InstrCallStack TypeCheck (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 InstrCallStack TypeCheck (SomeInstrOut (cond : rs))
 -> TypeCheckInstr (SomeInstr (cond : rs)))
-> ReaderT InstrCallStack TypeCheck (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 InstrCallStack TypeCheck (out :~: out)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (out :~: out))
-> Either TCTypeError (out :~: out)
-> ReaderT InstrCallStack TypeCheck (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
          HST out
o <- ExpandedInstr
-> HST (cond : rs)
-> Maybe TypeContext
-> Either AnnConvergeError (HST out)
-> ReaderT InstrCallStack TypeCheck (HST out)
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
instr HST (cond : rs)
i (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
If) (HST out -> HST out -> Either AnnConvergeError (HST out)
forall (ts :: [T]).
HST ts -> HST ts -> Either AnnConvergeError (HST ts)
convergeHST HST out
po HST out
HST out
qo)
          pure $ 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
o
        (AnyOutInstr forall (out :: [T]). Instr bti out
p, Instr bfi out
q ::: HST out
qo) -> do
          SomeInstrOut (cond : rs)
-> ReaderT InstrCallStack TypeCheck (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT InstrCallStack TypeCheck (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT InstrCallStack TypeCheck (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 InstrCallStack TypeCheck (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT InstrCallStack TypeCheck (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT InstrCallStack TypeCheck (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 InstrCallStack TypeCheck (SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
 -> ReaderT InstrCallStack TypeCheck (SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT InstrCallStack TypeCheck (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)
  -> Notes (MapOpInp c)
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> HST (c ': rs)
  -> (forall v'. (SingI v') =>
        Notes v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' ': rs)))
  -> TypeCheckInstrNoExcept (TypeCheckedSeq (c ': rs))
mapImpl :: ([TypeCheckedOp] -> TypeCheckedInstr)
-> Notes (MapOpInp c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
    SingI v' =>
    Notes v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl [TypeCheckedOp] -> TypeCheckedInstr
cons Notes (MapOpInp c)
vn ExpandedInstr
instr [ExpandedOp]
mp i :: HST (c : rs)
i@((Notes x, Dict (WellTyped x), VarAnn)
_ ::& HST xs
rs) forall (v' :: T).
SingI v' =>
Notes 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 ((Notes (MapOpInp c)
vn, Dict (WellTyped (MapOpInp c))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall a. Default a => a
def) (Notes (MapOpInp c), Dict (WellTyped (MapOpInp c)), VarAnn)
-> HST xs -> HST (MapOpInp c : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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
          (Notes x
bn :: Notes v', Dict (WellTyped x)
_, VarAnn
_bvn) ::& HST xs
rs' -> do
            xs :~: xs
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (xs :~: xs)
-> ReaderT InstrCallStack TypeCheck (xs :~: xs)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (xs :~: xs))
-> Either TCTypeError (xs :~: xs)
-> ReaderT InstrCallStack TypeCheck (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 <- Notes x
-> HST rs
-> ReaderT InstrCallStack TypeCheck (HST (MapOpRes c x : rs))
forall (v' :: T).
SingI v' =>
Notes v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs))
mkRes Notes 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
:/ (SingI (MapOpRes c x) => SomeInstrOut (c : rs))
-> SomeInstrOut (c : rs)
forall k k (f :: k -> k) (x :: k) r.
(SingI1 f, SingI x) =>
(SingI (f x) => r) -> r
withSingI1 @(MapOpRes c) @v' (Instr (MapOpInp c : xs) (x : xs)
-> Instr (c : xs) (MapOpRes c x : xs)
forall (c :: T) (b :: T) (s :: [T]).
(MapOp c, SingI b) =>
Instr (MapOpInp c : s) (b : s) -> Instr (c : s) (MapOpRes c b : s)
MAP 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 InstrCallStack 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 InstrCallStack 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)
    )
  => Notes (IterOpEl c)
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> HST (c ': rs)
  -> TypeCheckInstrNoExcept (TypeCheckedSeq (c ': rs))
iterImpl :: Notes (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Notes (IterOpEl c)
en ExpandedInstr
instr [ExpandedOp]
mp i :: HST (c : rs)
i@((Notes x
_, Dict (WellTyped x)
_, VarAnn
lvn) ::& HST xs
rs) = do
  let evn :: VarAnn
evn = VarAnn -> VarAnn -> VarAnn
deriveVN [annQ|elt|] VarAnn
lvn
  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 InstrCallStack 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 ((Notes (IterOpEl c)
en, Dict (WellTyped (IterOpEl c))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
evn) (Notes (IterOpEl c), Dict (WellTyped (IterOpEl c)), VarAnn)
-> HST xs -> HST (IterOpEl c : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> 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 InstrCallStack TypeCheck (out :~: xs)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (out :~: xs))
-> Either TCTypeError (out :~: xs)
-> ReaderT InstrCallStack TypeCheck (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) (s :: [T]).
IterOp c =>
Instr (IterOpEl c : s) s -> Instr (c : s) s
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 InstrCallStack 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)
  -> U.ExpandedInstr
  -> [U.ExpandedOp]
  -> VarAnn
  -> Notes it
  -> Notes ot
  -> HST ts
  -> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl :: ([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> VarAnn
-> Notes it
-> Notes ot
-> HST ts
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl [TypeCheckedOp] -> TypeCheckedInstr
cons ExpandedInstr
instr [ExpandedOp]
is VarAnn
vn Notes it
ins Notes ot
ons HST ts
i =
  ExpandedInstr
-> ReaderT InstrCallStack TypeCheck ()
-> 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 InstrCallStack TypeCheck ())
-> ReaderT InstrCallStack TypeCheck ()
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 InstrCallStack TypeCheck ())
 -> ReaderT InstrCallStack TypeCheck ())
-> (ExpandedInstr -> ReaderT InstrCallStack TypeCheck ())
-> ReaderT InstrCallStack TypeCheck ()
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 InstrCallStack TypeCheck ()
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 ([ExpandedOp]
-> HST '[it] -> TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is ((Notes it
ins, Dict (WellTyped it)
forall (a :: Constraint). a => Dict a
Dict, VarAnn
forall a. Default a => a
def) (Notes it, Dict (WellTyped it), VarAnn) -> HST '[] -> HST '[it]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST '[]
SNil)) [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 :: Notes ot -> Notes ('TLambda it ot)
lamNotes Notes ot
onsr = TypeAnn -> Notes it -> Notes ot -> Notes ('TLambda it ot)
forall (p :: T) (q :: T).
TypeAnn -> Notes p -> Notes q -> Notes ('TLambda p q)
NTLambda TypeAnn
forall a. Default a => a
def Notes it
ins Notes ot
onsr
      let lamSt :: Notes ot -> HST ('TLambda it ot : ts)
lamSt Notes ot
onsr = (Notes ot -> Notes ('TLambda it ot)
lamNotes Notes ot
onsr, Dict (WellTyped ('TLambda it ot))
forall (a :: Constraint). a => Dict a
Dict, VarAnn
vn) (Notes ('TLambda it ot), Dict (WellTyped ('TLambda it ot)), VarAnn)
-> HST ts -> HST ('TLambda it ot : ts)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(Notes x, Dict (WellTyped x), VarAnn) -> HST xs -> HST (x : xs)
::& HST ts
i
      (SomeInstrOut ts -> SomeInstr ts)
-> ReaderT InstrCallStack TypeCheck (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 InstrCallStack TypeCheck (SomeInstrOut ts)
 -> TypeCheckInstr (SomeInstr ts))
-> ReaderT InstrCallStack TypeCheck (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 HST out -> Either TCTypeError (out :~: '[ot])
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
                let (Notes x
ons', Dict (WellTyped x)
_, VarAnn
_) ::& HST xs
SNil = HST out
lo
                Notes ot
onsr <- ExpandedInstr
-> HST ts
-> Maybe TypeContext
-> Either AnnConvergeError (Notes ot)
-> ReaderT InstrCallStack TypeCheck (Notes ot)
forall (m :: * -> *) (ts :: [T]) a.
(MonadReader InstrCallStack m, MonadError TCError m, SingI ts) =>
ExpandedInstr
-> HST ts -> Maybe TypeContext -> Either AnnConvergeError a -> m a
onTypeCheckInstrAnnErr ExpandedInstr
instr HST ts
i (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaCode) (Notes ot -> Notes ot -> Either AnnConvergeError (Notes ot)
forall (t :: T).
Notes t -> Notes t -> Either AnnConvergeError (Notes t)
converge Notes ot
ons Notes ot
ons')
                pure (Value' Instr ('TLambda it ot) -> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (s :: [T]).
(SingI i, SingI o) =>
Value' Instr ('TLambda i o) -> Instr s ('TLambda i o : s)
LAMBDA (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
::: Notes ot -> HST ('TLambda it ot : ts)
lamSt Notes ot
onsr)
            Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT InstrCallStack TypeCheck (SomeInstrOut ts)
forall (m :: * -> *) a.
(MonadReader InstrCallStack 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 InstrCallStack TypeCheck (SomeInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value' Instr ('TLambda it ot) -> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (s :: [T]).
(SingI i, SingI o) =>
Value' Instr ('TLambda i o) -> Instr s ('TLambda i o : s)
LAMBDA (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
::: Notes ot -> HST ('TLambda it ot : ts)
lamSt Notes ot
ons)
  where
    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 :: ([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 <- ReaderT TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
-> ReaderT InstrCallStack TypeCheckNoExcept (TypeCheckedSeq inp)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
 -> ReaderT InstrCallStack TypeCheckNoExcept (TypeCheckedSeq inp))
-> ReaderT
     TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
-> ReaderT InstrCallStack TypeCheckNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ [ExpandedOp]
-> HST inp
-> ReaderT
     TypeCheckOptions (State TypeCheckEnv) (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept [ExpandedOp]
instructions HST inp
inputHST
  InstrCallStack
pos <- ReaderT InstrCallStack TypeCheckNoExcept InstrCallStack
forall r (m :: * -> *). MonadReader r m => m r
ask
  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
-> InstrCallStack
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
mainInstr
                                    (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inputHST)
                                    InstrCallStack
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)