module Morley.Michelson.TypeCheck.Instr
( typeCheckContract
, typeCheckContractAndStorage
, typeCheckInstr
, typeCheckList
, tcList
, typeCheckListNoExcept
, typeCheckParameter
, typeCheckStorage
, typeCheckTopLevelType
, typeCheckValue
, typeCheckValueRunCodeCompat
, typeVerifyContract
, typeVerifyParameter
, typeVerifyStorage
, typeVerifyTopLevelType
, typeVerifyView
) where
import Prelude hiding (EQ, GT, LT)
import Control.Monad.Except (MonadError, catchError, liftEither, throwError)
import Data.Constraint ((\\))
import Data.Default (def)
import Data.Generics (everything, mkQ)
import Data.Sequence ((|>))
import Data.Sequence qualified as Seq
import Data.Singletons (Sing, SomeSing(..), demote, withSingI, withSomeSing)
import Data.Type.Equality (TestEquality(..))
import Data.Typeable ((:~:)(..))
import Fmt (pretty)
import Morley.Michelson.TypeCheck.Error
import Morley.Michelson.TypeCheck.Ext
import Morley.Michelson.TypeCheck.Helpers
import Morley.Michelson.TypeCheck.TypeCheck
import Morley.Michelson.TypeCheck.TypeCheckedSeq
(IllTypedInstr(..), TypeCheckedInstr, TypeCheckedOp(..), TypeCheckedSeq(..), someInstrToOp,
someViewToOp, tcsEither)
import Morley.Michelson.TypeCheck.Types
import Morley.Michelson.TypeCheck.Value
import Morley.Michelson.Typed hiding (Branch(..))
import Morley.Michelson.Typed.Contract (giveNotInView)
import Morley.Util.MismatchError
import Morley.Util.Peano
import Morley.Util.PeanoNatural
import Morley.Util.Sing (SingIOne, withSingIOne)
import Morley.Util.Type (knownListFromSingI, onFirst, type (++))
import Morley.Michelson.Untyped qualified as U
import Morley.Michelson.Untyped.Annotation (VarAnn)
import Morley.Util.Peano qualified as Peano
typeCheckContractAndStorage
:: U.Contract -> U.Value -> TypeCheckResult SomeContractAndStorage
typeCheckContractAndStorage :: Contract -> Value -> TypeCheckResult SomeContractAndStorage
typeCheckContractAndStorage Contract
uContract Value
uStorage = do
SomeContract (contract :: Contract cp st
contract@Contract{} :: Contract cp st) <- Contract -> TypeCheckResult SomeContract
typeCheckContract Contract
uContract
Value st
storage <- forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeVerifyStorage @st Value
uStorage
pure $ Contract cp st -> Value st -> SomeContractAndStorage
forall (cp :: T) (st :: T).
(StorageScope st, ParameterScope cp) =>
Contract cp st -> Value st -> SomeContractAndStorage
SomeContractAndStorage Contract cp st
contract Value st
storage
typeCheckContract
:: U.Contract
-> TypeCheckResult SomeContract
typeCheckContract :: Contract -> TypeCheckResult SomeContract
typeCheckContract Contract
c = do
SomeParamType
paramType <- Either TCError SomeParamType
-> ReaderT
TypeCheckOptions (ExceptT TCError Identity) SomeParamType
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError SomeParamType
-> ReaderT
TypeCheckOptions (ExceptT TCError Identity) SomeParamType)
-> Either TCError SomeParamType
-> ReaderT
TypeCheckOptions (ExceptT TCError Identity) SomeParamType
forall a b. (a -> b) -> a -> b
$ ParameterType -> Either TCError SomeParamType
mkSomeParamType (Contract -> ParameterType
forall op. Contract' op -> ParameterType
U.contractParameter Contract
c)
TypeCheckMode
-> TypeCheck SomeContract -> TypeCheckResult SomeContract
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck (SomeParamType -> TypeCheckMode
TypeCheckContract SomeParamType
paramType) (TypeCheck SomeContract -> TypeCheckResult SomeContract)
-> TypeCheck SomeContract -> TypeCheckResult SomeContract
forall a b. (a -> b) -> a -> b
$ Contract -> TypeCheck SomeContract
typeCheckContractImpl Contract
c
typeVerifyContract
:: forall cp st.
(SingI cp, SingI st)
=> U.Contract -> TypeCheckResult (Contract cp st)
typeVerifyContract :: forall (cp :: T) (st :: T).
(SingI cp, SingI st) =>
Contract -> TypeCheckResult (Contract cp st)
typeVerifyContract Contract
uContract = do
SomeContract tContract :: Contract cp st
tContract@(Contract{} :: Contract cp' st') <-
Contract -> TypeCheckResult SomeContract
typeCheckContract Contract
uContract
cp :~: cp
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @cp' @cp (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
st :~: st
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @st' @st (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltStorageType)
Contract cp st
-> ReaderT
TypeCheckOptions (ExceptT TCError Identity) (Contract cp st)
forall (m :: * -> *) a. Monad m => a -> m a
return Contract cp st
tContract
where
mkErr :: TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr :: forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
tyDesc MismatchError T
merr =
TCError -> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) any)
-> TCError
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"error in contract type" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$
TopLevelType -> MismatchError T -> TCTypeError
UnexpectedTopLevelType TopLevelType
tyDesc MismatchError T
merr
withWTP :: forall t a. SingI t => (WellTyped t => TypeCheck a) -> TypeCheck a
withWTP :: forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP WellTyped t => TypeCheck a
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
Right Dict (WellTyped t)
Dict -> TypeCheck a
WellTyped t => TypeCheck a
fn
Left NotWellTyped
err -> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a)
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError (NotWellTyped -> Text
forall a b. (Buildable a, FromBuilder b) => a -> b
pretty NotWellTyped
err) Maybe TCTypeError
forall a. Maybe a
Nothing
withWTPInstr_ :: forall t a. SingI t => U.ExpandedInstr -> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ :: forall (t :: T) a.
SingI t =>
ExpandedInstr
-> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ ExpandedInstr
v SomeHST
t WellTyped t => TypeCheckInstr a
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
Right Dict (WellTyped t)
Dict -> TypeCheckInstr a
WellTyped t => TypeCheckInstr a
fn
Left (NotWellTyped T
badType BadTypeForScope
cause) -> do
ErrorSrcPos
loc <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
TCError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
a)
-> TCError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
a
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
v SomeHST
t ErrorSrcPos
loc Maybe TypeContext
forall a. Maybe a
Nothing (TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope T
badType BadTypeForScope
cause)
withWTPInstr'_
:: forall t inp. SingI t
=> U.ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ :: forall (t :: T) (inp :: [T]).
SingI t =>
ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ ExpandedInstr
v SomeHST
t WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp)
fn = case forall (t :: T).
SingI t =>
Either NotWellTyped (Dict (WellTyped t))
getWTP @t of
Right Dict (WellTyped t)
Dict -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp)
fn
Left (NotWellTyped T
badType BadTypeForScope
cause) -> do
ErrorSrcPos
loc <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
let err :: TCError
err = ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
v SomeHST
t ErrorSrcPos
loc Maybe TypeContext
forall a. Maybe a
Nothing
(TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope T
badType BadTypeForScope
cause)
TypeCheckedSeq inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> TypeCheckedSeq inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq TCError
err [ExpandedOp -> IllTypedInstr
NonTypedInstr (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> ExpandedOp
U.PrimEx ExpandedInstr
v]
typeCheckContractImpl
:: U.Contract
-> TypeCheck SomeContract
typeCheckContractImpl :: Contract -> TypeCheck SomeContract
typeCheckContractImpl uContract :: Contract
uContract@(U.Contract wholeParam :: ParameterType
wholeParam@(U.ParameterType Ty
mParam RootAnn
rootAnn) Ty
mStorage [ExpandedOp]
pCode EntriesOrder
entriesOrder [View' ExpandedOp]
uViews) = do
NonEmpty ExpandedOp
_ <- ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp)
-> (NonEmpty ExpandedOp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp))
-> Maybe (NonEmpty ExpandedOp)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp))
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"no instructions in contract code" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
EmptyCode)
NonEmpty ExpandedOp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(NonEmpty ExpandedOp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ExpandedOp] -> Maybe (NonEmpty ExpandedOp)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty [ExpandedOp]
pCode)
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mParam ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
paramNote :: Notes param) ->
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mStorage ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall a b. (a -> b) -> a -> b
$ \(Notes t
storageNote :: Notes st) -> do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @st ((WellTyped t => TypeCheck SomeContract) -> TypeCheck SomeContract)
-> (WellTyped t => TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @param ((WellTyped t => TypeCheck SomeContract) -> TypeCheck SomeContract)
-> (WellTyped t => TypeCheck SomeContract)
-> TypeCheck SomeContract
forall a b. (a -> b) -> a -> b
$ do
Dict (ParameterScope t)
Dict <- (BadTypeForScope
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ParameterScope t)))
-> (Dict (ParameterScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ParameterScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @param Text
"parameter") Dict (ParameterScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ParameterScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ParameterScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope param)
Dict (StorageScope t)
Dict <- (BadTypeForScope
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (StorageScope t)))
-> (Dict (StorageScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (StorageScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @st Text
"storage") Dict (StorageScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (StorageScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (StorageScope t)))
-> Either BadTypeForScope (Dict (StorageScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (StorageScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(StorageScope st)
let inp :: HST '[ 'TPair t t]
inp = (forall {k} (a :: k). SingI a => Sing a
forall (a :: T). SingI a => Sing a
sing @('TPair param st), Dict (WellTyped ('TPair t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair t t), Dict (WellTyped ('TPair t t)))
-> HST '[] -> HST '[ 'TPair t t]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil
TypeCheckedSeq '[ 'TPair t t]
codeRes <-
TypeCheckInstrEnv
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TypeCheckedSeq '[ 'TPair t t])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(TypeCheckedSeq '[ 'TPair t t])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TypeCheckedSeq '[ 'TPair t t])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(TypeCheckedSeq '[ 'TPair t t]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TypeCheckedSeq '[ 'TPair t t])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(TypeCheckedSeq '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[ 'TPair t t])
-> ChangeMultiReaderBase
(ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
(ExceptT TCError Identity)
(TypeCheckedSeq '[ 'TPair t t])
forall (m :: * -> *) e a.
MonadMultiReaderT m Identity =>
m a -> ChangeMultiReaderBase m (Except e) a
liftNoExcept (ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[ 'TPair t t])
-> ChangeMultiReaderBase
(ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
(ExceptT TCError Identity)
(TypeCheckedSeq '[ 'TPair t t]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[ 'TPair t t])
-> ChangeMultiReaderBase
(ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
(ExceptT TCError Identity)
(TypeCheckedSeq '[ 'TPair t t])
forall a b. (a -> b) -> a -> b
$
TcInstrHandler
-> [ExpandedOp]
-> HST '[ 'TPair t t]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t t])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl
((IsNotInView =>
ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> (IsNotInView =>
ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter
TypeCheckInstrEnv
TypeCheckInstrEnv
(Maybe (Dict IsNotInView))
(Maybe (Dict IsNotInView))
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
TypeCheckInstrEnv
TypeCheckInstrEnv
(Maybe (Dict IsNotInView))
(Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView (Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall a b. (a -> b) -> a -> b
$ Dict IsNotInView -> Maybe (Dict IsNotInView)
forall a. a -> Maybe a
Just Dict IsNotInView
forall (a :: Constraint). a => Dict a
Dict) (ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> (ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall a b c. SuperComposition a b c => a -> b -> c
... ExpandedInstr
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
TcInstrHandler
typeCheckInstr)
[ExpandedOp]
pCode
HST '[ 'TPair t t]
inp
instr :: SomeInstr '[ 'TPair t t]
instr@(HST '[ 'TPair t t]
_ :/ SomeInstrOut '[ 'TPair t t]
instrOut) <-
([TypeCheckedOp]
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t t]))
-> (SomeInstr '[ 'TPair t t]
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t t]))
-> TypeCheckedSeq '[ 'TPair t t]
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t t])
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither [TypeCheckedOp]
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t t])
forall a. [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedCodeTypeCheck SomeInstr '[ 'TPair t t]
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t t])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq '[ 'TPair t t]
codeRes
[SomeView t]
views <- Contract' TypeCheckedOp
-> Notes t -> [View' ExpandedOp] -> TypeCheck [SomeView t]
forall (st :: T).
WellTyped st =>
Contract' TypeCheckedOp
-> Notes st -> [View' ExpandedOp] -> TypeCheck [SomeView st]
typeCheckViewsImpl
Contract
uContract{ contractCode :: [TypeCheckedOp]
U.contractCode = [SomeInstr '[ 'TPair t t] -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr '[ 'TPair t t]
instr], contractViews :: [View' TypeCheckedOp]
U.contractViews = [] }
Notes t
storageNote [View' ExpandedOp]
uViews
(TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall e (m :: * -> *) a.
MonadError e m =>
(e -> m a) -> m a -> m a
handleError ([TypeCheckedOp]
-> [View' TypeCheckedOp] -> TCError -> TypeCheck SomeContract
forall a.
[TypeCheckedOp] -> [View' TypeCheckedOp] -> TCError -> TypeCheck a
onFailedFullTypeCheck [SomeInstr '[ 'TPair t t] -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr '[ 'TPair t t]
instr] ((View' ExpandedOp -> SomeView t -> View' TypeCheckedOp)
-> [View' ExpandedOp] -> [SomeView t] -> [View' TypeCheckedOp]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith View' ExpandedOp -> SomeView t -> View' TypeCheckedOp
forall op (st :: T). View' op -> SomeView st -> View' TypeCheckedOp
someViewToOp [View' ExpandedOp]
uViews [SomeView t]
views)) (ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall a b. (a -> b) -> a -> b
$ do
let cStoreNotes :: Notes t
cStoreNotes = Notes t
storageNote
ParamNotes t
cParamNotes <-
Either TCError (ParamNotes t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(ParamNotes t)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError (ParamNotes t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(ParamNotes t))
-> Either TCError (ParamNotes t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(ParamNotes t)
forall a b. (a -> b) -> a -> b
$
Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)
forall (t :: T).
Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)
mkParamNotes Notes t
paramNote RootAnn
rootAnn Either ParamEpError (ParamNotes t)
-> (ParamEpError -> TCError) -> Either TCError (ParamNotes t)
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst`
(Text -> Maybe TCTypeError -> TCError
TCContractError Text
"invalid parameter declaration: " (Maybe TCTypeError -> TCError)
-> (ParamEpError -> Maybe TCTypeError) -> ParamEpError -> TCError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> (ParamEpError -> TCTypeError)
-> ParamEpError
-> Maybe TCTypeError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParamEpError -> TCTypeError
IllegalParamDecl)
let cEntriesOrder :: EntriesOrder
cEntriesOrder = EntriesOrder
entriesOrder
ViewsSet' Instr t
cViews <- Either TCError (ViewsSet' Instr t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(ViewsSet' Instr t)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError (ViewsSet' Instr t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(ViewsSet' Instr t))
-> Either TCError (ViewsSet' Instr t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(ViewsSet' Instr t)
forall a b. (a -> b) -> a -> b
$
[SomeView t] -> Either ViewsSetError (ViewsSet' Instr t)
forall (instr :: [T] -> [T] -> *) (st :: T).
[SomeView' instr st] -> Either ViewsSetError (ViewsSet' instr st)
mkViewsSet [SomeView t]
views Either ViewsSetError (ViewsSet' Instr t)
-> (ViewsSetError -> TCError) -> Either TCError (ViewsSet' Instr t)
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` \ViewsSetError
e -> Text -> Maybe TCTypeError -> TCError
TCContractError (ViewsSetError -> Text
forall a b. (Buildable a, FromBuilder b) => a -> b
pretty ViewsSetError
e) Maybe TCTypeError
forall a. Maybe a
Nothing
case SomeInstrOut '[ 'TPair t t]
instrOut of
Instr '[ 'TPair t t] out
instr' ::: HST out
out -> Either TCError SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither (Either TCError SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> Either TCError SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall a b. (a -> b) -> a -> b
$ do
case forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @('TPair ('TList 'TOperation) st) HST out
out of
Right out :~: '[ 'TPair ('TList 'TOperation) t]
Refl ->
SomeContract -> Either TCError SomeContract
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeContract -> Either TCError SomeContract)
-> SomeContract -> Either TCError SomeContract
forall a b. (a -> b) -> a -> b
$ Contract t t -> SomeContract
forall (cp :: T) (st :: T). Contract cp st -> SomeContract
SomeContract Contract :: forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode' instr cp st
-> ParamNotes cp
-> Notes st
-> ViewsSet' instr st
-> EntriesOrder
-> Contract' instr cp st
Contract{ cCode :: ContractCode' Instr t t
cCode = Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
-> ContractCode' Instr t t
forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
instr (ContractInp cp st) (ContractOut st)
-> ContractCode' instr cp st
ContractCode Instr '[ 'TPair t t] out
Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
instr', EntriesOrder
Notes t
ViewsSet' Instr t
ParamNotes t
cEntriesOrder :: EntriesOrder
cViews :: ViewsSet' Instr t
cStoreNotes :: Notes t
cParamNotes :: ParamNotes t
cViews :: ViewsSet' Instr t
cEntriesOrder :: EntriesOrder
cParamNotes :: ParamNotes t
cStoreNotes :: Notes t
.. }
Left TCTypeError
err ->
TCError -> Either TCError SomeContract
forall a b. a -> Either a b
Left (TCError -> Either TCError SomeContract)
-> TCError -> Either TCError SomeContract
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"contract output type violates convention:" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
err
AnyOutInstr forall (out :: [T]). Instr '[ 'TPair t t] out
instr' ->
SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract)
-> SomeContract
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
forall a b. (a -> b) -> a -> b
$ Contract t t -> SomeContract
forall (cp :: T) (st :: T). Contract cp st -> SomeContract
SomeContract Contract :: forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
(ParameterScope cp, StorageScope st) =>
ContractCode' instr cp st
-> ParamNotes cp
-> Notes st
-> ViewsSet' instr st
-> EntriesOrder
-> Contract' instr cp st
Contract{ cCode :: ContractCode' Instr t t
cCode = Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
-> ContractCode' Instr t t
forall (instr :: [T] -> [T] -> *) (cp :: T) (st :: T).
instr (ContractInp cp st) (ContractOut st)
-> ContractCode' instr cp st
ContractCode Instr '[ 'TPair t t] '[ 'TPair ('TList 'TOperation) t]
forall (out :: [T]). Instr '[ 'TPair t t] out
instr', EntriesOrder
Notes t
ViewsSet' Instr t
ParamNotes t
cEntriesOrder :: EntriesOrder
cViews :: ViewsSet' Instr t
cStoreNotes :: Notes t
cParamNotes :: ParamNotes t
cViews :: ViewsSet' Instr t
cEntriesOrder :: EntriesOrder
cParamNotes :: ParamNotes t
cStoreNotes :: Notes t
.. }
where
hasTypeError :: forall (t :: T) a. SingI t => Text -> BadTypeForScope -> TypeCheck a
hasTypeError :: forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError Text
name BadTypeForScope
reason = TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a)
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall a b. (a -> b) -> a -> b
$
Text -> Maybe TCTypeError -> TCError
TCContractError (Text
"contract " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
name Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" type error") (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$
TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope (forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) BadTypeForScope
reason
onFailedCodeTypeCheck :: [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedCodeTypeCheck :: forall a. [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedCodeTypeCheck [TypeCheckedOp]
ops TCError
err = do
Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
then TCError -> Contract' TypeCheckedOp -> TCError
TCIncompletelyTyped TCError
err Contract :: forall op.
ParameterType
-> Ty -> [op] -> EntriesOrder -> [View' op] -> Contract' op
U.Contract
{ contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
, contractStorage :: Ty
contractStorage = Ty
mStorage
, contractCode :: [TypeCheckedOp]
contractCode = [TypeCheckedOp]
ops
, entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
, contractViews :: [View' TypeCheckedOp]
contractViews = []
}
else TCError
err
onFailedFullTypeCheck :: [TypeCheckedOp] -> [U.View' TypeCheckedOp] -> TCError -> TypeCheck a
onFailedFullTypeCheck :: forall a.
[TypeCheckedOp] -> [View' TypeCheckedOp] -> TCError -> TypeCheck a
onFailedFullTypeCheck [TypeCheckedOp]
ops [View' TypeCheckedOp]
views TCError
err = do
Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
then TCError -> Contract' TypeCheckedOp -> TCError
TCIncompletelyTyped TCError
err Contract :: forall op.
ParameterType
-> Ty -> [op] -> EntriesOrder -> [View' op] -> Contract' op
U.Contract
{ contractParameter :: ParameterType
contractParameter = ParameterType
wholeParam
, contractStorage :: Ty
contractStorage = Ty
mStorage
, contractCode :: [TypeCheckedOp]
contractCode = [TypeCheckedOp]
ops
, entriesOrder :: EntriesOrder
entriesOrder = EntriesOrder
entriesOrder
, contractViews :: [View' TypeCheckedOp]
contractViews = [View' TypeCheckedOp]
views
}
else TCError
err
typeVerifyView
:: forall arg ret st.
(SingI arg, SingI ret, WellTyped st)
=> Notes st -> U.View -> TypeCheckResult (View arg st ret)
typeVerifyView :: forall (arg :: T) (ret :: T) (st :: T).
(SingI arg, SingI ret, WellTyped st) =>
Notes st -> View' ExpandedOp -> TypeCheckResult (View arg st ret)
typeVerifyView Notes st
notes View' ExpandedOp
v = do
SomeView (tcView :: View' Instr arg st ret
tcView@View{} :: View arg' st' ret') <-
TypeCheckMode
-> TypeCheck (SomeView' Instr st)
-> TypeCheckResult (SomeView' Instr st)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck TypeCheckMode
TypeCheckTest (TypeCheck (SomeView' Instr st)
-> TypeCheckResult (SomeView' Instr st))
-> TypeCheck (SomeView' Instr st)
-> TypeCheckResult (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ Notes st -> View' ExpandedOp -> TypeCheck (SomeView' Instr st)
forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
notes View' ExpandedOp
v
arg :~: arg
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @arg' @arg (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
st :~: st
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @st' @st (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltStorageType)
ret :~: ret
Refl <- forall (a :: T) (b :: T) (m :: * -> *).
(SingI a, SingI b, Monad m) =>
(forall x. MismatchError T -> m x) -> m (a :~: b)
requireEq @ret' @ret (TopLevelType -> MismatchError T -> TypeCheckResult x
forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
TltParameterType)
View' Instr arg st ret
-> ReaderT
TypeCheckOptions
(ExceptT TCError Identity)
(View' Instr arg st ret)
forall (m :: * -> *) a. Monad m => a -> m a
return View' Instr arg st ret
tcView
where
mkErr :: TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr :: forall any. TopLevelType -> MismatchError T -> TypeCheckResult any
mkErr TopLevelType
tyDesc MismatchError T
merr =
TCError -> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) any)
-> TCError
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) any
forall a b. (a -> b) -> a -> b
$ Text -> Maybe TCTypeError -> TCError
TCContractError Text
"error in view type" (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$ TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$
TopLevelType -> MismatchError T -> TCTypeError
UnexpectedTopLevelType TopLevelType
tyDesc MismatchError T
merr
typeCheckViewImpl :: WellTyped st => Notes st -> U.View -> TypeCheck (SomeView st)
typeCheckViewImpl :: forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
storageNote
uView :: View' ExpandedOp
uView@U.View
{ viewArgument :: forall op. View' op -> Ty
U.viewArgument = AsUType (Notes t
argNote :: Notes param)
, viewReturn :: forall op. View' op -> Ty
U.viewReturn = AsUType (Notes t
returnNote :: Notes ret)
, viewCode :: forall op. View' op -> [op]
U.viewCode = [ExpandedOp]
uInstr
, viewName :: forall op. View' op -> ViewName
U.viewName = ViewName
viewName
}
= forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @param ((WellTyped t =>
MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st))
-> MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st))
-> (WellTyped t =>
MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st))
-> MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheck a) -> TypeCheck a
withWTP @ret ((WellTyped t =>
MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st))
-> MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st))
-> (WellTyped t =>
MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st))
-> MultiReaderT
'[TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ do
let inp :: HST '[ 'TPair t st]
inp = (Sing t -> Sing st -> SingT ('TPair t st)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
argNote) (Notes st -> Sing st
forall (t :: T). Notes t -> Sing t
notesSing Notes st
storageNote), Dict (WellTyped ('TPair t st))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair t st), Dict (WellTyped ('TPair t st)))
-> HST '[] -> HST '[ 'TPair t st]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil
Dict (ViewableScope t)
Dict <-
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope param)
Either BadTypeForScope (Dict (ViewableScope t))
-> (Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t)))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t)))
-> (Dict (ViewableScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @param Text
"parameter") Dict (ViewableScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Dict (ViewableScope t)
Dict <-
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope ret)
Either BadTypeForScope (Dict (ViewableScope t))
-> (Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t)))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t))
forall a b. a -> (a -> b) -> b
& (BadTypeForScope
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t)))
-> (Dict (ViewableScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t))
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError @ret Text
"return") Dict (ViewableScope t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Dict (ViewableScope t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
TypeCheckedSeq '[ 'TPair t st]
codeRes <-
TypeCheckInstrEnv
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(TypeCheckedSeq '[ 'TPair t st])
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(TypeCheckedSeq '[ 'TPair t st]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TypeCheckedSeq '[ 'TPair t st])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(TypeCheckedSeq '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[ 'TPair t st])
-> ChangeMultiReaderBase
(ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
(ExceptT TCError Identity)
(TypeCheckedSeq '[ 'TPair t st])
forall (m :: * -> *) e a.
MonadMultiReaderT m Identity =>
m a -> ChangeMultiReaderBase m (Except e) a
liftNoExcept (ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[ 'TPair t st])
-> ChangeMultiReaderBase
(ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
(ExceptT TCError Identity)
(TypeCheckedSeq '[ 'TPair t st]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[ 'TPair t st])
-> ChangeMultiReaderBase
(ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity)))
(ExceptT TCError Identity)
(TypeCheckedSeq '[ 'TPair t st])
forall a b. (a -> b) -> a -> b
$
TcInstrHandler
-> [ExpandedOp]
-> HST '[ 'TPair t st]
-> TypeCheckInstrNoExcept (TypeCheckedSeq '[ 'TPair t st])
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr [ExpandedOp]
uInstr HST '[ 'TPair t st]
inp
HST '[ 'TPair t st]
_ :/ SomeInstrOut '[ 'TPair t st]
instrOut <-
([TypeCheckedOp]
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t st]))
-> (SomeInstr '[ 'TPair t st]
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t st]))
-> TypeCheckedSeq '[ 'TPair t st]
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t st])
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither (View' ExpandedOp
-> [TypeCheckedOp]
-> TCError
-> TypeCheck (SomeInstr '[ 'TPair t st])
forall a.
View' ExpandedOp -> [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedViewsTypeCheck View' ExpandedOp
uView) SomeInstr '[ 'TPair t st]
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr '[ 'TPair t st])
forall (f :: * -> *) a. Applicative f => a -> f a
pure TypeCheckedSeq '[ 'TPair t st]
codeRes
let vName :: ViewName
vName = ViewName
viewName
vArgument :: Notes t
vArgument = Notes t
argNote
vReturn :: Notes t
vReturn = Notes t
returnNote
case SomeInstrOut '[ 'TPair t st]
instrOut of
Instr '[ 'TPair t st] out
instr ::: HST out
out -> Either TCError (SomeView' Instr st)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeView' Instr st)
forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither do
out :~: '[t]
Refl <- forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @ret HST out
out
Either TCTypeError (out :~: '[t])
-> (TCTypeError -> TCError) -> Either TCError (out :~: '[t])
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` (Text -> ViewName -> Maybe TCTypeError -> TCError
TCViewError Text
"view return type mismatch:" ViewName
viewName (Maybe TCTypeError -> TCError)
-> (TCTypeError -> Maybe TCTypeError) -> TCTypeError -> TCError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just)
SomeView' Instr st -> Either TCError (SomeView' Instr st)
forall (m :: * -> *) a. Monad m => a -> m a
return (SomeView' Instr st -> Either TCError (SomeView' Instr st))
-> SomeView' Instr st -> Either TCError (SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ View' Instr t st t -> SomeView' Instr st
forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> SomeView' instr st
SomeView View :: forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
(ViewableScope arg, SingI st, ViewableScope ret) =>
ViewName
-> Notes arg
-> Notes ret
-> ViewCode' instr arg st ret
-> View' instr arg st ret
View{ vCode :: ViewCode' Instr t st t
vCode = Instr '[ 'TPair t st] out
ViewCode' Instr t st t
instr, ViewName
Notes t
Notes t
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
.. }
AnyOutInstr forall (out :: [T]). Instr '[ 'TPair t st] out
instr ->
SomeView' Instr st
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeView' Instr st)
forall (m :: * -> *) a. Monad m => a -> m a
return (SomeView' Instr st
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeView' Instr st))
-> SomeView' Instr st
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeView' Instr st)
forall a b. (a -> b) -> a -> b
$ View' Instr t st t -> SomeView' Instr st
forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> SomeView' instr st
SomeView View :: forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
(ViewableScope arg, SingI st, ViewableScope ret) =>
ViewName
-> Notes arg
-> Notes ret
-> ViewCode' instr arg st ret
-> View' instr arg st ret
View{ vCode :: ViewCode' Instr t st t
vCode = ViewCode' Instr t st t
forall (out :: [T]). Instr '[ 'TPair t st] out
instr, ViewName
Notes t
Notes t
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
vReturn :: Notes t
vArgument :: Notes t
vName :: ViewName
.. }
where
onFailedViewsTypeCheck
:: U.View -> [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedViewsTypeCheck :: forall a.
View' ExpandedOp -> [TypeCheckedOp] -> TCError -> TypeCheck a
onFailedViewsTypeCheck View' ExpandedOp
v [TypeCheckedOp]
viewOps TCError
err = do
Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
then TCError -> View' TypeCheckedOp -> TCError
TCIncompletelyTypedView TCError
err View' ExpandedOp
v{ viewCode :: [TypeCheckedOp]
U.viewCode = [TypeCheckedOp]
viewOps }
else TCError
err
hasTypeError :: forall (t :: T) a. SingI t => Text -> BadTypeForScope -> TypeCheck a
hasTypeError :: forall (t :: T) a.
SingI t =>
Text -> BadTypeForScope -> TypeCheck a
hasTypeError Text
desc BadTypeForScope
reason = TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a)
-> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall a b. (a -> b) -> a -> b
$
Text -> ViewName -> Maybe TCTypeError -> TCError
TCViewError (Text
desc Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" type error in view") ViewName
viewName (Maybe TCTypeError -> TCError) -> Maybe TCTypeError -> TCError
forall a b. (a -> b) -> a -> b
$
TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just (TCTypeError -> Maybe TCTypeError)
-> TCTypeError -> Maybe TCTypeError
forall a b. (a -> b) -> a -> b
$ T -> BadTypeForScope -> TCTypeError
UnsupportedTypeForScope (forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) BadTypeForScope
reason
typeCheckViewsImpl
:: (WellTyped st)
=> U.Contract' TypeCheckedOp -> Notes st -> [U.View] -> TypeCheck [SomeView st]
typeCheckViewsImpl :: forall (st :: T).
WellTyped st =>
Contract' TypeCheckedOp
-> Notes st -> [View' ExpandedOp] -> TypeCheck [SomeView st]
typeCheckViewsImpl Contract' TypeCheckedOp
tcCotract Notes st
storageNote [View' ExpandedOp]
cViews =
let myfoldM :: t a -> b -> (b -> a -> m b) -> m b
myfoldM t a
l b
acc b -> a -> m b
f = (b -> a -> m b) -> b -> t a -> m b
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM b -> a -> m b
f b
acc t a
l in
(Seq (View' ExpandedOp, SomeView st) -> [SomeView st])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
[SomeView st]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((View' ExpandedOp, SomeView st) -> SomeView st)
-> [(View' ExpandedOp, SomeView st)] -> [SomeView st]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (View' ExpandedOp, SomeView st) -> SomeView st
forall a b. (a, b) -> b
snd ([(View' ExpandedOp, SomeView st)] -> [SomeView st])
-> (Seq (View' ExpandedOp, SomeView st)
-> [(View' ExpandedOp, SomeView st)])
-> Seq (View' ExpandedOp, SomeView st)
-> [SomeView st]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq (View' ExpandedOp, SomeView st)
-> [(View' ExpandedOp, SomeView st)]
forall t. Container t => t -> [Element t]
toList) (ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
[SomeView st])
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
[SomeView st]
forall a b. (a -> b) -> a -> b
$ [View' ExpandedOp]
-> Seq (View' ExpandedOp, SomeView st)
-> (Seq (View' ExpandedOp, SomeView st)
-> View' ExpandedOp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st)))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
forall {t :: * -> *} {m :: * -> *} {a} {b}.
(Foldable t, Monad m) =>
t a -> b -> (b -> a -> m b) -> m b
myfoldM [View' ExpandedOp]
cViews (forall a. Seq a
forall {st :: T}. Seq (View' ExpandedOp, SomeView st)
Seq.Empty :: Seq (U.View, SomeView st))
\Seq (View' ExpandedOp, SomeView st)
processedViews View' ExpandedOp
uView -> do
SomeView st
resView <- Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
forall (st :: T).
WellTyped st =>
Notes st -> View' ExpandedOp -> TypeCheck (SomeView st)
typeCheckViewImpl Notes st
storageNote View' ExpandedOp
uView
pure $ Seq (View' ExpandedOp, SomeView st)
processedViews Seq (View' ExpandedOp, SomeView st)
-> (View' ExpandedOp, SomeView st)
-> Seq (View' ExpandedOp, SomeView st)
forall a. Seq a -> a -> Seq a
|> (View' ExpandedOp
uView, SomeView st
resView)
ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
-> (TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st)))
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` \case
TCIncompletelyTypedView TCError
err View' TypeCheckedOp
view' ->
let tcViews :: Seq (View' TypeCheckedOp)
tcViews = ((View' ExpandedOp, SomeView st) -> View' TypeCheckedOp)
-> Seq (View' ExpandedOp, SomeView st) -> Seq (View' TypeCheckedOp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map ((View' ExpandedOp -> SomeView st -> View' TypeCheckedOp)
-> (View' ExpandedOp, SomeView st) -> View' TypeCheckedOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry View' ExpandedOp -> SomeView st -> View' TypeCheckedOp
forall op (st :: T). View' op -> SomeView st -> View' TypeCheckedOp
someViewToOp) Seq (View' ExpandedOp, SomeView st)
processedViews
in Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp
-> TCError
-> TypeCheck (Seq (View' ExpandedOp, SomeView st))
forall a.
Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp -> TCError -> TypeCheck a
onFailedViewsTypeCheck Seq (View' TypeCheckedOp)
tcViews View' TypeCheckedOp
view' TCError
err
TCError
err -> TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Seq (View' ExpandedOp, SomeView st))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError TCError
err
where
onFailedViewsTypeCheck
:: Seq (U.View' TypeCheckedOp) -> U.View' TypeCheckedOp -> TCError -> TypeCheck a
onFailedViewsTypeCheck :: forall a.
Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp -> TCError -> TypeCheck a
onFailedViewsTypeCheck Seq (View' TypeCheckedOp)
processedViews View' TypeCheckedOp
v TCError
err = do
Bool
verbose <- (TypeCheckOptions -> Bool)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
Bool
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckOptions -> Bool
tcVerbose
TCError
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError if Bool
verbose
then TCError -> Contract' TypeCheckedOp -> TCError
TCIncompletelyTyped TCError
err Contract' TypeCheckedOp
tcCotract
{ contractViews :: [View' TypeCheckedOp]
U.contractViews = Seq (View' TypeCheckedOp) -> [Element (Seq (View' TypeCheckedOp))]
forall t. Container t => t -> [Element t]
toList (Seq (View' TypeCheckedOp)
processedViews Seq (View' TypeCheckedOp)
-> View' TypeCheckedOp -> Seq (View' TypeCheckedOp)
forall a. Seq a -> a -> Seq a
|> View' TypeCheckedOp
v)
}
else TCError
err
typeCheckList
:: (SingI inp)
=> [U.ExpandedOp]
-> HST inp
-> TypeCheck (SomeInstr inp)
typeCheckList :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheck (SomeInstr inp)
typeCheckList = ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr inp)
forall (m :: * -> *) (m' :: * -> *) (inp :: [T]).
(MonadMultiReaderT m Identity,
m' ~ ChangeMultiReaderBase m (ExceptT TCError Identity),
MonadError TCError m') =>
m (TypeCheckedSeq inp) -> m' (SomeInstr inp)
throwingTCError (ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr inp))
-> ([ExpandedOp]
-> HST inp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp))
-> [ExpandedOp]
-> HST inp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(SomeInstr inp)
forall a b c. SuperComposition a b c => a -> b -> c
... [ExpandedOp]
-> HST inp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept
typeCheckListNoExcept
:: (SingI inp)
=> [U.ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp] -> HST inp -> TypeCheckNoExcept (TypeCheckedSeq inp)
typeCheckListNoExcept = TypeCheckInstrEnv
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp))
-> ([ExpandedOp]
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp))
-> [ExpandedOp]
-> HST inp
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions Identity)
(TypeCheckedSeq inp)
forall a b c. SuperComposition a b c => a -> b -> c
... TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr
typeCheckValue
:: forall t. SingI t
=> U.Value
-> TypeCheckResult (Value t)
typeCheckValue :: forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeCheckValue Value
value = do
TypeCheckMode -> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
value, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) Maybe BigMapFinder
forall a. Maybe a
Nothing) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$
TypeCheckInstrEnv
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t)
forall a b. (a -> b) -> a -> b
$
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr Value
value
typeCheckValueRunCodeCompat :: forall t. SingI t => BigMapFinder -> U.Value -> TypeCheckResult (Value t)
typeCheckValueRunCodeCompat :: forall (t :: T).
SingI t =>
BigMapFinder -> Value -> TypeCheckResult (Value t)
typeCheckValueRunCodeCompat BigMapFinder
bigMapFinder Value
val =
TypeCheckMode -> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
val, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) (BigMapFinder -> Maybe BigMapFinder
forall a. a -> Maybe a
Just BigMapFinder
bigMapFinder)) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$
TypeCheckInstrEnv
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t)
forall a b. (a -> b) -> a -> b
$
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr Value
val
typeVerifyParameter
:: SingI t
=> TcOriginatedContracts -> U.Value -> TypeCheckResult (Value t)
typeVerifyParameter :: forall (t :: T).
SingI t =>
TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyParameter TcOriginatedContracts
originatedContracts = Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType (TcOriginatedContracts -> Maybe TcOriginatedContracts
forall a. a -> Maybe a
Just TcOriginatedContracts
originatedContracts)
typeVerifyStorage
:: SingI t
=> U.Value -> TypeCheckResult (Value t)
typeVerifyStorage :: forall (t :: T). SingI t => Value -> TypeCheckResult (Value t)
typeVerifyStorage = Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType Maybe TcOriginatedContracts
forall a. Maybe a
Nothing
typeVerifyTopLevelType
:: forall t. SingI t
=> Maybe TcOriginatedContracts -> U.Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType :: forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType Maybe TcOriginatedContracts
mOriginatedContracts Value
valueU =
TypeCheckMode -> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a. TypeCheckMode -> TypeCheck a -> TypeCheckResult a
runTypeCheck ((Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
valueU, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) Maybe BigMapFinder
forall a. Maybe a
Nothing) (TypeCheck (Value t) -> TypeCheckResult (Value t))
-> TypeCheck (Value t) -> TypeCheckResult (Value t)
forall a b. (a -> b) -> a -> b
$ TypeCheckInstrEnv
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t)
forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
usingReaderT TypeCheckInstrEnv
forall a. Default a => a
def (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
(Value t)
forall a b. (a -> b) -> a -> b
$
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value t)
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl Maybe TcOriginatedContracts
mOriginatedContracts TcInstrHandler
typeCheckInstr Value
valueU
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)
typeCheckStorage
:: U.Ty -> U.Value -> TypeCheckResult SomeValue
typeCheckStorage :: Ty -> Value -> TypeCheckResult SomeValue
typeCheckStorage = Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult SomeValue
typeCheckTopLevelType Maybe TcOriginatedContracts
forall a. Maybe a
Nothing
typeCheckTopLevelType
:: Maybe TcOriginatedContracts -> U.Ty -> U.Value -> TypeCheckResult SomeValue
typeCheckTopLevelType :: Maybe TcOriginatedContracts
-> Ty -> Value -> TypeCheckResult SomeValue
typeCheckTopLevelType Maybe TcOriginatedContracts
mOriginatedContracts Ty
typeU Value
valueU =
Demote T
-> (forall (a :: T). Sing a -> TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall k r.
SingKind k =>
Demote k -> (forall (a :: k). Sing a -> r) -> r
withSomeSing (Ty -> T
fromUType Ty
typeU) ((forall (a :: T). Sing a -> TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue)
-> (forall (a :: T). Sing a -> TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall a b. (a -> b) -> a -> b
$ \(Sing a
s :: Sing t) ->
Sing a
-> (SingI a => TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a => TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue)
-> (SingI a => TypeCheckResult SomeValue)
-> TypeCheckResult SomeValue
forall a b. (a -> b) -> a -> b
$ Value a -> SomeValue
forall (t :: T). SingI t => Value t -> SomeValue
SomeValue (Value a -> SomeValue)
-> ReaderT TypeCheckOptions (ExceptT TCError Identity) (Value a)
-> TypeCheckResult SomeValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: T).
SingI t =>
Maybe TcOriginatedContracts -> Value -> TypeCheckResult (Value t)
typeVerifyTopLevelType @t Maybe TcOriginatedContracts
mOriginatedContracts Value
valueU
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
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
data TCDigHelper inp where
TCDigHelper ::
forall (n :: Peano) inp out a.
(SingI out, ConstraintDIG n inp out a) =>
PeanoNatural n -> HST out -> TCDigHelper inp
data TCDugHelper inp where
TCDugHelper ::
forall (n :: Peano) inp out a.
(SingI out, ConstraintDUG n inp out a) =>
PeanoNatural n -> HST out -> TCDugHelper inp
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
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)
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)
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)
workOnInstr
:: U.ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr :: forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
instr = (TCError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
Identity
(TypeCheckedSeq s))
-> (SomeInstr s
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
Identity
(TypeCheckedSeq s))
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(SomeInstr s)
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
Identity
(TypeCheckedSeq s)
forall a b.
(TCError -> TypeCheckInstrNoExcept a)
-> (b -> TypeCheckInstrNoExcept a)
-> TypeCheckInstr b
-> TypeCheckInstrNoExcept a
tcEither
(\TCError
err -> TypeCheckedSeq s
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq s
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq s))
-> TypeCheckedSeq s
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq s)
forall a b. (a -> b) -> a -> b
$ TCError -> [IllTypedInstr] -> TypeCheckedSeq s
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq TCError
err [ExpandedOp -> IllTypedInstr
NonTypedInstr (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> ExpandedOp
U.PrimEx ExpandedInstr
instr])
(TypeCheckedSeq s
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeCheckedSeq s
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq s))
-> (SomeInstr s -> TypeCheckedSeq s)
-> SomeInstr s
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeInstr s -> TypeCheckedSeq s
forall (inp :: [T]). SomeInstr inp -> TypeCheckedSeq inp
WellTypedSeq)
tcList
:: (SingI inp)
=> [U.ExpandedOp] -> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList :: forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList = TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr
typeCheckInstr :: TcInstrHandler
typeCheckInstr :: TcInstrHandler
typeCheckInstr ExpandedInstr
uInstr HST inp
inp = case (ExpandedInstr
uInstr, HST inp
inp) of
(U.EXT ExtInstrAbstract ExpandedOp
ext, HST inp
si) ->
TcInstrHandler
-> ExtInstrAbstract ExpandedOp
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
SingI s =>
TcInstrHandler
-> ExtInstrAbstract ExpandedOp
-> HST s
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
typeCheckExt TcInstrHandler
typeCheckInstr ExtInstrAbstract ExpandedOp
ext HST inp
si
(ExpandedInstr
U.DROP, (SingT x, Dict (WellTyped x))
_ ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (x : xs) xs
forall (a :: T) (out :: [T]). Instr (a : out) out
DROP Instr (x : xs) xs -> HST xs -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs
(ExpandedInstr
U.DROP, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.DROPN Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper inp)
-> (TCDropHelper inp -> SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCDropHelper PeanoNatural n
s HST out
out -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp (Drop n inp)
forall (n :: Nat) (inp :: [T]).
RequireLongerOrSameLength inp n =>
PeanoNatural n -> Instr inp (Drop n inp)
DROPN PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
where
go :: forall inp. SingI inp
=> Word
-> HST inp
-> TypeCheckInstr (TCDropHelper inp)
go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go = ((Word, HST inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper inp))
-> Word
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
(Word
0, HST inp
i) -> TCDropHelper inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDropHelper inp
forall (n :: Nat) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp n, Drop n inp ~ out) =>
PeanoNatural n -> HST out -> TCDropHelper inp
TCDropHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)
(Word
_, HST inp
SNil) -> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
(Word
n, ((SingT x, Dict (WellTyped x))
_ ::& HST xs
iTail)) -> do
Word -> HST xs -> TypeCheckInstr (TCDropHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDropHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper xs)
-> (TCDropHelper xs -> TCDropHelper inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDropHelper inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDropHelper PeanoNatural n
s HST out
out) -> PeanoNatural ('S n) -> HST out -> TCDropHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]).
(SingI out, LongerOrSameLength inp n, Drop n inp ~ out) =>
PeanoNatural n -> HST out -> TCDropHelper inp
TCDropHelper (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) HST out
out
(U.DUP VarAnn
vn1, a :: (SingT x, Dict (WellTyped x))
a@(SingT x
n :: SingT t, Dict (WellTyped x)
d) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
Dict (DupableScope x)
Dict <-
forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope t)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : xs) (x : x : xs)
forall (a :: T) (s :: [T]).
DupableScope a =>
AnnVar -> Instr (a : s) (a : a : s)
AnnDUP (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn1) Instr (x : xs) (x : x : xs)
-> HST (x : x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x
n, Dict (WellTyped x)
d) (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))
(U.DUP VarAnn
_vn, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.DUPN VarAnn
vn Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper inp)
-> (TCDupNHelper inp -> SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural n -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (a :: T).
(ConstraintDUPN n inp out a, DupableScope a) =>
AnnVar -> PeanoNatural n -> Instr inp out
AnnDUPN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
where
go :: forall inp. SingI inp
=> Word
-> HST inp
-> TypeCheckInstr (TCDupNHelper inp)
go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go = ((Word, HST inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper inp))
-> Word
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
(Word
_, HST inp
SNil) -> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
(Word
0, HST inp
_) ->
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper inp)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"'DUP n' expects n > 0")
(Word
1, i :: HST inp
i@((SingT x
an :: SingT a, Dict (WellTyped x)
dict) ::& HST xs
_)) -> do
Dict (DupableScope x)
Dict <-
forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (DupableScope x)))
-> Either BadTypeForScope (Dict (DupableScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (DupableScope x))
forall a b. (a -> b) -> a -> b
$
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(DupableScope a)
TCDupNHelper (x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural ('S 'Z) -> HST (x : inp) -> TCDupNHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUPN n inp out s, DupableScope s) =>
PeanoNatural n -> HST out -> TCDupNHelper inp
TCDupNHelper PeanoNatural ('S 'Z)
forall (n :: Nat). (n ~ 'S 'Z) => PeanoNatural n
One ((SingT x
an, Dict (WellTyped x)
dict) (SingT x, Dict (WellTyped x)) -> HST inp -> HST (x : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i))
(Word
n, ((SingT x, Dict (WellTyped x))
b ::& HST xs
iTail)) ->
Word -> HST xs -> TypeCheckInstr (TCDupNHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDupNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper xs)
-> (TCDupNHelper xs -> TCDupNHelper inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDupNHelper inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDupNHelper s :: PeanoNatural n
s@(Succ PeanoNatural m
_) ((SingT x, Dict (WellTyped x))
a ::& HST xs
resTail)) ->
PeanoNatural ('S ('S (Decrement n)))
-> HST (x : x : xs) -> TCDupNHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUPN n inp out s, DupableScope s) =>
PeanoNatural n -> HST out -> TCDupNHelper inp
TCDupNHelper (PeanoNatural n -> PeanoNatural ('S ('S (Decrement n)))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
resTail)
(ExpandedInstr
U.SWAP, (SingT x, Dict (WellTyped x))
a ::& (SingT x, Dict (WellTyped x))
b ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (x : x : xs) (x : x : xs)
forall (a :: T) (b :: T) (s :: [T]). Instr (a : b : s) (b : a : s)
SWAP Instr (x : x : xs) (x : x : xs)
-> HST (x : x : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))
(ExpandedInstr
U.SWAP, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.DIG Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper inp)
-> (TCDigHelper inp -> SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDigHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (a :: T).
ConstraintDIG n inp out a =>
PeanoNatural n -> Instr inp out
DIG PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
where
go :: forall inp. SingI inp
=> Word
-> HST inp
-> TypeCheckInstr (TCDigHelper inp)
go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go = ((Word, HST inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper inp))
-> Word
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
(Word
_, HST inp
SNil) -> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
(Word
0, i :: HST inp
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_)) -> TCDigHelper (x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDigHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDIG n inp out s) =>
PeanoNatural n -> HST out -> TCDigHelper inp
TCDigHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i (KnownList (x : xs) => TCDigHelper (x : xs))
-> Dict (KnownList inp) -> TCDigHelper (x : xs)
forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
\\ forall (xs :: [T]). SingI xs => Dict (KnownList xs)
forall {k} (xs :: [k]). SingI xs => Dict (KnownList xs)
knownListFromSingI @inp)
(Word
n, ((SingT x, Dict (WellTyped x))
b ::& HST xs
iTail)) ->
Word -> HST xs -> TypeCheckInstr (TCDigHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDigHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
iTail ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper xs)
-> (TCDigHelper xs -> TCDigHelper (x : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDigHelper (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDigHelper PeanoNatural n
s ((SingT x, Dict (WellTyped x))
a ::& HST xs
resTail)) ->
PeanoNatural ('S n) -> HST (x : x : xs) -> TCDigHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDIG n inp out s) =>
PeanoNatural n -> HST out -> TCDigHelper inp
TCDigHelper (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST (x : xs) -> HST (x : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
resTail)
(U.DUG Word
nTotal, HST inp
inputHST) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper inp)
-> (TCDugHelper inp -> SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDugHelper PeanoNatural n
s HST out
out) -> HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (a :: T).
ConstraintDUG n inp out a =>
PeanoNatural n -> Instr inp out
DUG PeanoNatural n
s Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
where
go :: forall inp. SingI inp
=> Word
-> HST inp
-> TypeCheckInstr (TCDugHelper inp)
go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go = ((Word, HST inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper inp))
-> Word
-> HST inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper inp)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry \case
(Word
0, i :: HST inp
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_)) -> TCDugHelper (x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PeanoNatural 'Z -> HST inp -> TCDugHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUG n inp out s) =>
PeanoNatural n -> HST out -> TCDugHelper inp
TCDugHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero HST inp
i)
(Word
n, ((SingT x, Dict (WellTyped x))
a ::& (SingT x, Dict (WellTyped x))
b ::& HST xs
iTail)) ->
Word -> HST (x : xs) -> TypeCheckInstr (TCDugHelper (x : xs))
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstr (TCDugHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
iTail) ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper (x : xs))
-> (TCDugHelper (x : xs) -> TCDugHelper (x : x : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper (x : x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCDugHelper PeanoNatural n
s HST out
resTail) ->
PeanoNatural ('S n) -> HST (x : out) -> TCDugHelper (x : x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: T).
(SingI out, ConstraintDUG n inp out s) =>
PeanoNatural n -> HST out -> TCDugHelper inp
TCDugHelper (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) ((SingT x, Dict (WellTyped x))
b (SingT x, Dict (WellTyped x)) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST out
resTail)
(Word, HST inp)
_ -> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCDugHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
(U.PUSH VarAnn
vn Ty
mt Value
mval, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
nt :: Notes t) -> do
Value t
val <- (TypeCheckEnv -> TypeCheckEnv)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
forall (n :: Nat) r (m :: * -> *) a.
MultiReader n r m =>
(r -> r) -> m a -> m a
local' ((TypeCheckMode -> Identity TypeCheckMode)
-> TypeCheckEnv -> Identity TypeCheckEnv
Iso' TypeCheckEnv TypeCheckMode
tcModeL ((TypeCheckMode -> Identity TypeCheckMode)
-> TypeCheckEnv -> Identity TypeCheckEnv)
-> TypeCheckMode -> TypeCheckEnv -> TypeCheckEnv
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Value, T) -> Maybe BigMapFinder -> TypeCheckMode
TypeCheckValue (Value
mval, forall {k} (a :: k). (SingKind k, SingI a) => Demote k
forall (a :: T). (SingKind T, SingI a) => Demote T
demote @t) Maybe BigMapFinder
forall a. Maybe a
Nothing) (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Value t)
forall a b. (a -> b) -> a -> b
$
forall (ty :: T).
SingI ty =>
Maybe TcOriginatedContracts
-> TcInstrHandler -> Value -> TypeCheckInstr (Value ty)
typeCheckValImpl @t Maybe TcOriginatedContracts
forall a. Maybe a
Nothing TcInstrHandler
typeCheckInstr Value
mval
Dict (ConstantScope t)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
i) Maybe TypeContext
forall a. Maybe a
Nothing
(Either BadTypeForScope (Dict (ConstantScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ConstantScope t)))
-> Either BadTypeForScope (Dict (ConstantScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ConstantScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope t)
case Dict (ConstantScope t)
proofScope of
Dict (ConstantScope t)
Dict -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped t => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t] -> Value t -> Instr inp (t : inp)
forall (t :: T) (inp :: [T]).
ConstantScope t =>
Anns '[VarAnn, Notes t] -> Value' Instr t -> Instr inp (t : inp)
AnnPUSH (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
nt) Value t
val Instr inp (t : inp) -> HST (t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
nt, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict) (SingT t, Dict (WellTyped t)) -> HST inp -> HST (t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)
(U.SOME TypeAnn
tn VarAnn
vn, (SingT x
an, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn] -> Instr (x : xs) ('TOption x : xs)
forall (a :: T) (s :: [T]).
Anns '[TypeAnn, VarAnn] -> Instr (a : s) ('TOption a : s)
AnnSOME (TypeAnn -> VarAnn -> Anns '[TypeAnn, VarAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 TypeAnn
tn VarAnn
vn) Instr (x : xs) ('TOption x : xs)
-> HST ('TOption x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing x -> SingT ('TOption x)
forall (n :: T). Sing n -> SingT ('TOption n)
STOption Sing x
SingT x
an, Dict (WellTyped ('TOption x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption x), Dict (WellTyped ('TOption x)))
-> HST xs -> HST ('TOption x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))
(U.SOME TypeAnn
_ VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.NONE TypeAnn
tn VarAnn
vn Ty
elMt, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
elMt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
elNotes :: Notes t) ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped t => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t] -> Instr inp ('TOption t : inp)
forall (a :: T) (inp :: [T]).
SingI a =>
Anns '[TypeAnn, VarAnn, Notes a] -> Instr inp ('TOption a : inp)
AnnNONE (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
elNotes) Instr inp ('TOption t : inp)
-> HST ('TOption t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TOption t)
forall (n :: T). Sing n -> SingT ('TOption n)
STOption (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
elNotes), Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption t), Dict (WellTyped ('TOption t)))
-> HST inp -> HST ('TOption t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.UNIT TypeAnn
tn VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn] -> Instr inp ('TUnit : inp)
forall (inp :: [T]).
Anns '[TypeAnn, VarAnn] -> Instr inp ('TUnit : inp)
AnnUNIT (TypeAnn -> VarAnn -> Anns '[TypeAnn, VarAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 TypeAnn
tn VarAnn
vn) Instr inp ('TUnit : inp) -> HST ('TUnit : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TUnit
STUnit, Dict (WellTyped 'TUnit)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TUnit, Dict (WellTyped 'TUnit))
-> HST inp -> HST ('TUnit : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.MIN_BLOCK_TIME [AnyAnn]
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ [AnyAnn] -> Instr inp ('TNat : inp)
forall (inp :: [T]). [AnyAnn] -> Instr inp ('TNat : inp)
AnnMIN_BLOCK_TIME [AnyAnn]
vn Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
STNat, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat))
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.IF_NONE [ExpandedOp]
mp [ExpandedOp]
mq, (STOption (SingT n
asing :: SingT a), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @a ((WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> (WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$
(forall (s' :: [T]).
Instr xs s' -> Instr (n : xs) s' -> Instr ('TOption n : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST xs
-> HST (n : xs)
-> HST ('TOption n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr xs s' -> Instr (n : xs) s' -> Instr ('TOption n : xs) s'
forall (s :: [T]) (out :: [T]) (a :: T).
Instr s out -> Instr (a : s) out -> Instr ('TOption a : s) out
IF_NONE forall op. [op] -> [op] -> InstrAbstract op
U.IF_NONE [ExpandedOp]
mp [ExpandedOp]
mq HST xs
rs ((SingT n
asing, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict) (SingT n, Dict (WellTyped n)) -> HST xs -> HST (n : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs) HST inp
HST ('TOption n : xs)
inp
(U.IF_NONE [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"option 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.IF_NONE [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.PAIR TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn, (SingT x
an :: SingT a, Dict (WellTyped x)
_) ::& (SingT x
bn :: SingT b, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
TypeCheckInstr (SomeInstr (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs)))
-> (WellTyped ('TPair x x) =>
TypeCheckInstr (SomeInstr (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, RootAnn, RootAnn]
-> Instr (x : x : xs) ('TPair x x : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[TypeAnn, VarAnn, RootAnn, RootAnn]
-> Instr (a : b : s) ('TPair a b : s)
AnnPAIR (TypeAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Anns '[TypeAnn, VarAnn, RootAnn, RootAnn]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k).
Each '[Typeable] '[a, b, c, d] =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Anns '[Annotation a, Annotation b, Annotation c, Annotation d]
Anns4 TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn) Instr (x : x : xs) ('TPair x x : xs)
-> HST ('TPair x x : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing x -> Sing x -> SingT ('TPair x x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing x
SingT x
an Sing x
SingT x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x x), Dict (WellTyped ('TPair x x)))
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))
(U.PAIR {}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.UNPAIR VarAnn
instrVn1 VarAnn
instrVn2 RootAnn
instrFn1 RootAnn
instrFn2, (STPair Sing n1
n1 Sing n2
n2, Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, VarAnn, RootAnn, RootAnn]
-> Instr ('TPair n1 n2 : xs) (n1 : n2 : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[VarAnn, VarAnn, RootAnn, RootAnn]
-> Instr ('TPair a b : s) (a : b : s)
AnnUNPAIR (VarAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Anns '[VarAnn, VarAnn, RootAnn, RootAnn]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k).
Each '[Typeable] '[a, b, c, d] =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Anns '[Annotation a, Annotation b, Annotation c, Annotation d]
Anns4 VarAnn
instrVn1 VarAnn
instrVn2 RootAnn
instrFn1 RootAnn
instrFn2) Instr ('TPair n1 n2 : xs) (n1 : n2 : xs)
-> HST (n1 : n2 : xs) -> SomeInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
:::
( (Sing n1
SingT n1
n1, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1))
-> HST (n2 : xs) -> HST (n1 : n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::&
(Sing n2
SingT n2
n2, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::&
HST xs
rs
)
(U.UNPAIR {}, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.UNPAIR {}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.PAIRN VarAnn
varAnn Word
nTotal, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go Word
nTotal HST inp
inp ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper inp)
-> (TCPairNHelper inp -> SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCPairNHelper PeanoNatural n
s HST (PairN n inp)
out -> HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural n -> Instr inp (PairN n inp)
forall (n :: Nat) (inp :: [T]).
ConstraintPairN n inp =>
AnnVar
-> PeanoNatural n
-> Instr inp (RightComb (Take n inp) : Drop n inp)
AnnPAIRN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
varAnn) PeanoNatural n
s Instr inp (PairN n inp) -> HST (PairN n inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (PairN n inp)
out
where
go :: forall inp. Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go :: forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go Word
n HST inp
hst
| Word
n Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
2 =
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper inp)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
(ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"'PAIR n' expects n ≥ 2")
| Word
n Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
2 =
case HST inp
hst of
(SingT x
an :: SingT a, Dict (WellTyped x)
_) ::& (SingT x
bn :: SingT b, Dict (WellTyped x)
_) ::& HST xs
hstTail -> do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
TypeCheckInstr (TCPairNHelper (x : x : xs)))
-> TypeCheckInstr (TCPairNHelper (x : x : xs)))
-> (WellTyped ('TPair x x) =>
TypeCheckInstr (TCPairNHelper (x : x : xs)))
-> TypeCheckInstr (TCPairNHelper (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
TCPairNHelper (x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : xs)))
-> TCPairNHelper (x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S 'Z))
-> HST (PairN ('S ('S 'Z)) (x : x : xs))
-> TCPairNHelper (x : x : xs)
forall (n :: Nat) (inp :: [T]).
(SingI (PairN n inp), ConstraintPairN n inp) =>
PeanoNatural n -> HST (PairN n inp) -> TCPairNHelper inp
TCPairNHelper PeanoNatural ('S ('S 'Z))
forall (n :: Nat). (n ~ 'S ('S 'Z)) => PeanoNatural n
Two (HST (PairN ('S ('S 'Z)) (x : x : xs))
-> TCPairNHelper (x : x : xs))
-> HST (PairN ('S ('S 'Z)) (x : x : xs))
-> TCPairNHelper (x : x : xs)
forall a b. (a -> b) -> a -> b
$
(Sing x -> Sing x -> SingT ('TPair x x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing x
SingT x
an Sing x
SingT x
bn, Dict (WellTyped ('TPair x x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x x), Dict (WellTyped ('TPair x x)))
-> HST xs -> HST ('TPair x x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hstTail
HST inp
_ -> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCPairNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
| Bool
otherwise =
case HST inp
hst of
(SingT x
an :: SingT a, Dict (WellTyped x)
_) ::& hstTail :: HST xs
hstTail@((SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> do
Word -> HST xs -> TypeCheckInstr (TCPairNHelper xs)
forall (inp :: [T]).
Word -> HST inp -> TypeCheckInstr (TCPairNHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
hstTail ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : xs))
-> (TCPairNHelper (x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : x : xs))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
TCPairNHelper nSing :: PeanoNatural n
nSing@(Succ (Succ PeanoNatural m
_)) ((SingT x
bn :: SingT b, Dict (WellTyped x)
_) ::& HST xs
hstTail') -> do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TPair a b) ((WellTyped ('TPair x x) =>
TypeCheckInstr (TCPairNHelper (x : x : x : xs)))
-> TypeCheckInstr (TCPairNHelper (x : x : x : xs)))
-> (WellTyped ('TPair x x) =>
TypeCheckInstr (TCPairNHelper (x : x : x : xs)))
-> TypeCheckInstr (TCPairNHelper (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
TCPairNHelper (x : x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCPairNHelper (x : x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : x : xs)))
-> TCPairNHelper (x : x : x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCPairNHelper (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S ('S m)))
-> HST (PairN ('S ('S ('S m))) (x : x : x : xs))
-> TCPairNHelper (x : x : x : xs)
forall (n :: Nat) (inp :: [T]).
(SingI (PairN n inp), ConstraintPairN n inp) =>
PeanoNatural n -> HST (PairN n inp) -> TCPairNHelper inp
TCPairNHelper (PeanoNatural n -> PeanoNatural ('S ('S ('S m)))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
nSing) (HST (PairN ('S ('S ('S m))) (x : x : x : xs))
-> TCPairNHelper (x : x : x : xs))
-> HST (PairN ('S ('S ('S m))) (x : x : x : xs))
-> TCPairNHelper (x : x : x : xs)
forall a b. (a -> b) -> a -> b
$
(Sing x
-> Sing (RightComb (Take n (x : x : xs)))
-> SingT ('TPair x (RightComb (Take n (x : x : xs))))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing x
SingT x
an Sing (RightComb (Take n (x : x : xs)))
SingT x
bn, Dict (WellTyped ('TPair x (RightComb (Take n (x : x : xs)))))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair x (RightComb (Take n (x : x : xs)))),
Dict (WellTyped ('TPair x (RightComb (Take n (x : x : xs))))))
-> HST xs -> HST ('TPair x (RightComb (Take n (x : x : xs))) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hstTail'
HST inp
_ -> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCPairNHelper inp)
forall a. TypeCheckInstr a
notEnoughItemsOnStack'
(U.UNPAIRN Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.UNPAIRN Word
nTotal, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go Word
nTotal HST inp
HST (x : xs)
inp ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper (x : xs))
-> (TCUnpairNHelper (x : xs) -> SomeInstr (x : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCUnpairNHelper PeanoNatural n
s HST (UnpairN n ('TPair a b) ++ rest)
out ->
HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n
-> Instr ('TPair a b : xs) (UnpairN n ('TPair a b) ++ xs)
forall (n :: Nat) (pair :: T) (s :: [T]).
ConstraintUnpairN n pair =>
PeanoNatural n -> Instr (pair : s) (UnpairN n pair ++ s)
UNPAIRN PeanoNatural n
s Instr ('TPair a b : xs) (UnpairN n ('TPair a b) ++ xs)
-> HST (UnpairN n ('TPair a b) ++ xs)
-> SomeInstrOut ('TPair a b : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (UnpairN n ('TPair a b) ++ xs)
HST (UnpairN n ('TPair a b) ++ rest)
out
where
go :: forall x xs. Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go :: forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go Word
n HST (x : xs)
hst
| Word
n Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
2 =
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper (x : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
(ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"UNPAIR expects an argument of at least 2.")
| Word
n Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
2 =
case HST (x : xs)
hst of
(STPair Sing n1
aT Sing n2
bT, Dict (WellTyped x)
Dict) ::& HST xs
rest -> do
TCUnpairNHelper ('TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 n2 : xs)))
-> TCUnpairNHelper ('TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S 'Z))
-> HST (UnpairN ('S ('S 'Z)) ('TPair n1 n2) ++ xs)
-> TCUnpairNHelper ('TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UnpairN n ('TPair out s) ++ s'),
ConstraintUnpairN n ('TPair out s)) =>
PeanoNatural n
-> HST (UnpairN n ('TPair out s) ++ s')
-> TCUnpairNHelper ('TPair out s : s')
TCUnpairNHelper PeanoNatural ('S ('S 'Z))
forall (n :: Nat). (n ~ 'S ('S 'Z)) => PeanoNatural n
Two (HST (UnpairN ('S ('S 'Z)) ('TPair n1 n2) ++ xs)
-> TCUnpairNHelper ('TPair n1 n2 : xs))
-> HST (UnpairN ('S ('S 'Z)) ('TPair n1 n2) ++ xs)
-> TCUnpairNHelper ('TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$
(Sing n1
SingT n1
aT, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict)
(SingT n1, Dict (WellTyped n1))
-> HST (n2 : xs) -> HST (n1 : n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (Sing n2
SingT n2
bT, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict)
(SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
HST (x : xs)
_ -> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr a
unexpectedType
| Bool
otherwise =
case HST (x : xs)
hst of
(STPair Sing n1
aT Sing n2
bT, Dict (WellTyped x)
Dict) ::& HST xs
rest -> do
Word -> HST (n2 : xs) -> TypeCheckInstr (TCUnpairNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCUnpairNHelper (x : xs))
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) ((Sing n2
SingT n2
bT, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper (n2 : xs))
-> (TCUnpairNHelper (n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 n2 : xs))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
TCUnpairNHelper nSing :: PeanoNatural n
nSing@(Succ (Succ PeanoNatural m
_)) HST (UnpairN n ('TPair a b) ++ rest)
out -> do
TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 ('TPair a b) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)))
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUnpairNHelper ('TPair n1 ('TPair a b) : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S ('S ('S m)))
-> HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UnpairN n ('TPair out s) ++ s'),
ConstraintUnpairN n ('TPair out s)) =>
PeanoNatural n
-> HST (UnpairN n ('TPair out s) ++ s')
-> TCUnpairNHelper ('TPair out s : s')
TCUnpairNHelper (PeanoNatural n -> PeanoNatural ('S ('S ('S m)))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
nSing) (HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs))
-> HST (UnpairN ('S ('S ('S m))) ('TPair n1 ('TPair a b)) ++ xs)
-> TCUnpairNHelper ('TPair n1 ('TPair a b) : xs)
forall a b. (a -> b) -> a -> b
$
(Sing n1
SingT n1
aT, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1))
-> HST (UnpairN n ('TPair a b) ++ xs)
-> HST (n1 : (UnpairN n ('TPair a b) ++ xs))
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST (UnpairN n ('TPair a b) ++ xs)
HST (UnpairN n ('TPair a b) ++ rest)
out
HST (x : xs)
_ -> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCUnpairNHelper (x : xs))
forall a. TypeCheckInstr a
unexpectedType
unexpectedType :: TypeCheckInstr a
unexpectedType :: forall a. TypeCheckInstr a
unexpectedType = TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
a
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
a)
-> TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
a
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Word -> Text
pairWithElems Word
nTotal Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.CAR VarAnn
vn RootAnn
fn, (STPair Sing n1
lt Sing n2
_, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, RootAnn] -> Instr ('TPair n1 n2 : xs) (n1 : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[VarAnn, RootAnn] -> Instr ('TPair a b : s) (a : s)
AnnCAR (VarAnn -> RootAnn -> Anns '[VarAnn, RootAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 VarAnn
vn RootAnn
fn) Instr ('TPair n1 n2 : xs) (n1 : xs)
-> HST (n1 : xs) -> SomeInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing n1
SingT n1
lt, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.CAR VarAnn
_ RootAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.CAR VarAnn
_ RootAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.CDR VarAnn
vn RootAnn
fn, (STPair Sing n1
_ Sing n2
rt, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TPair n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, RootAnn] -> Instr ('TPair n1 n2 : xs) (n2 : xs)
forall (a :: T) (b :: T) (s :: [T]).
Anns '[VarAnn, RootAnn] -> Instr ('TPair a b : s) (b : s)
AnnCDR (VarAnn -> RootAnn -> Anns '[VarAnn, RootAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 VarAnn
vn RootAnn
fn) Instr ('TPair n1 n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut ('TPair n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing n2
SingT n2
rt, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.CDR VarAnn
_ RootAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.CDR VarAnn
_ RootAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LEFT TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Ty
bMt, (SingT x
an :: SingT l, Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
bMt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
bn :: Notes r) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @r ((WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
forall a b. (a -> b) -> a -> b
$ do
let ns :: SingT ('TOr x t)
ns = Sing x -> Sing t -> SingT ('TOr x t)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TOr n1 n2)
STOr Sing x
SingT x
an (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
bn)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
-> Instr (x : xs) ('TOr x t : xs)
forall (b :: T) (a :: T) (s :: [T]).
SingI b =>
Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes b]
-> Instr (a : s) ('TOr a b : s)
AnnLEFT (TypeAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Notes t
-> Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k) (t :: T).
(Each '[Typeable] '[a, b, c, d], SingI t) =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Notes t
-> Anns
'[Annotation a, Annotation b, Annotation c, Annotation d, Notes t]
Anns5' TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Notes t
bn) Instr (x : xs) ('TOr x t : xs)
-> HST ('TOr x t : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOr x t)
ns, Dict (WellTyped ('TOr x t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOr x t), Dict (WellTyped ('TOr x t)))
-> HST xs -> HST ('TOr x t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))
(U.LEFT {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.RIGHT TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Ty
aMt, (SingT x
bn :: SingT r, Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
aMt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
an :: Notes l) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @l ((WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
forall a b. (a -> b) -> a -> b
$ do
let ns :: SingT ('TOr t x)
ns = Sing t -> Sing x -> SingT ('TOr t x)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TOr n1 n2)
STOr (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
an) Sing x
SingT x
bn
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
-> Instr (x : xs) ('TOr t x : xs)
forall (a :: T) (b :: T) (s :: [T]).
SingI a =>
Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes a]
-> Instr (b : s) ('TOr a b : s)
AnnRIGHT (TypeAnn
-> VarAnn
-> RootAnn
-> RootAnn
-> Notes t
-> Anns '[TypeAnn, VarAnn, RootAnn, RootAnn, Notes t]
forall {k} (a :: k) (b :: k) (c :: k) (d :: k) (t :: T).
(Each '[Typeable] '[a, b, c, d], SingI t) =>
Annotation a
-> Annotation b
-> Annotation c
-> Annotation d
-> Notes t
-> Anns
'[Annotation a, Annotation b, Annotation c, Annotation d, Notes t]
Anns5' TypeAnn
tn VarAnn
vn RootAnn
pfn RootAnn
qfn Notes t
an) Instr (x : xs) ('TOr t x : xs)
-> HST ('TOr t x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOr t x)
ns, Dict (WellTyped ('TOr t x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOr t x), Dict (WellTyped ('TOr t x)))
-> HST xs -> HST ('TOr t x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs))
(U.RIGHT {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.IF_LEFT [ExpandedOp]
mp [ExpandedOp]
mq, (STOr (SingT n1
lt :: SingT l) (SingT n2
rt :: SingT r), Dict (WellTyped x)
_) ::& HST xs
rs) -> do
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
lt ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
rt ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @l ((WellTyped n1 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n1 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @r ((WellTyped n2 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
let
ait :: HST (n1 : xs)
ait = (SingT n1
lt, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
bit :: HST (n2 : xs)
bit = (SingT n2
rt, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
(forall (s' :: [T]).
Instr (n1 : xs) s'
-> Instr (n2 : xs) s' -> Instr ('TOr n1 n2 : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST (n1 : xs)
-> HST (n2 : xs)
-> HST ('TOr n1 n2 : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr (n1 : xs) s'
-> Instr (n2 : xs) s' -> Instr ('TOr n1 n2 : xs) s'
forall (a :: T) (s :: [T]) (out :: [T]) (b :: T).
Instr (a : s) out -> Instr (b : s) out -> Instr ('TOr a b : s) out
IF_LEFT forall op. [op] -> [op] -> InstrAbstract op
U.IF_LEFT [ExpandedOp]
mp [ExpandedOp]
mq HST (n1 : xs)
ait HST (n2 : xs)
bit HST inp
HST ('TOr n1 n2 : xs)
inp
(U.IF_LEFT [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"or 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.IF_LEFT [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.NIL TypeAnn
tn VarAnn
vn Ty
elMt, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
elMt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
elNotes :: Notes t) ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TList t) ((WellTyped ('TList t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TList t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t] -> Instr inp ('TList t : inp)
forall (p :: T) (inp :: [T]).
SingI p =>
Anns '[TypeAnn, VarAnn, Notes p] -> Instr inp ('TList p : inp)
AnnNIL (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
elNotes) Instr inp ('TList t : inp)
-> HST ('TList t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TList t)
forall (n :: T). Sing n -> SingT ('TList n)
STList (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
elNotes), Dict (WellTyped ('TList t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TList t), Dict (WellTyped ('TList t)))
-> HST inp -> HST ('TList t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)
(U.CONS VarAnn
vn, ((SingT x
_ :: SingT a), Dict (WellTyped x)
_) ::& ((SingT x
ln :: SingT l), Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr
case forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @('TList a) @l of
Right 'TList x :~: x
Refl -> do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TList l) ((WellTyped ('TList x) =>
TypeCheckInstr (SomeInstr (x : 'TList x : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TList x : xs)))
-> (WellTyped ('TList x) =>
TypeCheckInstr (SomeInstr (x : 'TList x : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TList x : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : 'TList x : xs) ('TList x : xs)
forall (a :: T) (s :: [T]).
AnnVar -> Instr (a : 'TList a : s) ('TList a : s)
AnnCONS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TList x : xs) ('TList x : xs)
-> HST ('TList x : xs) -> SomeInstrOut (x : 'TList x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x
ln, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : x : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ConsArgument) TCTypeError
m
(U.CONS VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.IF_CONS [ExpandedOp]
mp [ExpandedOp]
mq, (ns :: SingT x
ns@(STList (SingT n
an :: SingT t1)), Dict (WellTyped x)
Dict) ::& HST xs
rs) -> do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
let ait :: HST (n : x : xs)
ait = (SingT n
an, Dict (WellTyped n)
forall (a :: Constraint). a => Dict a
Dict) (SingT n, Dict (WellTyped n)) -> HST (x : xs) -> HST (n : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x
ns, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
(forall (s' :: [T]).
Instr (n : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST (n : x : xs)
-> HST xs
-> HST ('TList n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr (n : x : xs) s' -> Instr xs s' -> Instr ('TList n : xs) s'
forall (a :: T) (s :: [T]) (out :: [T]).
Instr (a : 'TList a : s) out
-> Instr s out -> Instr ('TList a : s) out
IF_CONS forall op. [op] -> [op] -> InstrAbstract op
U.IF_CONS [ExpandedOp]
mp [ExpandedOp]
mq HST (n : x : xs)
ait HST xs
rs HST inp
HST ('TList n : xs)
inp
(U.IF_CONS [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.IF_CONS [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil)-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SIZE VarAnn
vn, (STList{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TList n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TList n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstr (SomeInstr ('TList n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
(U.SIZE VarAnn
vn, (STSet{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> TypeCheckInstr (SomeInstr ('TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
(U.SIZE VarAnn
vn, (STMap{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr ('TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
(U.SIZE VarAnn
vn, (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TString : xs)))
-> TypeCheckInstr (SomeInstr ('TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
(U.SIZE VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SizeOp c, inp ~ (c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sizeImpl HST inp
inp VarAnn
vn
(U.SIZE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"set 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"map 'k 'v" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"string" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
]
(U.SIZE VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.EMPTY_SET TypeAnn
tn VarAnn
vn Ty
mv, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v) ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TSet v) ((WellTyped ('TSet t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TSet t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
Sing t
-> ExpandedInstr
-> HST inp
-> (Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns) ExpandedInstr
uInstr HST inp
inp ((Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t] -> Instr inp ('TSet t : inp)
forall (e :: T) (inp :: [T]).
(SingI e, Comparable e) =>
Anns '[TypeAnn, VarAnn, Notes e] -> Instr inp ('TSet e : inp)
AnnEMPTY_SET (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
vns) Instr inp ('TSet t : inp)
-> HST ('TSet t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TSet t)
forall (n :: T). Sing n -> SingT ('TSet n)
STSet (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns), Dict (WellTyped ('TSet t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TSet t), Dict (WellTyped ('TSet t)))
-> HST inp -> HST ('TSet t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)
(U.EMPTY_MAP TypeAnn
tn VarAnn
vn Ty
mk Ty
mv, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ do
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v) ->
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mk ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
ktn :: Notes k) ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TMap k v) ((WellTyped ('TMap t t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TMap t t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
Sing t
-> ExpandedInstr
-> HST inp
-> (Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) ExpandedInstr
uInstr HST inp
inp ((Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t, Notes t]
-> Instr inp ('TMap t t : inp)
forall (a :: T) (b :: T) (inp :: [T]).
(SingI a, SingI b, Comparable a) =>
Anns '[TypeAnn, VarAnn, Notes a, Notes b]
-> Instr inp ('TMap a b : inp)
AnnEMPTY_MAP (TypeAnn
-> VarAnn
-> Notes t
-> Notes t
-> Anns '[TypeAnn, VarAnn, Notes t, Notes t]
forall {k} (a :: k) (b :: k) (t :: T) (u :: T).
(Each '[Typeable] '[a, b], SingI t, SingI u) =>
Annotation a
-> Annotation b
-> Notes t
-> Notes u
-> Anns '[Annotation a, Annotation b, Notes t, Notes u]
Anns4'' TypeAnn
tn VarAnn
vn Notes t
ktn Notes t
vns) Instr inp ('TMap t t : inp)
-> HST ('TMap t t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> Sing t -> SingT ('TMap t t)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TMap n1 n2)
STMap (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns), Dict (WellTyped ('TMap t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TMap t t), Dict (WellTyped ('TMap t t)))
-> HST inp -> HST ('TMap t t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)
(U.EMPTY_BIG_MAP TypeAnn
tn VarAnn
vn Ty
mk Ty
mv, HST inp
i) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mv ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
vns :: Notes v) ->
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mk ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ \(Notes t
ktn :: Notes k) ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TBigMap k v) ((WellTyped ('TBigMap t t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TBigMap t t) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
Sing t
-> ExpandedInstr
-> HST inp
-> (Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) ExpandedInstr
uInstr HST inp
inp ((Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (Comparable t => SomeInstr inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
HST inp
i HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t, Notes t]
-> Instr inp ('TBigMap t t : inp)
forall (a :: T) (b :: T) (inp :: [T]).
(SingI a, SingI b, Comparable a, HasNoBigMap b) =>
Anns '[TypeAnn, VarAnn, Notes a, Notes b]
-> Instr inp ('TBigMap a b : inp)
AnnEMPTY_BIG_MAP (TypeAnn
-> VarAnn
-> Notes t
-> Notes t
-> Anns '[TypeAnn, VarAnn, Notes t, Notes t]
forall {k} (a :: k) (b :: k) (t :: T) (u :: T).
(Each '[Typeable] '[a, b], SingI t, SingI u) =>
Annotation a
-> Annotation b
-> Notes t
-> Notes u
-> Anns '[Annotation a, Annotation b, Notes t, Notes u]
Anns4'' TypeAnn
tn VarAnn
vn Notes t
ktn Notes t
vns) Instr inp ('TBigMap t t : inp)
-> HST ('TBigMap t t : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> Sing t -> SingT ('TBigMap t t)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TBigMap n1 n2)
STBigMap (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ktn) (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
vns), Dict (WellTyped ('TBigMap t t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TBigMap t t), Dict (WellTyped ('TBigMap t t)))
-> HST inp -> HST ('TBigMap t t : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
i)
(U.MAP VarAnn
vn [ExpandedOp]
mp, (STList (SingT n
vns :: SingT t1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
SingT n
vns ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp ('TList n))
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TList n : xs)
-> (forall (v' :: T).
SingI v' =>
SingT v'
-> HST xs -> TypeCheckInstr (HST (MapOpRes ('TList n) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl (VarAnn -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) SingT n
SingT (MapOpInp ('TList n))
vns VarAnn
vn ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TList n : xs)
inp
(\(SingT v'
rn :: SingT t) HST xs
hst -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped v' => TypeCheckInstr (HST ('TList v' : xs)))
-> TypeCheckInstr (HST ('TList v' : xs)))
-> (WellTyped v' => TypeCheckInstr (HST ('TList v' : xs)))
-> TypeCheckInstr (HST ('TList v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TList v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TList v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TList v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TList v' : xs)))
-> HST ('TList v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TList v' : xs))
forall a b. (a -> b) -> a -> b
$ (Sing v' -> SingT ('TList v')
forall (n :: T). Sing n -> SingT ('TList n)
STList Sing v'
SingT v'
rn, Dict (WellTyped ('TList v'))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TList v'), Dict (WellTyped ('TList v')))
-> HST xs -> HST ('TList v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hst)
(U.MAP VarAnn
vn [ExpandedOp]
mp, (STOption (SingT n
vns :: SingT t1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOption n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOption n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
SingT n
vns ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOption n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOption n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOption n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> (WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall a b. (a -> b) -> a -> b
$
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp ('TOption n))
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TOption n : xs)
-> (forall (v' :: T).
SingI v' =>
SingT v'
-> HST xs -> TypeCheckInstr (HST (MapOpRes ('TOption n) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOption n : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl (VarAnn -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) SingT n
SingT (MapOpInp ('TOption n))
vns VarAnn
vn ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TOption n : xs)
inp
(\(SingT v'
rn :: SingT t) HST xs
hst -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped v' => TypeCheckInstr (HST ('TOption v' : xs)))
-> TypeCheckInstr (HST ('TOption v' : xs)))
-> (WellTyped v' => TypeCheckInstr (HST ('TOption v' : xs)))
-> TypeCheckInstr (HST ('TOption v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TOption v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TOption v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TOption v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TOption v' : xs)))
-> HST ('TOption v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TOption v' : xs))
forall a b. (a -> b) -> a -> b
$ (Sing v' -> SingT ('TOption v')
forall (n :: T). Sing n -> SingT ('TOption n)
STOption Sing v'
SingT v'
rn, Dict (WellTyped ('TOption v'))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption v'), Dict (WellTyped ('TOption v')))
-> HST xs -> HST ('TOption v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hst)
(U.MAP VarAnn
vn [ExpandedOp]
mp, (STMap (SingT n1
k :: SingT k) (SingT n2
v :: SingT v1), Dict (WellTyped x)
Dict) ::& HST xs
_) -> Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @('TPair k v1) ((WellTyped ('TPair n1 n2) =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (WellTyped ('TPair n1 n2) =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp ('TMap n1 n2))
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TMap n1 n2 : xs)
-> (forall (v' :: T).
SingI v' =>
SingT v'
-> HST xs -> TypeCheckInstr (HST (MapOpRes ('TMap n1 n2) v' : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl (VarAnn -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
U.MAP VarAnn
vn) (Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
SingT n1
k Sing n2
SingT n2
v) VarAnn
vn ExpandedInstr
uInstr [ExpandedOp]
mp HST inp
HST ('TMap n1 n2 : xs)
inp
(\(SingT v'
rn :: SingT v) HST xs
hst -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TMap k v) ((WellTyped ('TMap n1 v') =>
TypeCheckInstr (HST ('TMap n1 v' : xs)))
-> TypeCheckInstr (HST ('TMap n1 v' : xs)))
-> (WellTyped ('TMap n1 v') =>
TypeCheckInstr (HST ('TMap n1 v' : xs)))
-> TypeCheckInstr (HST ('TMap n1 v' : xs))
forall a b. (a -> b) -> a -> b
$ HST ('TMap n1 v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TMap n1 v' : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HST ('TMap n1 v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TMap n1 v' : xs)))
-> HST ('TMap n1 v' : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(HST ('TMap n1 v' : xs))
forall a b. (a -> b) -> a -> b
$ (Sing n1 -> Sing v' -> SingT ('TMap n1 v')
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TMap n1 n2)
STMap Sing n1
SingT n1
k Sing v'
SingT v'
rn, Dict (WellTyped ('TMap n1 v'))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TMap n1 v'), Dict (WellTyped ('TMap n1 v')))
-> HST xs -> HST ('TMap n1 v' : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
hst)
(U.MAP VarAnn
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"map 'k 'v" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"option 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
]
(U.MAP VarAnn
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.ITER [ExpandedOp]
is, (STSet (Sing n
s :: Sing t1), Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TSet n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TSet n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> (WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall a b. (a -> b) -> a -> b
$
SingT (IterOpEl ('TSet n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TSet n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TSet n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Sing n
SingT (IterOpEl ('TSet n))
s ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TSet n : xs)
inp
(U.ITER [ExpandedOp]
is, (STList (Sing n
l :: Sing t1), Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
l ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t1 ((WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> (WellTyped n =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall a b. (a -> b) -> a -> b
$
SingT (IterOpEl ('TList n))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TList n : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList n : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl Sing n
SingT (IterOpEl ('TList n))
l ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TList n : xs)
inp
(U.ITER [ExpandedOp]
is, (STMap (SingT n1
k :: SingT a) (SingT n2
v :: SingT b), Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @('TPair a b) ((WellTyped ('TPair n1 n2) =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> (WellTyped ('TPair n1 n2) =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ SingT (IterOpEl ('TMap n1 n2))
-> ExpandedInstr
-> [ExpandedOp]
-> HST ('TMap n1 n2 : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMap n1 n2 : xs))
forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl (Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
SingT n1
k Sing n2
SingT n2
v) ExpandedInstr
uInstr [ExpandedOp]
is HST inp
HST ('TMap n1 n2 : xs)
inp
(U.ITER [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"set 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"list 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"map 'k 'v" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
]
(U.ITER [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.MEM VarAnn
varNotes,
(SingT x, Dict (WellTyped x))
_ ::& (STSet Sing n
s, Dict (WellTyped x)
_) ::& HST xs
_) -> Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TSet n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TSet n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TSet n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TSet n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
(m :: * -> *).
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
memImpl HST inp
inp VarAnn
varNotes
(U.MEM VarAnn
varNotes,
(SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
(m :: * -> *).
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
memImpl HST inp
inp VarAnn
varNotes
(U.MEM VarAnn
varNotes,
(SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (memKey :: T) (rs :: [T]) (inp :: [T])
(m :: * -> *).
(MemOp c, SingI (MemOpKey c), inp ~ (memKey : c : rs), SingI rs,
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
memImpl HST inp
inp VarAnn
varNotes
(U.MEM VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"set 'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"map 'k 'v"])
, (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"big_map 'k 'v"])
]
(U.MEM VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.GET VarAnn
varNotes,
(SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> SingT (GetOpVal ('TMap n1 n2))
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (getKey :: T) (rs :: [T]) (inp :: [T])
(m :: * -> *).
(GetOp c, SingI (GetOpKey c), WellTyped (GetOpVal c),
inp ~ (getKey : c : rs), SingI rs, MonadReader TypeCheckInstrEnv m,
MonadError TCError m) =>
HST inp -> SingT (GetOpVal c) -> VarAnn -> m (SomeInstr inp)
getImpl HST inp
inp SingT n2
SingT (GetOpVal ('TMap n1 n2))
v VarAnn
varNotes
(U.GET VarAnn
varNotes,
(SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> SingT (GetOpVal ('TBigMap n1 n2))
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (getKey :: T) (rs :: [T]) (inp :: [T])
(m :: * -> *).
(GetOp c, SingI (GetOpKey c), WellTyped (GetOpVal c),
inp ~ (getKey : c : rs), SingI rs, MonadReader TypeCheckInstrEnv m,
MonadError TCError m) =>
HST inp -> SingT (GetOpVal c) -> VarAnn -> m (SomeInstr inp)
getImpl HST inp
inp SingT n2
SingT (GetOpVal ('TBigMap n1 n2))
v VarAnn
varNotes
(U.GET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"map 'k 'v"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"big_map 'k 'v"])
]
(U.GET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.GETN VarAnn
_ Word
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.GETN VarAnn
getNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
ix0 HST inp
HST (x : xs)
inp ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper (x : xs))
-> (TCGetNHelper (x : xs) -> SomeInstr (x : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCGetNHelper PeanoNatural ix
s HST (GetN ix pair : rest)
out ->
HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> PeanoNatural ix -> Instr (x : xs) (GetN ix x : xs)
forall (ix :: Nat) (pair :: T) (s :: [T]).
ConstraintGetN ix pair =>
AnnVar -> PeanoNatural ix -> Instr (pair : s) (GetN ix pair : s)
AnnGETN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
getNVarAnn) PeanoNatural ix
s Instr (x : xs) (GetN ix x : xs)
-> HST (GetN ix x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (GetN ix x : xs)
HST (GetN ix pair : rest)
out
where
go :: forall x xs. Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go :: forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go Word
0 ((SingT x
a, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
TCGetNHelper (x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper (x : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper (x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper (x : xs)))
-> TCGetNHelper (x : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z -> HST (GetN 'Z x : xs) -> TCGetNHelper (x : xs)
forall (n :: Nat) (out :: T) (s :: [T]).
(SingI (GetN n out : s), ConstraintGetN n out) =>
PeanoNatural n -> HST (GetN n out : s) -> TCGetNHelper (out : s)
TCGetNHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero ((SingT x
a, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest)
go Word
1 ((STPair Sing n1
leftNotes Sing n2
_, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
TCGetNHelper ('TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCGetNHelper ('TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper ('TPair n1 n2 : xs)))
-> TCGetNHelper ('TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper ('TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (GetN ('S 'Z) ('TPair n1 n2) : xs)
-> TCGetNHelper ('TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: [T]).
(SingI (GetN n out : s), ConstraintGetN n out) =>
PeanoNatural n -> HST (GetN n out : s) -> TCGetNHelper (out : s)
TCGetNHelper PeanoNatural ('S 'Z)
forall (n :: Nat). (n ~ 'S 'Z) => PeanoNatural n
One (HST (GetN ('S 'Z) ('TPair n1 n2) : xs)
-> TCGetNHelper ('TPair n1 n2 : xs))
-> HST (GetN ('S 'Z) ('TPair n1 n2) : xs)
-> TCGetNHelper ('TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$ (Sing n1
SingT n1
leftNotes, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
go Word
ix ((STPair Sing n1
_ Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
Word -> HST (n2 : xs) -> TypeCheckInstr (TCGetNHelper (n2 : xs))
forall (x :: T) (xs :: [T]).
Word -> HST (x : xs) -> TypeCheckInstr (TCGetNHelper (x : xs))
go (Word
ix Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
2) ((Sing n2
SingT n2
rightNotes, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper (n2 : xs))
-> (TCGetNHelper (n2 : xs) -> TCGetNHelper ('TPair n1 n2 : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCGetNHelper ('TPair n1 n2 : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(TCGetNHelper PeanoNatural ix
ixSing HST (GetN ix pair : rest)
out) ->
PeanoNatural ('S ('S ix))
-> HST (GetN ('S ('S ix)) ('TPair n1 n2) : rest)
-> TCGetNHelper ('TPair n1 n2 : rest)
forall (n :: Nat) (out :: T) (s :: [T]).
(SingI (GetN n out : s), ConstraintGetN n out) =>
PeanoNatural n -> HST (GetN n out : s) -> TCGetNHelper (out : s)
TCGetNHelper (PeanoNatural ('S ix) -> PeanoNatural ('S ('S ix))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ (PeanoNatural ix -> PeanoNatural ('S ix)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural ix
ixSing)) HST (GetN ix pair : rest)
HST (GetN ('S ('S ix)) ('TPair n1 n2) : rest)
out
go Word
_ HST (x : xs)
_ = TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCGetNHelper (x : xs))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCGetNHelper (x : xs)))
-> TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCGetNHelper (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Word -> Text
pairWithNodeIndex Word
ix0 Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.UPDATE VarAnn
varAnn,
(SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
(inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
inp ~ (updKey : updParams : c : rs),
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
(U.UPDATE VarAnn
varAnn,
(SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k Sing n2
v, Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
(inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
inp ~ (updKey : updParams : c : rs),
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
(U.UPDATE VarAnn
varAnn,
(SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STSet Sing n
s, Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TSet n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TSet n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TSet n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TSet n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TSet n : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TSet n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : 'TSet n : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
(inp :: [T]) (m :: * -> *).
(UpdOp c, SingI (UpdOpKey c), SingI (UpdOpParams c), SingI rs,
inp ~ (updKey : updParams : c : rs),
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
updImpl HST inp
inp VarAnn
varAnn
(U.UPDATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool", Text
"set 'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"map 'k 'v"])
, (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"big_map 'k 'v"])
]
(U.UPDATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.UPDATEN VarAnn
updateNVarAnn Word
ix0, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
Word
-> HST (x : x : xs)
-> TypeCheckInstr (TCUpdateNHelper (x : x : xs))
forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go Word
ix0 HST inp
HST (x : x : xs)
inp ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (x : x : xs))
-> (TCUpdateNHelper (x : x : xs) -> SomeInstr (x : x : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCUpdateNHelper PeanoNatural ix
s HST (UpdateN ix val pair : rest)
out ->
HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> PeanoNatural ix -> Instr (x : x : xs) (UpdateN ix x x : xs)
forall (ix :: Nat) (val :: T) (pair :: T) (s :: [T]).
ConstraintUpdateN ix pair =>
AnnVar
-> PeanoNatural ix
-> Instr (val : pair : s) (UpdateN ix val pair : s)
AnnUPDATEN (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
updateNVarAnn) PeanoNatural ix
s Instr (x : x : xs) (UpdateN ix x x : xs)
-> HST (UpdateN ix x x : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (UpdateN ix x x : xs)
HST (UpdateN ix val pair : rest)
out
where
go :: forall val pair rest. Word -> HST (val : pair : rest) -> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go :: forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go Word
0 ((SingT x
valNotes, Dict (WellTyped x)
Dict) ::& (SingT x
_, Dict (WellTyped x)
_) ::& HST xs
rest) =
TCUpdateNHelper (val : pair : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : pair : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : pair : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : pair : xs)))
-> TCUpdateNHelper (val : pair : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : pair : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural 'Z
-> HST (UpdateN 'Z val pair : xs)
-> TCUpdateNHelper (val : pair : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UpdateN n out s : s'), ConstraintUpdateN n s) =>
PeanoNatural n
-> HST (UpdateN n out s : s') -> TCUpdateNHelper (out : s : s')
TCUpdateNHelper PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero (HST (UpdateN 'Z val pair : xs)
-> TCUpdateNHelper (val : pair : xs))
-> HST (UpdateN 'Z val pair : xs)
-> TCUpdateNHelper (val : pair : xs)
forall a b. (a -> b) -> a -> b
$
(SingT x
valNotes, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
go Word
1 ((SingT x
valNotes, Dict (WellTyped x)
Dict) ::& (STPair Sing n1
_ Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
TCUpdateNHelper (val : 'TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : 'TPair n1 n2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCUpdateNHelper (val : 'TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : 'TPair n1 n2 : xs)))
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : 'TPair n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ PeanoNatural ('S 'Z)
-> HST (UpdateN ('S 'Z) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UpdateN n out s : s'), ConstraintUpdateN n s) =>
PeanoNatural n
-> HST (UpdateN n out s : s') -> TCUpdateNHelper (out : s : s')
TCUpdateNHelper PeanoNatural ('S 'Z)
forall (n :: Nat). (n ~ 'S 'Z) => PeanoNatural n
One (HST (UpdateN ('S 'Z) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs))
-> HST (UpdateN ('S 'Z) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$
(Sing val -> Sing n2 -> SingT ('TPair val n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing val
SingT x
valNotes Sing n2
rightNotes, Dict (WellTyped ('TPair val n2))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair val n2), Dict (WellTyped ('TPair val n2)))
-> HST xs -> HST ('TPair val n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest
go Word
ix ((SingT x, Dict (WellTyped x))
val ::& (STPair Sing n1
leftNotes Sing n2
rightNotes, Dict (WellTyped x)
Dict) ::& HST xs
rest) =
Word
-> HST (x : n2 : xs)
-> TypeCheckInstr (TCUpdateNHelper (x : n2 : xs))
forall (val :: T) (pair :: T) (rest :: [T]).
Word
-> HST (val : pair : rest)
-> TypeCheckInstr (TCUpdateNHelper (val : pair : rest))
go (Word
ix Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
2) ((SingT x, Dict (WellTyped x))
val (SingT x, Dict (WellTyped x)) -> HST (n2 : xs) -> HST (x : n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (Sing n2
SingT n2
rightNotes, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rest) ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : n2 : rest))
-> (TCUpdateNHelper (val : n2 : rest)
-> TCUpdateNHelper (val : 'TPair n1 n2 : rest))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(TCUpdateNHelper (val : 'TPair n1 n2 : rest))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&>
\(TCUpdateNHelper PeanoNatural ix
ixSing ((SingT x
updatedRightNotes, Dict (WellTyped x)
Dict) ::& HST xs
outRest)) ->
PeanoNatural ('S ('S ix))
-> HST (UpdateN ('S ('S ix)) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall (n :: Nat) (out :: T) (s :: T) (s' :: [T]).
(SingI (UpdateN n out s : s'), ConstraintUpdateN n s) =>
PeanoNatural n
-> HST (UpdateN n out s : s') -> TCUpdateNHelper (out : s : s')
TCUpdateNHelper (PeanoNatural ('S ix) -> PeanoNatural ('S ('S ix))
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ (PeanoNatural ix -> PeanoNatural ('S ix)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural ix
ixSing)) (HST (UpdateN ('S ('S ix)) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs))
-> HST (UpdateN ('S ('S ix)) val ('TPair n1 n2) : xs)
-> TCUpdateNHelper (val : 'TPair n1 n2 : xs)
forall a b. (a -> b) -> a -> b
$
(Sing n1
-> Sing (UpdateN ix val n2)
-> SingT ('TPair n1 (UpdateN ix val n2))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing n1
leftNotes Sing (UpdateN ix val n2)
SingT x
updatedRightNotes, Dict (WellTyped ('TPair n1 (UpdateN ix val n2)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair n1 (UpdateN ix val n2)),
Dict (WellTyped ('TPair n1 (UpdateN ix val n2))))
-> HST xs -> HST ('TPair n1 (UpdateN ix val n2) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
outRest
go Word
_ HST (val : pair : rest)
_ = TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCUpdateNHelper (val : pair : rest))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCUpdateNHelper (val : pair : rest)))
-> TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
(TCUpdateNHelper (val : pair : rest))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'val" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Word -> Text
pairWithNodeIndex Word
ix0]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.UPDATEN VarAnn
_ Word
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.GET_AND_UPDATE VarAnn
varAnn,
(SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
(inp :: [T]) (m :: * -> *).
(UpdOp c, GetOp c, SingI (UpdOpKey c), SingI (GetOpVal c),
inp ~ (updKey : updParams : c : rs), SingI rs,
GetOpKey c ~ UpdOpKey c, UpdOpParams c ~ 'TOption (GetOpVal c),
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
getUpdImpl HST inp
inp VarAnn
varAnn
(U.GET_AND_UPDATE VarAnn
varAnn,
(SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (STBigMap Sing n1
k (SingT n2
v :: SingT v), Dict (WellTyped x)
_) ::& HST xs
_) ->
Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
k ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
v ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : x : 'TBigMap n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (updKey :: T) (updParams :: T) (rs :: [T])
(inp :: [T]) (m :: * -> *).
(UpdOp c, GetOp c, SingI (UpdOpKey c), SingI (GetOpVal c),
inp ~ (updKey : updParams : c : rs), SingI rs,
GetOpKey c ~ UpdOpKey c, UpdOpParams c ~ 'TOption (GetOpVal c),
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
getUpdImpl HST inp
inp VarAnn
varAnn
(U.GET_AND_UPDATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"map 'k 'v"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"'k" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"option 'v", Text
"big_map 'k 'v"])
]
(U.GET_AND_UPDATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.IF [ExpandedOp]
mp [ExpandedOp]
mq, (STBool{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
(forall (s' :: [T]).
Instr xs s' -> Instr xs s' -> Instr ('TBool : xs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST xs
-> HST xs
-> HST ('TBool : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr xs s' -> Instr xs s' -> Instr ('TBool : xs) s'
forall (s :: [T]) (out :: [T]).
Instr s out -> Instr s out -> Instr ('TBool : s) out
IF forall op. [op] -> [op] -> InstrAbstract op
U.IF [ExpandedOp]
mp [ExpandedOp]
mq HST xs
rs HST xs
rs HST inp
HST ('TBool : xs)
inp
(U.IF [ExpandedOp]
_ [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.IF [ExpandedOp]
_ [ExpandedOp]
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LOOP [ExpandedOp]
is, (STBool{}, Dict (WellTyped x)
_) ::& (HST xs
rs :: HST rs)) -> do
TypeCheckInstrNoExcept (TypeCheckedSeq xs)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr xs -> TypeCheckInstr (SomeInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST xs -> TypeCheckInstrNoExcept (TypeCheckedSeq xs)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is HST xs
rs) [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.LOOP ((SomeInstr xs -> TypeCheckInstr (SomeInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs)))
-> (SomeInstr xs -> TypeCheckInstr (SomeInstr ('TBool : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall a b. (a -> b) -> a -> b
$ \(HST xs
_ :/ SomeInstrOut xs
tp) ->
case SomeInstrOut xs
tp of
Instr xs out
subI ::: (HST out
o :: HST o) -> do
case HST out
-> HST ('TBool : xs) -> Either TCTypeError (out :~: ('TBool : xs))
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o (forall {k} (a :: k). SingI a => Sing a
forall (a :: T). SingI a => Sing a
sing @'TBool Sing 'TBool -> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(WellTyped x, SingI xs) =>
Sing x -> HST xs -> HST (x : xs)
-:& HST xs
rs) of
Right out :~: ('TBool : xs)
Refl -> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr xs ('TBool : xs) -> Instr ('TBool : xs) xs
forall (out :: [T]).
Instr out ('TBool : out) -> Instr ('TBool : out) out
LOOP Instr xs out
Instr xs ('TBool : xs)
subI Instr ('TBool : xs) xs -> HST xs -> SomeInstrOut ('TBool : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs
Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBool : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
m
AnyOutInstr forall (out :: [T]). Instr xs out
subI ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr xs ('TBool : xs) -> Instr ('TBool : xs) xs
forall (out :: [T]).
Instr out ('TBool : out) -> Instr ('TBool : out) out
LOOP Instr xs ('TBool : xs)
forall (out :: [T]). Instr xs out
subI Instr ('TBool : xs) xs -> HST xs -> SomeInstrOut ('TBool : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs
(U.LOOP [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.LOOP [ExpandedOp]
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LOOP_LEFT [ExpandedOp]
is, (os :: SingT x
os@(STOr (SingT n1
an :: SingT t) (SingT n2
bn :: SingT b)), Dict (WellTyped x)
Dict) ::& HST xs
rs) -> do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t ((WellTyped n1 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n1 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @b ((WellTyped n2 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
let ait :: HST (n1 : xs)
ait = (SingT n1
an, Dict (WellTyped n1)
forall (a :: Constraint). a => Dict a
Dict) (SingT n1, Dict (WellTyped n1)) -> HST xs -> HST (n1 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs
TypeCheckInstrNoExcept (TypeCheckedSeq (n1 : xs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (n1 : xs)
-> TypeCheckInstr (SomeInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST (n1 : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (n1 : xs))
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is HST (n1 : xs)
ait) [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.LOOP_LEFT ((SomeInstr (n1 : xs)
-> TypeCheckInstr (SomeInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs)))
-> (SomeInstr (n1 : xs)
-> TypeCheckInstr (SomeInstr ('TOr n1 n2 : xs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TOr n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ \(HST (n1 : xs)
_ :/ SomeInstrOut (n1 : xs)
tp) ->
case SomeInstrOut (n1 : xs)
tp of
Instr (n1 : xs) out
subI ::: HST out
o -> do
case (HST out
-> HST ('TOr n1 n2 : xs)
-> Either TCTypeError (out :~: ('TOr n1 n2 : xs))
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o (Sing ('TOr n1 n2)
SingT x
os Sing ('TOr n1 n2) -> HST xs -> HST ('TOr n1 n2 : xs)
forall (x :: T) (xs :: [T]).
(WellTyped x, SingI xs) =>
Sing x -> HST xs -> HST (x : xs)
-:& HST xs
rs), HST out
o) of
(Right out :~: ('TOr n1 n2 : xs)
Refl, (SingT x
_, Dict (WellTyped x)
Dict) ::& HST xs
rs') ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (n1 : xs) ('TOr n1 n2 : xs)
-> Instr ('TOr n1 n2 : xs) (n2 : xs)
forall (a :: T) (s :: [T]) (b :: T).
Instr (a : s) ('TOr a b : s) -> Instr ('TOr a b : s) (b : s)
LOOP_LEFT Instr (n1 : xs) out
Instr (n1 : xs) ('TOr n1 n2 : xs)
subI Instr ('TOr n1 n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut ('TOr n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT n2
bn, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs')
(Left TCTypeError
m, HST out
_) -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TOr n1 n2 : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
m
AnyOutInstr forall (out :: [T]). Instr (n1 : xs) out
subI -> do
let br :: (SingT n2, Dict (WellTyped n2))
br = (SingT n2
bn, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (n1 : xs) ('TOr n1 n2 : xs)
-> Instr ('TOr n1 n2 : xs) (n2 : xs)
forall (a :: T) (s :: [T]) (b :: T).
Instr (a : s) ('TOr a b : s) -> Instr ('TOr a b : s) (b : s)
LOOP_LEFT Instr (n1 : xs) ('TOr n1 n2 : xs)
forall (out :: [T]). Instr (n1 : xs) out
subI Instr ('TOr n1 n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut ('TOr n1 n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT n2, Dict (WellTyped n2))
br (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.LOOP_LEFT [ExpandedOp]
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"or 'a 'b" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.LOOP_LEFT [ExpandedOp]
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LAMBDA VarAnn
vn p1 :: Ty
p1@(AsUType (Notes t
ins :: Notes t)) p2 :: Ty
p2@(AsUType (Notes t
ons :: Notes u)) [ExpandedOp]
is, HST inp
i) -> do
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @t ((WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' @u ((WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes t, Notes t]
-> ExpandedInstr
-> [ExpandedOp]
-> SingT t
-> SingT t
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (it :: T) (ot :: T) (ts :: [T]).
(WellTyped it, WellTyped ot, SingI ts) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes it, Notes ot]
-> ExpandedInstr
-> [ExpandedOp]
-> SingT it
-> SingT ot
-> HST ts
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl (VarAnn -> Ty -> Ty -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. VarAnn -> Ty -> Ty -> [op] -> InstrAbstract op
U.LAMBDA VarAnn
vn Ty
p1 Ty
p2) (VarAnn -> Notes t -> Notes t -> Anns '[VarAnn, Notes t, Notes t]
forall {k} (a :: k) (t :: T) (u :: T).
(Typeable a, SingI t, SingI u) =>
Annotation a
-> Notes t -> Notes u -> Anns '[Annotation a, Notes t, Notes u]
Anns3'' VarAnn
vn Notes t
ins Notes t
ons) ExpandedInstr
uInstr [ExpandedOp]
is (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ins) (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
ons) HST inp
i
(U.EXEC VarAnn
vn, ((SingT x
_ :: SingT t1), Dict (WellTyped x)
_)
::& ( STLambda (SingT n1
v :: SingT t1') (SingT n2
b :: SingT t2'), Dict (WellTyped x)
_)
::& HST xs
rs) -> Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
v ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
b ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda n1 n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TLambda n1 n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
x :~: n1
Refl <- Either TCTypeError (x :~: n1)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: n1)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (x :~: n1)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: n1))
-> Either TCTypeError (x :~: n1)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: n1)
forall a b. (a -> b) -> a -> b
$ forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t1'
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t2' ((WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs)))
-> (WellTyped n2 =>
TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda x n2 : xs))
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : 'TLambda x n2 : xs) (n2 : xs)
forall (t1 :: T) (t2 :: T) (s :: [T]).
AnnVar -> Instr (t1 : 'TLambda t1 t2 : s) (t2 : s)
AnnEXEC (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TLambda x n2 : xs) (n2 : xs)
-> HST (n2 : xs) -> SomeInstrOut (x : 'TLambda x n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT n2
b, Dict (WellTyped n2)
forall (a :: Constraint). a => Dict a
Dict) (SingT n2, Dict (WellTyped n2)) -> HST xs -> HST (n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
where
errM :: (MonadReader TypeCheckInstrEnv m, MonadError TCError m) => Either TCTypeError a -> m a
errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaArgument)
(U.EXEC VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"lambda 'a 'b"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.EXEC VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.APPLY VarAnn
vn, ((SingT x
_ :: SingT a'), Dict (WellTyped x)
_)
::& ( STLambda (STPair (SingT n1
lt :: SingT a) (SingT n2
rt :: SingT b) :: SingT t1) (SingT n2
b :: SingT t2), Dict (WellTyped x)
_)
::& HST xs
rs) -> Sing n1
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n1
SingT n1
lt ((SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n1 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
rt ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ Sing n2
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n2
SingT n2
b ((SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (SingI n2 =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TLambda t1 t2) ((WellTyped ('TLambda n1 n2) =>
TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr
(SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> (WellTyped ('TLambda n1 n2) =>
TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TLambda ('TPair n1 n2) n2 : xs))
forall a b. (a -> b) -> a -> b
$ do
x :~: n1
proofArgEq <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (x :~: n1)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: n1)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaArgument)
(forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @a' @a)
Dict (ConstantScope n1)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaArgument)
(Either BadTypeForScope (Dict (ConstantScope n1))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ConstantScope n1)))
-> Either BadTypeForScope (Dict (ConstantScope n1))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ConstantScope n1))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope a)
case (x :~: n1
proofArgEq, Dict (ConstantScope n1)
proofScope) of
(x :~: n1
Refl, Dict (ConstantScope n1)
Dict) ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ forall (a :: T) (b :: T) (c :: T) (s :: [T]).
(ConstantScope a, SingI b) =>
AnnVar
-> Instr (a : 'TLambda ('TPair a b) c : s) ('TLambda b c : s)
AnnAPPLY @a (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (n1 : 'TLambda ('TPair n1 n2) n2 : xs) ('TLambda n2 n2 : xs)
-> HST ('TLambda n2 n2 : xs)
-> SomeInstrOut (n1 : 'TLambda ('TPair n1 n2) n2 : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing n2 -> Sing n2 -> SingT ('TLambda n2 n2)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TLambda n1 n2)
STLambda Sing n2
SingT n2
rt Sing n2
SingT n2
b, Dict (WellTyped ('TLambda n2 n2))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TLambda n2 n2), Dict (WellTyped ('TLambda n2 n2)))
-> HST xs -> HST ('TLambda n2 n2 : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.APPLY VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"lambda (pair 'a 'b) 'c"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.APPLY VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.DIP [ExpandedOp]
is, (SingT x, Dict (WellTyped x))
a ::& HST xs
s) -> do
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST xs
-> (TCError -> [IllTypedInstr] -> TypeCheckedSeq (x : xs))
-> (forall (out :: [T]).
SingI out =>
Instr xs out -> HST out -> TypeCheckedSeq (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (inp :: [T]) r.
SingI inp =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall (out :: [T]).
SingI out =>
Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.DIP ExpandedInstr
uInstr [ExpandedOp]
is HST xs
s
(TCError -> [IllTypedInstr] -> TypeCheckedSeq (x : xs)
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq)
(\Instr xs out
subI HST out
t -> SomeInstr inp -> TypeCheckedSeq inp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedSeq inp
WellTypedSeq (SomeInstr inp -> TypeCheckedSeq inp)
-> SomeInstr inp -> TypeCheckedSeq inp
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr xs out -> Instr (x : xs) (x : out)
forall (a :: [T]) (c :: [T]) (b :: T).
Instr a c -> Instr (b : a) (b : c)
DIP Instr xs out
subI Instr (x : xs) (x : out) -> HST (x : out) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x, Dict (WellTyped x))
a (SingT x, Dict (WellTyped x)) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST out
t))
(U.DIP [ExpandedOp]
_is, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.DIPN Word
nTotal [ExpandedOp]
instructions, HST inp
inputHST) ->
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
go Word
nTotal HST inp
inputHST ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TCDipHelper inp)
-> (TCDipHelper inp -> TypeCheckedSeq inp)
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq inp)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCDipHelperErr TCError
err [IllTypedInstr]
rest -> TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
forall (inp :: [T]).
TCError -> [IllTypedInstr] -> TypeCheckedSeq inp
IllTypedSeq TCError
err [IllTypedInstr]
rest
TCDipHelperOk PeanoNatural n
s Instr s s'
subI HST out
out -> SomeInstr inp -> TypeCheckedSeq inp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedSeq inp
WellTypedSeq (SomeInstr inp -> TypeCheckedSeq inp)
-> SomeInstr inp -> TypeCheckedSeq inp
forall a b. (a -> b) -> a -> b
$ HST inp
inputHST HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ PeanoNatural n -> Instr s s' -> Instr inp out
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T]).
ConstraintDIPN n inp out s s' =>
PeanoNatural n -> Instr s s' -> Instr inp out
DIPN PeanoNatural n
s Instr s s'
subI Instr inp out -> HST out -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
out
where
go :: forall inp. SingI inp
=> Word
-> HST inp
-> TypeCheckInstrNoExcept (TCDipHelper inp)
go :: forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
go Word
n HST inp
curHST = case (Word
n, HST inp
curHST) of
(Word
0, HST inp
_) -> ([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> TCDipHelper inp)
-> (forall (out :: [T]).
SingI out =>
Instr inp out -> HST out -> TCDipHelper inp)
-> TypeCheckInstrNoExcept (TCDipHelper inp)
forall (inp :: [T]) r.
SingI inp =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall (out :: [T]).
SingI out =>
Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody (Word -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. Word -> [op] -> InstrAbstract op
U.DIPN Word
nTotal) ExpandedInstr
uInstr [ExpandedOp]
instructions HST inp
curHST
(TCError -> [IllTypedInstr] -> TCDipHelper inp
forall (inp :: [T]). TCError -> [IllTypedInstr] -> TCDipHelper inp
TCDipHelperErr)
(PeanoNatural 'Z -> Instr inp out -> HST out -> TCDipHelper inp
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T]).
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper inp
TCDipHelperOk PeanoNatural 'Z
forall (n :: Nat). (n ~ 'Z) => PeanoNatural n
Zero)
(Word
_, HST inp
SNil) -> do
ErrorSrcPos
pos <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
let err :: TCError
err = ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) ErrorSrcPos
pos Maybe TypeContext
forall a. Maybe a
Nothing (TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
NotEnoughItemsOnStack)
TCDipHelper '[]
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TCDipHelper '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TCDipHelper '[]
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TCDipHelper '[]))
-> TCDipHelper '[]
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TCDipHelper '[])
forall a b. (a -> b) -> a -> b
$ TCError -> [IllTypedInstr] -> TCDipHelper '[]
forall (inp :: [T]). TCError -> [IllTypedInstr] -> TCDipHelper inp
TCDipHelperErr TCError
err [ExpandedOp -> IllTypedInstr
NonTypedInstr (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> ExpandedOp
U.PrimEx ExpandedInstr
uInstr]
(Word
_, (SingT x, Dict (WellTyped x))
hstHead ::& HST xs
hstTail) ->
Word -> HST xs -> TypeCheckInstrNoExcept (TCDipHelper xs)
forall (inp :: [T]).
SingI inp =>
Word -> HST inp -> TypeCheckInstrNoExcept (TCDipHelper inp)
go (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) HST xs
hstTail ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TCDipHelper xs)
-> (TCDipHelper xs -> TCDipHelper (x : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TCDipHelper (x : xs))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
TCDipHelperOk PeanoNatural n
s Instr s s'
subI HST out
out -> PeanoNatural ('S n)
-> Instr s s' -> HST (x : out) -> TCDipHelper (x : xs)
forall (n :: Nat) (inp :: [T]) (out :: [T]) (s :: [T]) (s' :: [T]).
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper inp
TCDipHelperOk (PeanoNatural n -> PeanoNatural ('S n)
forall (n :: Nat) (m :: Nat).
(n ~ 'S m) =>
PeanoNatural m -> PeanoNatural n
Succ PeanoNatural n
s) Instr s s'
subI ((SingT x, Dict (WellTyped x))
hstHead (SingT x, Dict (WellTyped x)) -> HST out -> HST (x : out)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST out
out)
TCDipHelperErr TCError
err [IllTypedInstr]
rest -> TCError -> [IllTypedInstr] -> TCDipHelper (x : xs)
forall (inp :: [T]). TCError -> [IllTypedInstr] -> TCDipHelper inp
TCDipHelperErr TCError
err [IllTypedInstr]
rest
(ExpandedInstr
U.FAILWITH, ((SingT x
_ :: SingT a, Dict (WellTyped x)
_) ::& HST xs
_)) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
Dict (ConstantScope x)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
FailwithArgument)
(Either BadTypeForScope (Dict (ConstantScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ConstantScope x)))
-> Either BadTypeForScope (Dict (ConstantScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ConstantScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ConstantScope a)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ (forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
AnyOutInstr forall (out :: [T]). Instr inp out
forall (a :: T) (s :: [T]) (out :: [T]).
(SingI a, ConstantScope a) =>
Instr (a : s) out
FAILWITH
(ExpandedInstr
U.FAILWITH, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.CAST VarAnn
vn (AsUType (Notes t
castToNotes :: Notes t)), (SingT x
_ :: SingT t1, Dict (WellTyped x)
_) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
t :~: x
Refl <- Either TCTypeError (t :~: x)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(t :~: x)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (t :~: x)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(t :~: x))
-> Either TCTypeError (t :~: x)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(t :~: x)
forall a b. (a -> b) -> a -> b
$ forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t @t1
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr (t : xs)))
-> TypeCheckInstr (SomeInstr (t : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (t : xs)))
-> TypeCheckInstr (SomeInstr (t : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t] -> Instr (t : xs) (t : xs)
forall (a :: T) (s :: [T]).
SingI a =>
Anns '[VarAnn, Notes a] -> Instr (a : s) (a : s)
AnnCAST (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
castToNotes) Instr (t : xs) (t : xs) -> HST (t : xs) -> SomeInstrOut (t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
castToNotes, Dict (WellTyped t)
forall (a :: Constraint). a => Dict a
Dict) (SingT t, Dict (WellTyped t)) -> HST xs -> HST (t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
where
errM :: (MonadReader TypeCheckInstrEnv m, MonadError TCError m) => Either TCTypeError a -> m a
errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Cast)
(U.CAST VarAnn
_ Ty
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.RENAME VarAnn
vn, (SingT x
an, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : xs) (x : xs)
forall (a :: T) (s :: [T]). AnnVar -> Instr (a : s) (a : s)
AnnRENAME (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : xs) (x : xs) -> HST (x : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT x
an, Dict (WellTyped x)
forall (a :: Constraint). a => Dict a
Dict) (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.RENAME VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.UNPACK TypeAnn
tn VarAnn
vn Ty
mt, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBytes : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBytes : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBytes : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBytes : xs)))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBytes : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
tns :: Notes tn) -> do
case TypeAnn -> Notes t -> Notes ('TOption t)
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TOption t1)
NTOption TypeAnn
tn Notes t
tns of
(Notes ('TOption t)
ns :: Notes ('TOption t1)) -> forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TOption t1) ((WellTyped ('TOption t) =>
TypeCheckInstr (SomeInstr ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs)))
-> (WellTyped ('TOption t) =>
TypeCheckInstr (SomeInstr ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$ do
Dict (UnpackedValScope t)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @tn ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
(Either BadTypeForScope (Dict (UnpackedValScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (UnpackedValScope t)))
-> Either BadTypeForScope (Dict (UnpackedValScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (UnpackedValScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(UnpackedValScope tn)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[TypeAnn, VarAnn, Notes t]
-> Instr ('TBytes : xs) ('TOption t : xs)
forall (a :: T) (s :: [T]).
(UnpackedValScope a, SingI a) =>
Anns '[TypeAnn, VarAnn, Notes a]
-> Instr ('TBytes : s) ('TOption a : s)
AnnUNPACK (TypeAnn -> VarAnn -> Notes t -> Anns '[TypeAnn, VarAnn, Notes t]
forall {k} (a :: k) (b :: k) (t :: T).
(Each '[Typeable] '[a, b], SingI t) =>
Annotation a
-> Annotation b
-> Notes t
-> Anns '[Annotation a, Annotation b, Notes t]
Anns3' TypeAnn
tn VarAnn
vn Notes t
tns) Instr ('TBytes : xs) ('TOption t : xs)
-> HST ('TOption t : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TOption t) -> Sing ('TOption t)
forall (t :: T). Notes t -> Sing t
notesSing Notes ('TOption t)
ns, Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption t), Dict (WellTyped ('TOption t)))
-> HST xs -> HST ('TOption t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.UNPACK {}, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.UNPACK {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.PACK VarAnn
vn, (SingT x
_ :: SingT a, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ do
Dict (PackedValScope x)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @a ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
(Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (PackedValScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(PackedValScope a)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : xs) ('TBytes : xs)
forall (a :: T) (s :: [T]).
PackedValScope a =>
AnnVar -> Instr (a : s) ('TBytes : s)
AnnPACK (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.PACK VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.CONCAT VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TBytes : 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, inp ~ (c : c : rs), WellTyped c,
MonadReader TypeCheckInstrEnv m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl HST inp
inp VarAnn
vn
(U.CONCAT VarAnn
vn, (STString{}, Dict (WellTyped x)
_) ::& (STString{}, Dict (WellTyped x)
_) ::& HST xs
_) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TString : 'TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TString : 'TString : xs)))
-> TypeCheckInstr (SomeInstr ('TString : 'TString : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TString : 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, inp ~ (c : c : rs), WellTyped c,
MonadReader TypeCheckInstrEnv m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl HST inp
inp VarAnn
vn
(U.CONCAT VarAnn
vn, (STList Sing n
SingT n
STBytes, Dict (WellTyped x)
_) ::& HST xs
_) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TList 'TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, WellTyped c, inp ~ ('TList c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl' HST inp
inp VarAnn
vn
(U.CONCAT VarAnn
vn, (STList Sing n
SingT n
STString, Dict (WellTyped x)
_) ::& HST xs
_) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TString : xs)))
-> TypeCheckInstr (SomeInstr ('TList 'TString : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TList 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(ConcatOp c, WellTyped c, inp ~ ('TList c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
concatImpl' HST inp
inp VarAnn
vn
(U.CONCAT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"string" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"string"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bytes"])
, (Text
"list string" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"list string"])
, (Text
"list bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"list bytes"])
]
(U.CONCAT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SLICE VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::&
(STNat{}, Dict (WellTyped x)
_) ::&
(STString{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TNat : 'TNat : 'TString : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TNat : 'TNat : 'TString : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TString : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TNat : 'TNat : 'TString : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SliceOp c, inp ~ ('TNat : 'TNat : c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sliceImpl HST inp
inp VarAnn
vn
(U.SLICE VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::&
(STNat{}, Dict (WellTyped x)
_) ::&
(STBytes{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TNat : 'TNat : 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TNat : 'TNat : 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TNat : 'TNat : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$ HST inp
-> VarAnn
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (c :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SliceOp c, inp ~ ('TNat : 'TNat : c : rs), Monad m) =>
HST inp -> VarAnn -> m (SomeInstr inp)
sliceImpl HST inp
inp VarAnn
vn
(U.SLICE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat", Text
"string"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat", Text
"bytes"])
]
(U.SLICE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.ISNAT VarAnn
vn', (STInt{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TInt : xs) ('TOption 'TNat : xs)
forall (s :: [T]). AnnVar -> Instr ('TInt : s) ('TOption 'TNat : s)
AnnISNAT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn') Instr ('TInt : xs) ('TOption 'TNat : xs)
-> HST ('TOption 'TNat : xs) -> SomeInstrOut ('TInt : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOption 'TNat)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TOption 'TNat))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption 'TNat), Dict (WellTyped ('TOption 'TNat)))
-> HST xs -> HST ('TOption 'TNat : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.ISNAT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.ISNAT VarAnn
_, HST inp
SNil)-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.ADD VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
addImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr
(U.ADD VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SUB VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
subImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr
(U.SUB VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SUB_MUTEZ VarAnn
vn, (SingT x
STMutez, Dict (WellTyped x)
_) ::& (SingT x
STMutez, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMutez : 'TMutez : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TMutez : 'TMutez : xs)))
-> TypeCheckInstr (SomeInstr ('TMutez : 'TMutez : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TMutez : 'TMutez : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @SubMutez AnnVar
-> Instr
('TMutez : 'TMutez : xs) (ArithRes SubMutez 'TMutez 'TMutez : xs)
forall (s :: [T]).
AnnVar -> Instr ('TMutez : 'TMutez : s) ('TOption 'TMutez : s)
AnnSUB_MUTEZ HST inp
HST ('TMutez : 'TMutez : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.SUB_MUTEZ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"mutez" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"mutez"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SUB_MUTEZ VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.MUL VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(Each '[SingI] '[a, b], inp ~ (a : b : rs), SingI rs,
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
mulImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr
(U.MUL VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.EDIV VarAnn
vn, (SingT x
a, Dict (WellTyped x)
_) ::& (SingT x
b, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$
Sing x
-> Sing x
-> HST inp
-> VarAnn
-> ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (a :: T) (b :: T) (inp :: [T]) (rs :: [T]) (m :: * -> *).
(SingI rs, Each '[SingI] '[a, b], inp ~ (a : b : rs),
MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Sing a
-> Sing b
-> HST inp
-> VarAnn
-> ExpandedInstr
-> m (SomeInstr inp)
edivImpl Sing x
SingT x
a Sing x
SingT x
b HST inp
inp VarAnn
vn ExpandedInstr
uInstr
(U.EDIV VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.ABS VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Abs (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Abs 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Abs n =>
AnnVar -> Instr (n : s) (UnaryArithRes Abs n : s)
AnnABS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.ABS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.ABS VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.NEG VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Neg 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.NEG VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TNat : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TNat : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TNat : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TNat : xs)))
-> SomeInstr ('TNat : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TNat : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Neg (AnnVar -> Instr ('TNat : xs) (UnaryArithRes Neg 'TNat : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TNat : xs)
inp VarAnn
vn
(U.NEG VarAnn
vn, (SingT x
STBls12381Fr, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TBls12381Fr : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381Fr : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBls12381Fr : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381Fr : xs)))
-> SomeInstr ('TBls12381Fr : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar
-> Instr ('TBls12381Fr : xs) (UnaryArithRes Neg 'TBls12381Fr : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBls12381Fr : xs)
inp VarAnn
vn
(U.NEG VarAnn
vn, (SingT x
STBls12381G1, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381G1 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G1 : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TBls12381G1 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381G1 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBls12381G1 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381G1 : xs)))
-> SomeInstr ('TBls12381G1 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381G1 : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar
-> Instr ('TBls12381G1 : xs) (UnaryArithRes Neg 'TBls12381G1 : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBls12381G1 : xs)
inp VarAnn
vn
(U.NEG VarAnn
vn, (SingT x
STBls12381G2, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381G2 : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381G2 : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TBls12381G2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381G2 : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBls12381G2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381G2 : xs)))
-> SomeInstr ('TBls12381G2 : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBls12381G2 : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Neg (AnnVar
-> Instr ('TBls12381G2 : xs) (UnaryArithRes Neg 'TBls12381G2 : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neg n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neg n : s)
AnnNEG (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBls12381G2 : xs)
inp VarAnn
vn
(U.NEG VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"bls12_381_fr" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"bls12_381_g1" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"bls12_381_g2" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
]
(U.NEG VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LSL VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
(SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Lsl AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes Lsl 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Lsl n m =>
AnnVar -> Instr (n : m : s) (ArithRes Lsl n m : s)
AnnLSL HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.LSL VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.LSL VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LSR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
(SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Lsr AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes Lsr 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Lsr n m =>
AnnVar -> Instr (n : m : s) (ArithRes Lsr n m : s)
AnnLSR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.LSR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.LSR VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.OR VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
(SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Or AnnVar
-> Instr ('TBool : 'TBool : xs) (ArithRes Or 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Or n m =>
AnnVar -> Instr (n : m : s) (ArithRes Or n m : s)
AnnOR HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.OR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
(SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Or AnnVar -> Instr ('TNat : 'TNat : xs) (ArithRes Or 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Or n m =>
AnnVar -> Instr (n : m : s) (ArithRes Or n m : s)
AnnOR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.OR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])
]
(U.OR VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.AND VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::&
(SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And AnnVar
-> Instr ('TInt : 'TNat : xs) (ArithRes And 'TInt 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
AnnVar -> Instr (n : m : s) (ArithRes And n m : s)
AnnAND HST inp
HST ('TInt : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.AND VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
(SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes And 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
AnnVar -> Instr (n : m : s) (ArithRes And n m : s)
AnnAND HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.AND VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
(SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @And AnnVar
-> Instr ('TBool : 'TBool : xs) (ArithRes And 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp And n m =>
AnnVar -> Instr (n : m : s) (ArithRes And n m : s)
AnnAND HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.AND VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])
, (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool"])
]
(U.AND VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.XOR VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::&
(SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : 'TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : 'TBool : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Xor AnnVar
-> Instr ('TBool : 'TBool : xs) (ArithRes Xor 'TBool 'TBool : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Xor n m =>
AnnVar -> Instr (n : m : s) (ArithRes Xor n m : s)
AnnXOR HST inp
HST ('TBool : 'TBool : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.XOR VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::&
(SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall {k} (aop :: k) (inp :: [T]) (m :: T) (n :: T) (s :: [T])
(t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
forall aop (inp :: [T]) (m :: T) (n :: T) (s :: [T]) (t :: * -> *).
(WellTyped (ArithRes aop n m), inp ~ (n : m : s),
MonadReader TypeCheckInstrEnv t) =>
(AnnVar -> Instr inp (ArithRes aop n m : s))
-> HST inp -> VarAnn -> ExpandedInstr -> t (SomeInstr inp)
arithImpl @Xor AnnVar
-> Instr ('TNat : 'TNat : xs) (ArithRes Xor 'TNat 'TNat : xs)
forall (n :: T) (m :: T) (s :: [T]).
ArithOp Xor n m =>
AnnVar -> Instr (n : m : s) (ArithRes Xor n m : s)
AnnXOR HST inp
HST ('TNat : 'TNat : xs)
inp VarAnn
vn ExpandedInstr
uInstr
(U.XOR VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"bool"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"])
]
(U.XOR VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.NOT VarAnn
vn, (SingT x
STNat, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TNat : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TNat : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TNat : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TNat : xs)))
-> SomeInstr ('TNat : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TNat : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Not (AnnVar -> Instr ('TNat : xs) (UnaryArithRes Not 'TNat : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Not n =>
AnnVar -> Instr (n : s) (UnaryArithRes Not n : s)
AnnNOT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TNat : xs)
inp VarAnn
vn
(U.NOT VarAnn
vn, (SingT x
STBool, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs)))
-> TypeCheckInstr (SomeInstr ('TBool : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBool : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TBool : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBool : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TBool : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBool : xs)))
-> SomeInstr ('TBool : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TBool : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Not (AnnVar -> Instr ('TBool : xs) (UnaryArithRes Not 'TBool : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Not n =>
AnnVar -> Instr (n : s) (UnaryArithRes Not n : s)
AnnNOT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TBool : xs)
inp VarAnn
vn
(U.NOT VarAnn
vn, (SingT x
STInt, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t,
n ~ UnaryArithRes aop n) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImplAnnotated @Not (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Not 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Not n =>
AnnVar -> Instr (n : s) (UnaryArithRes Not n : s)
AnnNOT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.NOT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType
(NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:|
[ (Text
"bool" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
, (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [])
]
(U.NOT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.COMPARE VarAnn
vn,
(SingT x
_ :: SingT aT, Dict (WellTyped x)
_)
::& (SingT x
_ :: SingT bT, Dict (WellTyped x)
_)
::& HST xs
rs
)
-> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TypeCheckInstr (SomeInstr (x : x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ do
case forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @aT @bT of
Right x :~: x
Refl -> do
Dict (ComparabilityScope x)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @aT (VarAnn -> ExpandedInstr
forall op. VarAnn -> InstrAbstract op
U.COMPARE VarAnn
vn) (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ComparisonArguments)
(Either BadTypeForScope (Dict (ComparabilityScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ComparabilityScope x)))
-> Either BadTypeForScope (Dict (ComparabilityScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ComparabilityScope x))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ComparabilityScope aT)
case Dict (ComparabilityScope x)
proofScope of
Dict (ComparabilityScope x)
Dict ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : x : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
(Comparable n, SingI n) =>
AnnVar -> Instr (n : n : s) ('TInt : s)
AnnCOMPARE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : x : xs) ('TInt : xs)
-> HST ('TInt : xs) -> SomeInstrOut (x : x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TInt
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TInt, Dict (WellTyped 'TInt)) -> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
Left TCTypeError
err -> do
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : x : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ComparisonArguments) TCTypeError
err
(U.COMPARE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.EQ VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Eq' (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Eq' 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Eq' n =>
AnnVar -> Instr (n : s) (UnaryArithRes Eq' n : s)
AnnEQ (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.EQ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.EQ VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.NEQ VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Neq (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Neq 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Neq n =>
AnnVar -> Instr (n : s) (UnaryArithRes Neq n : s)
AnnNEQ (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.NEQ VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.NEQ VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LT VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Lt (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Lt 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Lt n =>
AnnVar -> Instr (n : s) (UnaryArithRes Lt n : s)
AnnLT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.LT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.LT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.GT VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Gt (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Gt 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Gt n =>
AnnVar -> Instr (n : s) (UnaryArithRes Gt n : s)
AnnGT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.GT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.GT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.LE VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Le (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Le 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Le n =>
AnnVar -> Instr (n : s) (UnaryArithRes Le n : s)
AnnLE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.LE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.LE VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.GE VarAnn
vn, (STInt{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs)))
-> TypeCheckInstr (SomeInstr ('TInt : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TInt : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs)))
-> SomeInstr ('TInt : xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TInt : xs))
forall a b. (a -> b) -> a -> b
$ forall {k} (aop :: k) (n :: T) (inp :: [T]) (s :: [T])
(t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
forall aop (n :: T) (inp :: [T]) (s :: [T]) (t :: * -> *).
(WellTyped (UnaryArithRes aop n), inp ~ (n : s), Monad t) =>
Instr inp (UnaryArithRes aop n : s) -> HST inp -> t (SomeInstr inp)
unaryArithImpl @Ge (AnnVar -> Instr ('TInt : xs) (UnaryArithRes Ge 'TInt : xs)
forall (n :: T) (s :: [T]).
UnaryArithOp Ge n =>
AnnVar -> Instr (n : s) (UnaryArithRes Ge n : s)
AnnGE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn)) HST inp
HST ('TInt : xs)
inp VarAnn
vn
(U.GE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"int" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.GE VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.INT VarAnn
vn, (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNat : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TNat : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
ToIntArithOp n =>
AnnVar -> Instr (n : s) ('TInt : s)
AnnINT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TNat : xs) ('TInt : xs)
-> HST ('TInt : xs) -> SomeInstrOut ('TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TInt
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TInt, Dict (WellTyped 'TInt)) -> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.INT VarAnn
vn, (STBls12381Fr{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs)))
-> TypeCheckInstr (SomeInstr ('TBls12381Fr : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBls12381Fr : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBls12381Fr : xs) ('TInt : xs)
forall (n :: T) (s :: [T]).
ToIntArithOp n =>
AnnVar -> Instr (n : s) ('TInt : s)
AnnINT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBls12381Fr : xs) ('TInt : xs)
-> HST ('TInt : xs) -> SomeInstrOut ('TBls12381Fr : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TInt
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TInt)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TInt, Dict (WellTyped 'TInt)) -> HST xs -> HST ('TInt : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.INT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| [Text
"bls12_381_fr" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []]
(U.INT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.VIEW VarAnn
vn ViewName
name (AsUType (Notes t
retNotes :: Notes ret)), (SingT x, Dict (WellTyped x))
_ ::& (STAddress{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TAddress : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TAddress : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TAddress : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @ret ((WellTyped t => TypeCheckInstr (SomeInstr (x : 'TAddress : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr (x : 'TAddress : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TAddress : xs))
forall a b. (a -> b) -> a -> b
$ do
Dict (ViewableScope t)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @ret ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
(Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ViewableScope t)))
-> Either BadTypeForScope (Dict (ViewableScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ViewableScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ViewableScope ret)
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t]
-> ViewName -> Instr (x : 'TAddress : xs) ('TOption t : xs)
forall (arg :: T) (ret :: T) (s :: [T]).
(SingI arg, ViewableScope ret) =>
Anns '[VarAnn, Notes ret]
-> ViewName -> Instr (arg : 'TAddress : s) ('TOption ret : s)
AnnVIEW (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
retNotes) ViewName
name Instr (x : 'TAddress : xs) ('TOption t : xs)
-> HST ('TOption t : xs) -> SomeInstrOut (x : 'TAddress : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing t -> SingT ('TOption t)
forall (n :: T). Sing n -> SingT ('TOption n)
STOption (Notes t -> Sing t
forall (t :: T). Notes t -> Sing t
notesSing Notes t
retNotes), Dict (WellTyped ('TOption t))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption t), Dict (WellTyped ('TOption t)))
-> HST xs -> HST ('TOption t : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.VIEW{}, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'arg" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"address"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.VIEW{}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SELF VarAnn
vn RootAnn
fn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> (IsNotInView => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
TypeCheckMode
mode <- (TypeCheckEnv -> TypeCheckMode)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
TypeCheckMode
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckEnv -> TypeCheckMode
tcMode
case TypeCheckMode
mode of
TypeCheckValue (Value
value, T
ty) Maybe BigMapFinder
_ ->
Value
-> T -> Text -> Maybe TCTypeError -> TypeCheckInstr (SomeInstr inp)
forall a.
Value -> T -> Text -> Maybe TCTypeError -> TypeCheckInstr a
tcFailedOnValue Value
value T
ty Text
"The SELF instruction cannot appear in a lambda" Maybe TCTypeError
forall a. Maybe a
Nothing
TypeCheckContract (SomeParamType ParamNotes t
notescp) -> do
let epName :: EpName
epName = RootAnn -> EpName
U.epNameFromSelfAnn RootAnn
fn
MkEntrypointCallRes (Notes arg
argNotes :: Notes arg) EntrypointCallT t arg
epc <-
EpName -> ParamNotes t -> Maybe (MkEntrypointCallRes t)
forall (param :: T).
ParameterScope param =>
EpName -> ParamNotes param -> Maybe (MkEntrypointCallRes param)
mkEntrypointCall EpName
epName ParamNotes t
notescp
Maybe (MkEntrypointCallRes t)
-> (Maybe (MkEntrypointCallRes t)
-> Either TCTypeError (MkEntrypointCallRes t))
-> Either TCTypeError (MkEntrypointCallRes t)
forall a b. a -> (a -> b) -> b
& TCTypeError
-> Maybe (MkEntrypointCallRes t)
-> Either TCTypeError (MkEntrypointCallRes t)
forall l r. l -> Maybe r -> Either l r
maybeToRight (EpName -> TCTypeError
EntrypointNotFound EpName
epName)
Either TCTypeError (MkEntrypointCallRes t)
-> (Either TCTypeError (MkEntrypointCallRes t)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(MkEntrypointCallRes t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(MkEntrypointCallRes t)
forall a b. a -> (a -> b) -> b
& ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (MkEntrypointCallRes t)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(MkEntrypointCallRes t)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
case TypeAnn -> Notes arg -> Notes ('TContract arg)
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TContract t1)
NTContract TypeAnn
forall {k} (a :: k). Annotation a
U.noAnn Notes arg
argNotes of
(Notes ('TContract arg)
ntRes :: Notes ('TContract t1)) ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @('TContract t1) ((WellTyped ('TContract arg) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp))
-> (WellTyped ('TContract arg) => TypeCheckInstr (SomeInstr inp))
-> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ forall (arg :: T) (inp :: [T]).
(ParameterScope arg, IsNotInView) =>
AnnVar
-> SomeEntrypointCallT arg -> Instr inp ('TContract arg : inp)
AnnSELF @arg (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) (EntrypointCallT t arg -> SomeEntrypointCallT arg
forall (arg :: T) (param :: T).
ParameterScope param =>
EntrypointCallT param arg -> SomeEntrypointCallT arg
SomeEpc EntrypointCallT t arg
epc) Instr inp ('TContract arg : inp)
-> HST ('TContract arg : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TContract arg) -> Sing ('TContract arg)
forall (t :: T). Notes t -> Sing t
notesSing Notes ('TContract arg)
ntRes, Dict (WellTyped ('TContract arg))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TContract arg), Dict (WellTyped ('TContract arg)))
-> HST inp -> HST ('TContract arg : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
TypeCheckMode
TypeCheckTest ->
TCTypeError -> TypeCheckInstr (SomeInstr inp)
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr (SomeInstr inp))
-> TCTypeError -> TypeCheckInstr (SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr Text
"'SELF' appears in test typechecking"
(U.CONTRACT VarAnn
vn RootAnn
fn Ty
mt, (STAddress{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TAddress : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TAddress : xs)))
-> TypeCheckInstr (SomeInstr ('TAddress : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$
Ty
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TAddress : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TAddress : xs))
forall r. Ty -> (forall (t :: T). SingI t => Notes t -> r) -> r
withUType Ty
mt ((forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TAddress : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TAddress : xs)))
-> (forall (t :: T).
SingI t =>
Notes t
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TAddress : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$ \(Notes t
tns :: Notes t) -> do
Dict (ParameterScope t)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractParameter)
(Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ParameterScope t)))
-> Either BadTypeForScope (Dict (ParameterScope t))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ParameterScope t))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope t)
let ns :: Notes ('TOption ('TContract t))
ns = TypeAnn -> Notes ('TContract t) -> Notes ('TOption ('TContract t))
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TOption t1)
NTOption TypeAnn
forall a. Default a => a
def (Notes ('TContract t) -> Notes ('TOption ('TContract t)))
-> Notes ('TContract t) -> Notes ('TOption ('TContract t))
forall a b. (a -> b) -> a -> b
$ TypeAnn -> Notes t -> Notes ('TContract t)
forall (t1 :: T). TypeAnn -> Notes t1 -> Notes ('TContract t1)
NTContract TypeAnn
forall a. Default a => a
def Notes t
tns
EpName
epName <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError EpName
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
EpName
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
(Either TCTypeError EpName
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
EpName)
-> Either TCTypeError EpName
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
EpName
forall a b. (a -> b) -> a -> b
$ RootAnn -> Either EpNameFromRefAnnError EpName
epNameFromRefAnn RootAnn
fn Either EpNameFromRefAnnError EpName
-> (EpNameFromRefAnnError -> TCTypeError)
-> Either TCTypeError EpName
forall (p :: * -> * -> *) a c b.
Bifunctor p =>
p a c -> (a -> b) -> p b c
`onFirst` EpNameFromRefAnnError -> TCTypeError
IllegalEntrypoint
case Dict (ParameterScope t)
proofScope of
Dict (ParameterScope t)
Dict ->
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @t ((WellTyped t => TypeCheckInstr (SomeInstr ('TAddress : xs)))
-> TypeCheckInstr (SomeInstr ('TAddress : xs)))
-> (WellTyped t => TypeCheckInstr (SomeInstr ('TAddress : xs)))
-> TypeCheckInstr (SomeInstr ('TAddress : xs))
forall a b. (a -> b) -> a -> b
$ SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, Notes t]
-> EpName -> Instr ('TAddress : xs) ('TOption ('TContract t) : xs)
forall (p :: T) (s :: [T]).
ParameterScope p =>
Anns '[VarAnn, Notes p]
-> EpName -> Instr ('TAddress : s) ('TOption ('TContract p) : s)
AnnCONTRACT (VarAnn -> Notes t -> Anns '[VarAnn, Notes t]
forall {k} (a :: k) (t :: T).
(Typeable a, SingI t) =>
Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
Anns2' VarAnn
vn Notes t
tns) EpName
epName Instr ('TAddress : xs) ('TOption ('TContract t) : xs)
-> HST ('TOption ('TContract t) : xs)
-> SomeInstrOut ('TAddress : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Notes ('TOption ('TContract t)) -> Sing ('TOption ('TContract t))
forall (t :: T). Notes t -> Sing t
notesSing Notes ('TOption ('TContract t))
ns, Dict (WellTyped ('TOption ('TContract t)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TContract t)),
Dict (WellTyped ('TOption ('TContract t))))
-> HST xs -> HST ('TOption ('TContract t) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.CONTRACT {}, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"address" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.CONTRACT {}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.TRANSFER_TOKENS VarAnn
vn, ((SingT x
_ :: SingT p'), Dict (WellTyped x)
_)
::& (STMutez{}, Dict (WellTyped x)
_)
::& (STContract (Sing n
s :: Sing p), Dict (WellTyped x)
_) ::& HST xs
rs) -> Sing n
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing n
s ((SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> (SingI n =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq (x : 'TMutez : 'TContract n : xs))
forall a b. (a -> b) -> a -> b
$
ExpandedInstr
-> (IsNotInView =>
TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TMutez : 'TContract n : xs))
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
Dict (ParameterScope n)
proofScope <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @p ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractParameter)
(Either BadTypeForScope (Dict (ParameterScope n))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ParameterScope n)))
-> Either BadTypeForScope (Dict (ParameterScope n))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (ParameterScope n))
forall a b. (a -> b) -> a -> b
$ forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(ParameterScope p)
case (forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @p @p', Dict (ParameterScope n)
proofScope) of
(Right n :~: x
Refl, Dict (ParameterScope x)
Dict (ParameterScope n)
Dict) ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr (x : 'TMutez : 'TContract x : xs) ('TOperation : xs)
forall (p :: T) (s :: [T]).
(ParameterScope p, IsNotInView) =>
AnnVar -> Instr (p : 'TMutez : 'TContract p : s) ('TOperation : s)
AnnTRANSFER_TOKENS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TMutez : 'TContract x : xs) ('TOperation : xs)
-> HST ('TOperation : xs)
-> SomeInstrOut (x : 'TMutez : 'TContract x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(Left TCTypeError
m, Dict (ParameterScope n)
_) ->
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : 'TMutez : 'TContract n : xs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractParameter) TCTypeError
m
(U.TRANSFER_TOKENS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"'p" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"mutez", Text
"contract 'p"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.TRANSFER_TOKENS VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SET_DELEGATE VarAnn
vn,
(STOption Sing n
SingT n
STKeyHash, Dict (WellTyped x)
_)
::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TOption 'TKeyHash : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TOption 'TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TOption 'TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> (IsNotInView =>
TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : xs))
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TOption 'TKeyHash : xs) ('TOperation : xs)
forall (s :: [T]).
IsNotInView =>
AnnVar -> Instr ('TOption 'TKeyHash : s) ('TOperation : s)
AnnSET_DELEGATE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TOption 'TKeyHash : xs) ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeInstrOut ('TOption 'TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.SET_DELEGATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"option key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SET_DELEGATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.CREATE_CONTRACT VarAnn
ovn VarAnn
avn Contract
contract,
(STOption Sing n
SingT n
STKeyHash, Dict (WellTyped x)
_)
::& (STMutez{}, Dict (WellTyped x)
_)
::& (SingT x
_ :: SingT g, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr
(SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TOption 'TKeyHash : 'TMutez : x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> TypeCheckInstr
(SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TOption 'TKeyHash : 'TMutez : x : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr
-> (IsNotInView =>
TypeCheckInstr (SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs)))
-> TypeCheckInstr
(SomeInstr ('TOption 'TKeyHash : 'TMutez : x : xs))
forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
uInstr do
(SomeContract contr :: Contract cp st
contr@(Contract ContractCode' Instr cp st
_ ParamNotes cp
_ (Notes st
_ :: Notes st) ViewsSet' Instr st
_ EntriesOrder
_))
<- ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
SomeContract
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
SomeContract)
-> ReaderT
TypeCheckEnv
(ReaderT TypeCheckOptions (ExceptT TCError Identity))
SomeContract
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
SomeContract
forall a b. (a -> b) -> a -> b
$ Contract -> TypeCheck SomeContract
typeCheckContractImpl Contract
contract
x :~: st
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (x :~: st)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: st)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
ContractStorage) (Either TCTypeError (x :~: st)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: st))
-> Either TCTypeError (x :~: st)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(x :~: st)
forall a b. (a -> b) -> a -> b
$
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @g @st
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Anns '[VarAnn, VarAnn]
-> Contract cp st
-> Instr
('TOption 'TKeyHash : 'TMutez : st : xs)
('TOperation : 'TAddress : xs)
forall (p :: T) (g :: T) (s :: [T]).
(ParameterScope p, StorageScope g, IsNotInView) =>
Anns '[VarAnn, VarAnn]
-> Contract' Instr p g
-> Instr
('TOption 'TKeyHash : 'TMutez : g : s)
('TOperation : 'TAddress : s)
AnnCREATE_CONTRACT (VarAnn -> VarAnn -> Anns '[VarAnn, VarAnn]
forall {k} (a :: k) (b :: k).
Each '[Typeable] '[a, b] =>
Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
Anns2 VarAnn
ovn VarAnn
avn) Contract cp st
contr
Instr
('TOption 'TKeyHash : 'TMutez : st : xs)
('TOperation : 'TAddress : xs)
-> HST ('TOperation : 'TAddress : xs)
-> SomeInstrOut ('TOption 'TKeyHash : 'TMutez : st : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST ('TAddress : xs) -> HST ('TOperation : 'TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST xs -> HST ('TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.CREATE_CONTRACT {}, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"option key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"mutez", Text
"'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.CREATE_CONTRACT {}, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.IMPLICIT_ACCOUNT VarAnn
vn, (STKeyHash{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKeyHash : xs) ('TContract 'TUnit : xs)
forall (s :: [T]).
AnnVar -> Instr ('TKeyHash : s) ('TContract 'TUnit : s)
AnnIMPLICIT_ACCOUNT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKeyHash : xs) ('TContract 'TUnit : xs)
-> HST ('TContract 'TUnit : xs) -> SomeInstrOut ('TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TContract 'TUnit)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TContract 'TUnit))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TContract 'TUnit), Dict (WellTyped ('TContract 'TUnit)))
-> HST xs -> HST ('TContract 'TUnit : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.IMPLICIT_ACCOUNT VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.IMPLICIT_ACCOUNT VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.NOW VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TTimestamp : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TTimestamp : inp)
AnnNOW (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TTimestamp : inp)
-> HST ('TTimestamp : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TTimestamp
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TTimestamp)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TTimestamp, Dict (WellTyped 'TTimestamp))
-> HST inp -> HST ('TTimestamp : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.AMOUNT VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TMutez : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TMutez : inp)
AnnAMOUNT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TMutez : inp)
-> HST ('TMutez : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TMutez
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TMutez)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TMutez, Dict (WellTyped 'TMutez))
-> HST inp -> HST ('TMutez : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.BALANCE VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TMutez : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TMutez : inp)
AnnBALANCE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TMutez : inp)
-> HST ('TMutez : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TMutez
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TMutez)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TMutez, Dict (WellTyped 'TMutez))
-> HST inp -> HST ('TMutez : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.VOTING_POWER VarAnn
vn, (STKeyHash{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs)))
-> TypeCheckInstr (SomeInstr ('TKeyHash : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKeyHash : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKeyHash : xs) ('TNat : xs)
forall (s :: [T]). AnnVar -> Instr ('TKeyHash : s) ('TNat : s)
AnnVOTING_POWER (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKeyHash : xs) ('TNat : xs)
-> HST ('TNat : xs) -> SomeInstrOut ('TKeyHash : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat)) -> HST xs -> HST ('TNat : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.VOTING_POWER VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key_hash" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.VOTING_POWER VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.TOTAL_VOTING_POWER VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TNat : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TNat : inp)
AnnTOTAL_VOTING_POWER (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat))
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.CHECK_SIGNATURE VarAnn
vn,
(STKey{}, Dict (WellTyped x)
_)
::& (STSignature{}, Dict (WellTyped x)
_) ::& (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TKey : 'TSignature : 'TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TKey : 'TSignature : 'TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TKey : 'TSignature : 'TBytes : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TKey : 'TSignature : 'TBytes : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKey : 'TSignature : 'TBytes : xs) ('TBool : xs)
forall (s :: [T]).
AnnVar -> Instr ('TKey : 'TSignature : 'TBytes : s) ('TBool : s)
AnnCHECK_SIGNATURE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKey : 'TSignature : 'TBytes : xs) ('TBool : xs)
-> HST ('TBool : xs)
-> SomeInstrOut ('TKey : 'TSignature : 'TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBool
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBool)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBool, Dict (WellTyped 'TBool))
-> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.CHECK_SIGNATURE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"signature", Text
"bytes"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.CHECK_SIGNATURE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SHA256 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnSHA256 (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.SHA256 VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SHA256 VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SHA512 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnSHA512 (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.SHA512 VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SHA512 VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.BLAKE2B VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnBLAKE2B (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.BLAKE2B VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.BLAKE2B VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SHA3 VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnSHA3 (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.SHA3 VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SHA3 VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.KECCAK VarAnn
vn, (STBytes{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs)))
-> TypeCheckInstr (SomeInstr ('TBytes : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TBytes : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TBytes : xs) ('TBytes : xs)
forall (s :: [T]). AnnVar -> Instr ('TBytes : s) ('TBytes : s)
AnnKECCAK (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TBytes : xs) ('TBytes : xs)
-> HST ('TBytes : xs) -> SomeInstrOut ('TBytes : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBytes
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBytes)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBytes, Dict (WellTyped 'TBytes))
-> HST xs -> HST ('TBytes : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.KECCAK VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"bytes" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.KECCAK VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.HASH_KEY VarAnn
vn, (STKey{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TKey : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKey : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TKey : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKey : xs)))
-> TypeCheckInstr (SomeInstr ('TKey : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TKey : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TKey : xs) ('TKeyHash : xs)
forall (s :: [T]). AnnVar -> Instr ('TKey : s) ('TKeyHash : s)
AnnHASH_KEY (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TKey : xs) ('TKeyHash : xs)
-> HST ('TKeyHash : xs) -> SomeInstrOut ('TKey : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TKeyHash
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TKeyHash)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TKeyHash, Dict (WellTyped 'TKeyHash))
-> HST xs -> HST ('TKeyHash : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.HASH_KEY VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"key" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.HASH_KEY VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.PAIRING_CHECK VarAnn
vn, (STList (STPair Sing n1
SingT n1
STBls12381G1 Sing n2
SingT n2
STBls12381G2), Dict (WellTyped x)
_) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr
(SomeInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr
(SomeInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs)))
-> TypeCheckInstr
(SomeInstr ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs) ('TBool : xs)
forall (s :: [T]).
AnnVar
-> Instr
('TList ('TPair 'TBls12381G1 'TBls12381G2) : s) ('TBool : s)
AnnPAIRING_CHECK (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs) ('TBool : xs)
-> HST ('TBool : xs)
-> SomeInstrOut ('TList ('TPair 'TBls12381G1 'TBls12381G2) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TBool
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TBool)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TBool, Dict (WellTyped 'TBool))
-> HST xs -> HST ('TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.PAIRING_CHECK VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"list (pair bls12_381_g1 bls12_381_g2)" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.PAIRING_CHECK VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SOURCE VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TAddress : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TAddress : inp)
AnnSOURCE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.SENDER VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TAddress : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TAddress : inp)
AnnSENDER (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.ADDRESS VarAnn
vn, (STContract{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TContract n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TContract n : xs)))
-> TypeCheckInstr (SomeInstr ('TContract n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TContract n : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr ('TContract n : xs) ('TAddress : xs)
forall (a :: T) (s :: [T]).
AnnVar -> Instr ('TContract a : s) ('TAddress : s)
AnnADDRESS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr ('TContract n : xs) ('TAddress : xs)
-> HST ('TAddress : xs) -> SomeInstrOut ('TContract n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST xs -> HST ('TAddress : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.ADDRESS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"contract 'p" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.ADDRESS VarAnn
_, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.CHAIN_ID VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TChainId : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TChainId : inp)
AnnCHAIN_ID (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TChainId : inp)
-> HST ('TChainId : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TChainId
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TChainId)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TChainId, Dict (WellTyped 'TChainId))
-> HST inp -> HST ('TChainId : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.LEVEL VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TNat : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TNat : inp)
AnnLEVEL (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TNat : inp) -> HST ('TNat : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TNat
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TNat)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TNat, Dict (WellTyped 'TNat))
-> HST inp -> HST ('TNat : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(U.SELF_ADDRESS VarAnn
vn, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr inp ('TAddress : inp)
forall (inp :: [T]). AnnVar -> Instr inp ('TAddress : inp)
AnnSELF_ADDRESS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr inp ('TAddress : inp)
-> HST ('TAddress : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TAddress
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TAddress)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TAddress, Dict (WellTyped 'TAddress))
-> HST inp -> HST ('TAddress : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
(ExpandedInstr
U.NEVER, (STNever{}, Dict (WellTyped x)
_) ::& HST xs
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TNever : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNever : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TNever : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNever : xs)))
-> TypeCheckInstr (SomeInstr ('TNever : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TNever : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ (forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
AnyOutInstr forall (out :: [T]). Instr inp out
forall (s :: [T]) (out :: [T]). Instr ('TNever : s) out
NEVER
(ExpandedInstr
U.NEVER, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"never" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(ExpandedInstr
U.NEVER, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.TICKET VarAnn
vn, (Sing x
stVal :: Sing v, Dict (WellTyped x)
_) ::& (STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr @v ((WellTyped x => TypeCheckInstr (SomeInstr (x : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs)))
-> (WellTyped x => TypeCheckInstr (SomeInstr (x : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
Sing x
-> ExpandedInstr
-> HST inp
-> (Comparable x => SomeInstr (x : 'TNat : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : 'TNat : xs))
forall (a :: T) (m :: * -> *) v (ts :: [T]).
(SingI ts, MonadReader TypeCheckInstrEnv m,
MonadError TCError m) =>
Sing a -> ExpandedInstr -> HST ts -> (Comparable a => v) -> m v
withCompareableCheck Sing x
stVal ExpandedInstr
uInstr HST inp
inp ((Comparable x => SomeInstr (x : 'TNat : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : 'TNat : xs)))
-> (Comparable x => SomeInstr (x : 'TNat : xs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (x : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Instr (x : 'TNat : xs) ('TTicket x : xs)
forall (a :: T) (s :: [T]).
Comparable a =>
AnnVar -> Instr (a : 'TNat : s) ('TTicket a : s)
AnnTICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr (x : 'TNat : xs) ('TTicket x : xs)
-> HST ('TTicket x : xs) -> SomeInstrOut (x : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TTicket x)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TTicket x))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TTicket x), Dict (WellTyped ('TTicket x)))
-> HST xs -> HST ('TTicket x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.TICKET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"a'" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.TICKET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.READ_TICKET VarAnn
vn, ticket :: (SingT x, Dict (WellTyped x))
ticket@(STTicket{}, Dict (WellTyped x)
Dict) ::& HST xs
rs) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TTicket n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TTicket n : xs)))
-> TypeCheckInstr (SomeInstr ('TTicket n : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ('TTicket n : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
('TTicket n : xs)
(RightComb '[ 'TAddress, n, 'TNat] : 'TTicket n : xs)
forall (a :: T) (s :: [T]).
AnnVar
-> Instr
('TTicket a : s)
(RightComb '[ 'TAddress, a, 'TNat] : 'TTicket a : s)
AnnREAD_TICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
('TTicket n : xs) ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
-> HST ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
-> SomeInstrOut ('TTicket n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TPair 'TAddress ('TPair n 'TNat))
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TPair 'TAddress ('TPair n 'TNat)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TPair 'TAddress ('TPair n 'TNat)),
Dict (WellTyped ('TPair 'TAddress ('TPair n 'TNat))))
-> HST (x : xs) -> HST ('TPair 'TAddress ('TPair n 'TNat) : x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& (SingT x, Dict (WellTyped x))
ticket (SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.READ_TICKET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"ticket 'a" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.READ_TICKET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SPLIT_TICKET VarAnn
vn, (STTicket{}, Dict (WellTyped x)
Dict) ::& (STPair STNat{} STNat{}, Dict (WellTyped x)
_) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr
(SomeInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TTicket n : 'TPair 'TNat 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TTicket n : 'TPair 'TNat 'TNat : xs)))
-> TypeCheckInstr
(SomeInstr ('TTicket n : 'TPair 'TNat 'TNat : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TTicket n : 'TPair 'TNat 'TNat : xs))
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
('TTicket n : 'TPair 'TNat 'TNat : xs)
('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
forall (a :: T) (s :: [T]).
AnnVar
-> Instr
('TTicket a : 'TPair 'TNat 'TNat : s)
('TOption ('TPair ('TTicket a) ('TTicket a)) : s)
AnnSPLIT_TICKET (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
('TTicket n : 'TPair 'TNat 'TNat : xs)
('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
-> HST ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
-> SomeInstrOut ('TTicket n : 'TPair 'TNat 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TOption ('TPair ('TTicket n) ('TTicket n)))
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TOption ('TPair ('TTicket n) ('TTicket n))))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TPair ('TTicket n) ('TTicket n))),
Dict (WellTyped ('TOption ('TPair ('TTicket n) ('TTicket n)))))
-> HST xs -> HST ('TOption ('TPair ('TTicket n) ('TTicket n)) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.SPLIT_TICKET VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair nat nat" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"ticket 'a"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SPLIT_TICKET VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.JOIN_TICKETS VarAnn
vn,
(STPair (nt1 :: SingT n1
nt1@STTicket{} :: SingT t1) (STTicket{} :: SingT t2), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr
(SomeInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TPair ('TTicket n) ('TTicket n) : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TPair ('TTicket n) ('TTicket n) : xs)))
-> TypeCheckInstr
(SomeInstr ('TPair ('TTicket n) ('TTicket n) : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TPair ('TTicket n) ('TTicket n) : xs))
forall a b. (a -> b) -> a -> b
$ do
n1 :~: n2
Refl <-
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (n1 :~: n2)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(n1 :~: n2)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
TicketsJoin) (Either TCTypeError (n1 :~: n2)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(n1 :~: n2))
-> Either TCTypeError (n1 :~: n2)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(n1 :~: n2)
forall a b. (a -> b) -> a -> b
$
forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t2
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
('TPair ('TTicket n) ('TTicket n) : xs)
('TOption ('TTicket n) : xs)
forall (a :: T) (s :: [T]).
AnnVar
-> Instr
('TPair ('TTicket a) ('TTicket a) : s) ('TOption ('TTicket a) : s)
AnnJOIN_TICKETS (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
('TPair ('TTicket n) ('TTicket n) : xs)
('TOption ('TTicket n) : xs)
-> HST ('TOption ('TTicket n) : xs)
-> SomeInstrOut ('TPair ('TTicket n) ('TTicket n) : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((Sing ('TTicket n) -> SingT ('TOption ('TTicket n))
forall (n :: T). Sing n -> SingT ('TOption n)
STOption Sing ('TTicket n)
SingT n1
nt1, Dict (WellTyped ('TOption ('TTicket n)))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TOption ('TTicket n)),
Dict (WellTyped ('TOption ('TTicket n))))
-> HST xs -> HST ('TOption ('TTicket n) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.JOIN_TICKETS VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs)))
-> TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"pair (ticket 'a) (ticket 'a)" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| []) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.JOIN_TICKETS VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.OPEN_CHEST VarAnn
vn,
(SingT x
STChestKey, Dict (WellTyped x)
Dict)
::& (SingT x
STChest, Dict (WellTyped x)
Dict)
::& (SingT x
STNat, Dict (WellTyped x)
Dict)
::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TChestKey : 'TChest : 'TNat : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TChestKey : 'TChest : 'TNat : xs)))
-> TypeCheckInstr (SomeInstr ('TChestKey : 'TChest : 'TNat : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TChestKey : 'TChest : 'TNat : xs))
forall a b. (a -> b) -> a -> b
$ do
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
('TChestKey : 'TChest : 'TNat : xs) ('TOr 'TBytes 'TBool : xs)
forall (s :: [T]).
AnnVar
-> Instr
('TChestKey : 'TChest : 'TNat : s) ('TOr 'TBytes 'TBool : s)
AnnOPEN_CHEST (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
('TChestKey : 'TChest : 'TNat : xs) ('TOr 'TBytes 'TBool : xs)
-> HST ('TOr 'TBytes 'TBool : xs)
-> SomeInstrOut ('TChestKey : 'TChest : 'TNat : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: (
(Sing 'TBytes -> Sing 'TBool -> SingT ('TOr 'TBytes 'TBool)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TOr n1 n2)
STOr Sing 'TBytes
SingT 'TBytes
STBytes Sing 'TBool
SingT 'TBool
STBool, Dict (WellTyped ('TOr 'TBytes 'TBool))
forall (a :: Constraint). a => Dict a
Dict)
(SingT ('TOr 'TBytes 'TBool),
Dict (WellTyped ('TOr 'TBytes 'TBool)))
-> HST xs -> HST ('TOr 'TBytes 'TBool : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
(U.OPEN_CHEST VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"chest_key" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"chest", Text
"nat"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.OPEN_CHEST VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.SAPLING_EMPTY_STATE VarAnn
vn Natural
n, HST inp
_) -> ExpandedInstr
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstr (SomeInstr inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall a b. (a -> b) -> a -> b
$
(\(SomeSing (Sing a
s :: Sing a)) -> Sing a
-> (SingI a =>
ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall {k} (n :: k) r. Sing n -> (SingI n => r) -> r
withSingI Sing a
s ((SingI a =>
ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> (SingI a =>
ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar -> Sing a -> Instr inp ('TSaplingState a : inp)
forall (n :: Nat) (inp :: [T]).
AnnVar -> Sing n -> Instr inp ('TSaplingState n : inp)
AnnSAPLING_EMPTY_STATE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Sing a
s Instr inp ('TSaplingState a : inp)
-> HST ('TSaplingState a : inp) -> SomeInstrOut inp
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT ('TSaplingState a)
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped ('TSaplingState a))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TSaplingState a), Dict (WellTyped ('TSaplingState a)))
-> HST inp -> HST ('TSaplingState a : inp)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST inp
inp)
) (SomeSing Nat
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeSing Nat
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ Natural -> SomeSing Nat
Peano.someSingNat Natural
n
(U.SAPLING_VERIFY_UPDATE VarAnn
vn,
(STSaplingTransaction Sing n
s1, Dict (WellTyped x)
Dict)
::& (STSaplingState Sing n
s2, Dict (WellTyped x)
Dict)
::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr
(SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TSaplingTransaction n : 'TSaplingState n : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (TypeCheckInstr
(SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> TypeCheckInstr
(SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
-> TypeCheckInstrNoExcept
(TypeCheckedSeq ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a b. (a -> b) -> a -> b
$
case SingNat n -> SingNat n -> Maybe (n :~: n)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality Sing n
SingNat n
s1 Sing n
SingNat n
s2 of
Just n :~: n
Refl ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> Instr
('TSaplingTransaction n : 'TSaplingState n : xs)
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
forall (n :: Nat) (s :: [T]).
AnnVar
-> Instr
('TSaplingTransaction n : 'TSaplingState n : s)
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : s)
AnnSAPLING_VERIFY_UPDATE (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
vn) Instr
('TSaplingTransaction n : 'TSaplingState n : xs)
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
-> HST
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
-> SomeInstrOut ('TSaplingTransaction n : 'TSaplingState n : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: (
(Sing ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))
-> SingT
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))))
forall (n :: T). Sing n -> SingT ('TOption n)
STOption (Sing 'TBytes
-> Sing ('TPair 'TInt ('TSaplingState n))
-> SingT ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing 'TBytes
SingT 'TBytes
STBytes (Sing 'TInt
-> Sing ('TSaplingState n)
-> SingT ('TPair 'TInt ('TSaplingState n))
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TPair n1 n2)
STPair Sing 'TInt
SingT 'TInt
STInt (Sing n -> SingT ('TSaplingState n)
forall (n :: Nat). Sing n -> SingT ('TSaplingState n)
STSaplingState Sing n
s1))), Dict
(WellTyped
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))))
forall (a :: Constraint). a => Dict a
Dict)
(SingT
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))),
Dict
(WellTyped
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))))))
-> HST xs
-> HST
('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
Maybe (n :~: n)
Nothing -> TCTypeError
-> TypeCheckInstr
(SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError
-> TypeCheckInstr
(SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs)))
-> TCTypeError
-> TypeCheckInstr
(SomeInstr ('TSaplingTransaction n : 'TSaplingState n : xs))
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
uInstr
Text
"Memo sizes of two sapling states or transactions do not match."
(U.SAPLING_VERIFY_UPDATE VarAnn
_, (SingT x, Dict (WellTyped x))
_ ::& (SingT x, Dict (WellTyped x))
_ ::& HST xs
_) ->
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr (TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs)))
-> TCTypeError
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : x : xs))
forall a b. (a -> b) -> a -> b
$ NonEmpty (NonEmpty Text) -> TCTypeError
UnexpectedType (NonEmpty (NonEmpty Text) -> TCTypeError)
-> NonEmpty (NonEmpty Text) -> TCTypeError
forall a b. (a -> b) -> a -> b
$ (Text
"sapling_transaction" Text -> [Text] -> NonEmpty Text
forall a. a -> [a] -> NonEmpty a
:| [Text
"sapling_state"]) NonEmpty Text -> [NonEmpty Text] -> NonEmpty (NonEmpty Text)
forall a. a -> [a] -> NonEmpty a
:| []
(U.SAPLING_VERIFY_UPDATE VarAnn
_, HST inp
_) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.EMIT{}, HST inp
SNil) -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack
(U.EMIT VarAnn
va RootAnn
tag Maybe Ty
mty, ((SingT x
_ :: SingT t2), Dict (WellTyped x)
Dict) ::& HST xs
rs) ->
ExpandedInstr
-> TypeCheckInstr (SomeInstr (x : xs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (x : xs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr do
Dict (PackedValScope x)
Dict <- forall (t :: T) (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m, SingI t) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either BadTypeForScope a -> m a
onScopeCheckInstrErr @t2 ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing (Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (PackedValScope x)))
-> Either BadTypeForScope (Dict (PackedValScope x))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Dict (PackedValScope x))
forall a b. (a -> b) -> a -> b
$
forall (c :: Constraint).
CheckScope c =>
Either BadTypeForScope (Dict c)
checkScope @(PackedValScope t2)
case Maybe Ty
mty of
Just (AsUType (Notes t
ty :: Notes t1)) -> do
t :~: x
Refl <- Either TCTypeError (t :~: x)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(t :~: x)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM (Either TCTypeError (t :~: x)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(t :~: x))
-> Either TCTypeError (t :~: x)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(t :~: x)
forall a b. (a -> b) -> a -> b
$ forall (a :: T) (b :: T).
Each '[SingI] '[a, b] =>
Either TCTypeError (a :~: b)
eqType @t1 @t2
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> RootAnn -> Maybe (Notes t) -> Instr (t : xs) ('TOperation : xs)
forall (t :: T) (s :: [T]).
PackedValScope t =>
AnnVar
-> RootAnn -> Maybe (Notes t) -> Instr (t : s) ('TOperation : s)
AnnEMIT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
va) RootAnn
tag (Notes t -> Maybe (Notes t)
forall a. a -> Maybe a
Just Notes t
ty) Instr (t : xs) ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeInstrOut (t : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
Maybe Ty
Nothing ->
SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp))
-> SomeInstr inp
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr inp)
forall a b. (a -> b) -> a -> b
$ HST inp
inp HST inp -> SomeInstrOut inp -> SomeInstr inp
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ AnnVar
-> RootAnn -> Maybe (Notes x) -> Instr (x : xs) ('TOperation : xs)
forall (t :: T) (s :: [T]).
PackedValScope t =>
AnnVar
-> RootAnn -> Maybe (Notes t) -> Instr (t : s) ('TOperation : s)
AnnEMIT (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
va) RootAnn
tag Maybe (Notes x)
forall a. Maybe a
Nothing Instr (x : xs) ('TOperation : xs)
-> HST ('TOperation : xs) -> SomeInstrOut (x : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: ((SingT 'TOperation
forall {k} (a :: k). SingI a => Sing a
sing, Dict (WellTyped 'TOperation)
forall (a :: Constraint). a => Dict a
Dict) (SingT 'TOperation, Dict (WellTyped 'TOperation))
-> HST xs -> HST ('TOperation : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
where
errM :: (MonadReader TypeCheckInstrEnv m, MonadError TCError m) => Either TCTypeError a -> m a
errM :: forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
Either TCTypeError a -> m a
errM = ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
EmitArgument)
where
withWTPInstr'
:: forall t inp. SingI t
=> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' :: forall (t :: T) (inp :: [T]).
SingI t =>
(WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr' = forall (t :: T) (inp :: [T]).
SingI t =>
ExpandedInstr
-> SomeHST
-> (WellTyped t => TypeCheckInstrNoExcept (TypeCheckedSeq inp))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
withWTPInstr'_ @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp)
withWTPInstr
:: forall t a. SingI t => (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr :: forall (t :: T) a.
SingI t =>
(WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr = forall (t :: T) a.
SingI t =>
ExpandedInstr
-> SomeHST -> (WellTyped t => TypeCheckInstr a) -> TypeCheckInstr a
withWTPInstr_ @t ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp)
failWithErr :: TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr :: forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr = ExpandedInstr
-> TypeCheckInstr (SomeInstr a)
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
Identity
(TypeCheckedSeq a)
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
uInstr (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr a)
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq a))
-> (TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr a))
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr a)
forall a. TCTypeError -> TypeCheckInstr a
failWithErr'
failWithErr' :: TCTypeError -> TypeCheckInstr a
failWithErr' :: forall a. TCTypeError -> TypeCheckInstr a
failWithErr' = ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
a
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
uInstr (HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inp) Maybe TypeContext
forall a. Maybe a
Nothing
notEnoughItemsOnStack :: TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack :: forall (a :: [T]). TypeCheckInstrNoExcept (TypeCheckedSeq a)
notEnoughItemsOnStack = TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
Identity
(TypeCheckedSeq a)
forall (a :: [T]).
TCTypeError -> TypeCheckInstrNoExcept (TypeCheckedSeq a)
failWithErr TCTypeError
NotEnoughItemsOnStack
notEnoughItemsOnStack' :: TypeCheckInstr a
notEnoughItemsOnStack' :: forall a. TypeCheckInstr a
notEnoughItemsOnStack' = TCTypeError
-> MultiReaderT
'[TypeCheckInstrEnv, TypeCheckEnv, TypeCheckOptions]
(ExceptT TCError Identity)
a
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' TCTypeError
NotEnoughItemsOnStack
withNotInView :: U.ExpandedInstr -> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView :: forall r.
ExpandedInstr
-> (IsNotInView => TypeCheckInstr r) -> TypeCheckInstr r
withNotInView ExpandedInstr
instr IsNotInView => TypeCheckInstr r
act = (TypeCheckEnv -> TypeCheckMode)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
TypeCheckMode
forall (m :: * -> *) r a (n :: Nat).
MultiReader n r m =>
(r -> a) -> m a
asks' TypeCheckEnv -> TypeCheckMode
tcMode ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
TypeCheckMode
-> (TypeCheckMode
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
TypeCheckMode
TypeCheckTest -> (IsNotInView =>
ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r
forall r. (IsNotInView => r) -> r
giveNotInView IsNotInView =>
ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r
IsNotInView => TypeCheckInstr r
act
TypeCheckMode
_ -> Getting
(Maybe (Dict IsNotInView))
TypeCheckInstrEnv
(Maybe (Dict IsNotInView))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Maybe (Dict IsNotInView))
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
(Maybe (Dict IsNotInView))
TypeCheckInstrEnv
(Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(Maybe (Dict IsNotInView))
-> (Maybe (Dict IsNotInView)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Just Dict IsNotInView
Dict -> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
r
IsNotInView => TypeCheckInstr r
act
Maybe (Dict IsNotInView)
Nothing -> TCTypeError -> TypeCheckInstr r
forall a. TCTypeError -> TypeCheckInstr a
failWithErr' (TCTypeError -> TypeCheckInstr r)
-> TCTypeError -> TypeCheckInstr r
forall a b. (a -> b) -> a -> b
$
ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
instr Text
"This instruction cannot be used on the top level of a view"
genericIf
:: forall bti bfi cond rs .
(SingI bti, SingI bfi)
=> (forall s'.
Instr bti s' ->
Instr bfi s' ->
Instr (cond ': rs) s'
)
-> (forall op. [op] -> [op] -> U.InstrAbstract op)
-> [U.ExpandedOp]
-> [U.ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond ': rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond ': rs))
genericIf :: forall (bti :: [T]) (bfi :: [T]) (cond :: T) (rs :: [T]).
(SingI bti, SingI bfi) =>
(forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s')
-> (forall op. [op] -> [op] -> InstrAbstract op)
-> [ExpandedOp]
-> [ExpandedOp]
-> HST bti
-> HST bfi
-> HST (cond : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
genericIf forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons forall op. [op] -> [op] -> InstrAbstract op
mCons [ExpandedOp]
mbt [ExpandedOp]
mbf HST bti
bti HST bfi
bfi i :: HST (cond : rs)
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
_) = do
let cons1 :: [TypeCheckedOp] -> TypeCheckedInstr
cons1 [TypeCheckedOp]
opsT = [TypeCheckedOp] -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> [op] -> InstrAbstract op
mCons [TypeCheckedOp]
opsT ((ExpandedOp -> TypeCheckedOp) -> [ExpandedOp] -> [TypeCheckedOp]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (IllTypedInstr -> TypeCheckedOp
IllTypedOp (IllTypedInstr -> TypeCheckedOp)
-> (ExpandedOp -> IllTypedInstr) -> ExpandedOp -> TypeCheckedOp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExpandedOp -> IllTypedInstr
NonTypedInstr) [ExpandedOp]
mbf)
TypeCheckInstrNoExcept (TypeCheckedSeq bti)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr bti
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving' ([ExpandedOp]
-> HST bti -> TypeCheckInstrNoExcept (TypeCheckedSeq bti)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
mbt HST bti
bti) [TypeCheckedOp] -> TypeCheckedInstr
cons1 ((SomeInstr bti
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> (SomeInstr bti
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall a b. (a -> b) -> a -> b
$ \tInstr :: SomeInstr bti
tInstr@(HST bti
_ :/ SomeInstrOut bti
pinstr) -> do
let cons2 :: [TypeCheckedOp] -> TypeCheckedInstr
cons2 [TypeCheckedOp]
opsF = [TypeCheckedOp] -> [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> [op] -> InstrAbstract op
mCons [SomeInstr bti -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr bti
tInstr] [TypeCheckedOp]
opsF
TypeCheckInstrNoExcept (TypeCheckedSeq bfi)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr bfi -> TypeCheckInstr (SomeInstr (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST bfi -> TypeCheckInstrNoExcept (TypeCheckedSeq bfi)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
mbf HST bfi
bfi) [TypeCheckedOp] -> TypeCheckedInstr
cons2 ((SomeInstr bfi -> TypeCheckInstr (SomeInstr (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs)))
-> (SomeInstr bfi -> TypeCheckInstr (SomeInstr (cond : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (cond : rs))
forall a b. (a -> b) -> a -> b
$ \(HST bfi
_ :/ SomeInstrOut bfi
qinstr) -> do
(SomeInstrOut (cond : rs) -> SomeInstr (cond : rs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (cond : rs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HST (cond : rs)
i HST (cond : rs)
-> SomeInstrOut (cond : rs) -> SomeInstr (cond : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/) (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (cond : rs)))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (cond : rs))
forall a b. (a -> b) -> a -> b
$ case (SomeInstrOut bti
pinstr, SomeInstrOut bfi
qinstr) of
(Instr bti out
p ::: HST out
po, Instr bfi out
q ::: HST out
qo) -> do
let instr :: ExpandedInstr
instr = [ExpandedOp] -> [ExpandedOp] -> ExpandedInstr
forall op. [op] -> [op] -> InstrAbstract op
mCons [ExpandedOp]
mbt [ExpandedOp]
mbf
out :~: out
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (out :~: out)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(out :~: out)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
instr (HST (cond : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (cond : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
If)
(Either TCTypeError (out :~: out)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(out :~: out))
-> Either TCTypeError (out :~: out)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(out :~: out)
forall a b. (a -> b) -> a -> b
$ HST out -> HST out -> Either TCTypeError (out :~: out)
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
po HST out
qo
SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
p Instr bfi out
Instr bfi out
q Instr (cond : rs) out -> HST out -> SomeInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
HST out
qo
(AnyOutInstr forall (out :: [T]). Instr bti out
p, Instr bfi out
q ::: HST out
qo) -> do
SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
forall (out :: [T]). Instr bti out
p Instr bfi out
q Instr (cond : rs) out -> HST out -> SomeInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
qo
(Instr bti out
p ::: HST out
po, AnyOutInstr forall (out :: [T]). Instr bfi out
q) -> do
SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
p Instr bfi out
forall (out :: [T]). Instr bfi out
q Instr (cond : rs) out -> HST out -> SomeInstrOut (cond : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
po
(AnyOutInstr forall (out :: [T]). Instr bti out
p, AnyOutInstr forall (out :: [T]). Instr bfi out
q) ->
SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs)))
-> SomeInstrOut (cond : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut (cond : rs))
forall a b. (a -> b) -> a -> b
$ (forall (out :: [T]). Instr (cond : rs) out)
-> SomeInstrOut (cond : rs)
forall (inp :: [T]).
(forall (out :: [T]). Instr inp out) -> SomeInstrOut inp
AnyOutInstr (Instr bti out -> Instr bfi out -> Instr (cond : rs) out
forall (s' :: [T]).
Instr bti s' -> Instr bfi s' -> Instr (cond : rs) s'
cons Instr bti out
forall (out :: [T]). Instr bti out
p Instr bfi out
forall (out :: [T]). Instr bfi out
q)
mapImpl
:: forall c rs.
( MapOp c
, WellTyped (MapOpInp c)
, SingIOne (MapOpRes c)
)
=> ([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> U.ExpandedInstr
-> [U.ExpandedOp]
-> HST (c ': rs)
-> (forall v'. (SingI v') =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' ': rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c ': rs))
mapImpl :: forall (c :: T) (rs :: [T]).
(MapOp c, WellTyped (MapOpInp c), SingIOne (MapOpRes c)) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> SingT (MapOpInp c)
-> VarAnn
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> (forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
mapImpl [TypeCheckedOp] -> TypeCheckedInstr
cons SingT (MapOpInp c)
vn VarAnn
anns ExpandedInstr
instr [ExpandedOp]
mp i :: HST (c : rs)
i@((SingT x, Dict (WellTyped x))
_ ::& HST xs
rs) forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs))
mkRes = do
TypeCheckInstrNoExcept (TypeCheckedSeq (MapOpInp c : rs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (MapOpInp c : rs)
-> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ([ExpandedOp]
-> HST (MapOpInp c : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (MapOpInp c : xs))
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
mp ((SingT (MapOpInp c)
vn, Dict (WellTyped (MapOpInp c))
forall (a :: Constraint). a => Dict a
Dict) (SingT (MapOpInp c), Dict (WellTyped (MapOpInp c)))
-> HST xs -> HST (MapOpInp c : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)) [TypeCheckedOp] -> TypeCheckedInstr
cons ((SomeInstr (MapOpInp c : rs)
-> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs)))
-> (SomeInstr (MapOpInp c : rs)
-> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall a b. (a -> b) -> a -> b
$ \(HST (MapOpInp c : rs)
_ :/ SomeInstrOut (MapOpInp c : rs)
subp) ->
case SomeInstrOut (MapOpInp c : rs)
subp of
Instr (MapOpInp c : rs) out
sub ::: HST out
subo ->
case HST out
subo of
(SingT x
bn :: SingT v', Dict (WellTyped x)
_) ::& HST xs
rs' -> do
xs :~: xs
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (xs :~: xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(xs :~: xs)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration)
(Either TCTypeError (xs :~: xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(xs :~: xs))
-> Either TCTypeError (xs :~: xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(xs :~: xs)
forall a b. (a -> b) -> a -> b
$ HST xs -> HST xs -> Either TCTypeError (xs :~: xs)
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST xs
rs HST xs
rs'
HST (MapOpRes c x : rs)
x <- SingT x -> HST rs -> TypeCheckInstr (HST (MapOpRes c x : rs))
forall (v' :: T).
SingI v' =>
SingT v' -> HST rs -> TypeCheckInstr (HST (MapOpRes c v' : rs))
mkRes SingT x
bn HST rs
HST xs
rs'
pure $ HST (c : rs)
i HST (c : rs) -> SomeInstrOut (c : rs) -> SomeInstr (c : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ forall {k1} {k2} (f :: k1 -> k2) (x :: k1) r.
(SingIOne f, SingI x) =>
(SingI (f x) => r) -> r
forall (f :: T -> T) (x :: T) r.
(SingIOne f, SingI x) =>
(SingI (f x) => r) -> r
withSingIOne @(MapOpRes c) @v' (AnnVar
-> Instr (MapOpInp c : rs) (x : rs)
-> Instr (c : rs) (MapOpRes c x : rs)
forall (c :: T) (b :: T) (s :: [T]).
(MapOp c, SingI b) =>
AnnVar
-> Instr (MapOpInp c : s) (b : s)
-> Instr (c : s) (MapOpRes c b : s)
AnnMAP (VarAnn -> AnnVar
forall {k} (a :: k).
Typeable a =>
Annotation a -> Anns '[Annotation a]
Anns1 VarAnn
anns) Instr (MapOpInp c : rs) out
Instr (MapOpInp c : rs) (x : rs)
sub Instr (c : rs) (MapOpRes c x : rs)
-> HST (MapOpRes c x : rs) -> SomeInstrOut (c : rs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST (MapOpRes c x : rs)
x)
HST out
_ -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> m a
typeCheckInstrErr ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration)
AnyOutInstr forall (out :: [T]). Instr (MapOpInp c : rs) out
_ ->
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
CodeAlwaysFails
iterImpl
:: forall c rs .
( IterOp c
, WellTyped (IterOpEl c)
)
=> SingT (IterOpEl c)
-> U.ExpandedInstr
-> [U.ExpandedOp]
-> HST (c ': rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c ': rs))
iterImpl :: forall (c :: T) (rs :: [T]).
(IterOp c, WellTyped (IterOpEl c)) =>
SingT (IterOpEl c)
-> ExpandedInstr
-> [ExpandedOp]
-> HST (c : rs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
iterImpl SingT (IterOpEl c)
en ExpandedInstr
instr [ExpandedOp]
mp i :: HST (c : rs)
i@((SingT x
_, Dict (WellTyped x)
_) ::& HST xs
rs) = do
let tcAction :: TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
tcAction = case [ExpandedOp]
mp of
[] -> ExpandedInstr
-> TypeCheckInstr (SomeInstr (IterOpEl c : rs))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
forall (s :: [T]).
ExpandedInstr
-> TypeCheckInstr (SomeInstr s)
-> TypeCheckInstrNoExcept (TypeCheckedSeq s)
workOnInstr ExpandedInstr
instr
(ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (IterOpEl c : rs))
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) TCTypeError
EmptyCode)
[ExpandedOp]
_ -> TcInstrHandler
-> [ExpandedOp]
-> HST (IterOpEl c : xs)
-> TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : xs))
forall (inp :: [T]).
SingI inp =>
TcInstrHandler
-> [ExpandedOp]
-> HST inp
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
typeCheckImpl TcInstrHandler
typeCheckInstr [ExpandedOp]
mp ((SingT (IterOpEl c)
en, Dict (WellTyped (IterOpEl c))
forall (a :: Constraint). a => Dict a
Dict) (SingT (IterOpEl c), Dict (WellTyped (IterOpEl c)))
-> HST xs -> HST (IterOpEl c : xs)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST xs
rs)
TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr (IterOpEl c : rs)
-> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving TypeCheckInstrNoExcept (TypeCheckedSeq (IterOpEl c : rs))
tcAction [TypeCheckedOp] -> TypeCheckedInstr
forall op. [op] -> InstrAbstract op
U.ITER ((SomeInstr (IterOpEl c : rs)
-> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs)))
-> (SomeInstr (IterOpEl c : rs)
-> TypeCheckInstr (SomeInstr (c : rs)))
-> TypeCheckInstrNoExcept (TypeCheckedSeq (c : rs))
forall a b. (a -> b) -> a -> b
$ \(HST (IterOpEl c : rs)
_ :/ SomeInstrOut (IterOpEl c : rs)
subp) -> case SomeInstrOut (IterOpEl c : rs)
subp of
Instr (IterOpEl c : rs) out
subI ::: HST out
o -> do
out :~: xs
Refl <- ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> Either TCTypeError (out :~: xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(out :~: xs)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr
-> SomeHST -> Maybe TypeContext -> Either TCTypeError a -> m a
onTypeCheckInstrErr ExpandedInstr
instr (HST (c : rs) -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST (c : rs)
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
Iteration) (Either TCTypeError (out :~: xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(out :~: xs))
-> Either TCTypeError (out :~: xs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(out :~: xs)
forall a b. (a -> b) -> a -> b
$ HST out -> HST xs -> Either TCTypeError (out :~: xs)
forall (as :: [T]) (bs :: [T]).
(SingI as, SingI bs) =>
HST as -> HST bs -> Either TCTypeError (as :~: bs)
eqHST HST out
o HST xs
rs
SomeInstr (c : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr (c : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs)))
-> SomeInstr (c : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs))
forall a b. (a -> b) -> a -> b
$ HST (c : rs)
i HST (c : rs) -> SomeInstrOut (c : rs) -> SomeInstr (c : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (IterOpEl c : out) out -> Instr (c : out) out
forall (c :: T) (out :: [T]).
IterOp c =>
Instr (IterOpEl c : out) out -> Instr (c : out) out
ITER Instr (IterOpEl c : rs) out
Instr (IterOpEl c : out) out
subI Instr (c : out) out -> HST out -> SomeInstrOut (c : out)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST out
o
AnyOutInstr forall (out :: [T]). Instr (IterOpEl c : rs) out
subI ->
SomeInstr (c : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SomeInstr (c : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs)))
-> SomeInstr (c : rs)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr (c : rs))
forall a b. (a -> b) -> a -> b
$ HST (c : rs)
i HST (c : rs) -> SomeInstrOut (c : rs) -> SomeInstr (c : rs)
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/ Instr (IterOpEl c : xs) xs -> Instr (c : xs) xs
forall (c :: T) (out :: [T]).
IterOp c =>
Instr (IterOpEl c : out) out -> Instr (c : out) out
ITER Instr (IterOpEl c : xs) xs
forall (out :: [T]). Instr (IterOpEl c : rs) out
subI Instr (c : xs) xs -> HST xs -> SomeInstrOut (c : xs)
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: HST xs
rs
lamImpl
:: forall it ot ts .
( WellTyped it, WellTyped ot
, SingI ts
)
=> ([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes it, Notes ot]
-> U.ExpandedInstr
-> [U.ExpandedOp]
-> SingT it
-> SingT ot
-> HST ts
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl :: forall (it :: T) (ot :: T) (ts :: [T]).
(WellTyped it, WellTyped ot, SingI ts) =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> Anns '[VarAnn, Notes it, Notes ot]
-> ExpandedInstr
-> [ExpandedOp]
-> SingT it
-> SingT ot
-> HST ts
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
lamImpl [TypeCheckedOp] -> TypeCheckedInstr
cons Anns '[VarAnn, Notes it, Notes ot]
anns ExpandedInstr
instr [ExpandedOp]
is SingT it
ins SingT ot
ons HST ts
i =
ExpandedInstr
-> TypeCheckInstr ()
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall a (inp :: [T]).
ExpandedInstr
-> TypeCheckInstr a
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
guarding_ ExpandedInstr
instr
(Maybe ExpandedInstr
-> (ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
())
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
()
forall (f :: * -> *) a.
Applicative f =>
Maybe a -> (a -> f ()) -> f ()
whenJust (First ExpandedInstr -> Maybe ExpandedInstr
forall a. First a -> Maybe a
getFirst (First ExpandedInstr -> Maybe ExpandedInstr)
-> First ExpandedInstr -> Maybe ExpandedInstr
forall a b. (a -> b) -> a -> b
$ (Element [ExpandedOp] -> First ExpandedInstr)
-> [ExpandedOp] -> First ExpandedInstr
forall t m. (Container t, Monoid m) => (Element t -> m) -> t -> m
foldMap Element [ExpandedOp] -> First ExpandedInstr
ExpandedOp -> First ExpandedInstr
hasSelf [ExpandedOp]
is) ((ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
())
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
())
-> (ExpandedInstr
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
())
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
()
forall a b. (a -> b) -> a -> b
$ \ExpandedInstr
selfInstr -> do
let err :: TCTypeError
err = ExpandedInstr -> Text -> TCTypeError
InvalidInstruction ExpandedInstr
selfInstr Text
"SELF instruction cannot be used in a LAMBDA"
ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
()
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST ts -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST ts
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaCode) TCTypeError
err) (TypeCheckInstrNoExcept (TypeCheckedSeq ts)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall a b. (a -> b) -> a -> b
$
TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr '[it] -> TypeCheckInstr (SomeInstr ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall (inp :: [T]) (inp' :: [T]).
TypeCheckInstrNoExcept (TypeCheckedSeq inp)
-> ([TypeCheckedOp] -> TypeCheckedInstr)
-> (SomeInstr inp -> TypeCheckInstr (SomeInstr inp'))
-> TypeCheckInstrNoExcept (TypeCheckedSeq inp')
preserving ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
tcInstr [TypeCheckedOp] -> TypeCheckedInstr
cons ((SomeInstr '[it] -> TypeCheckInstr (SomeInstr ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts))
-> (SomeInstr '[it] -> TypeCheckInstr (SomeInstr ts))
-> TypeCheckInstrNoExcept (TypeCheckedSeq ts)
forall a b. (a -> b) -> a -> b
$ \(HST '[it]
_ :/ SomeInstrOut '[it]
lamI) -> do
let lamNotes :: SingT ot -> SingT ('TLambda it ot)
lamNotes SingT ot
onsr = Sing it -> Sing ot -> SingT ('TLambda it ot)
forall (n1 :: T) (n2 :: T).
Sing n1 -> Sing n2 -> SingT ('TLambda n1 n2)
STLambda Sing it
SingT it
ins Sing ot
SingT ot
onsr
let lamSt :: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
onsr = (SingT ot -> SingT ('TLambda it ot)
lamNotes SingT ot
onsr, Dict (WellTyped ('TLambda it ot))
forall (a :: Constraint). a => Dict a
Dict) (SingT ('TLambda it ot), Dict (WellTyped ('TLambda it ot)))
-> HST ts -> HST ('TLambda it ot : ts)
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST ts
i
(SomeInstrOut ts -> SomeInstr ts)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut ts)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ts)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HST ts
i HST ts -> SomeInstrOut ts -> SomeInstr ts
forall (inp :: [T]). HST inp -> SomeInstrOut inp -> SomeInstr inp
:/) (ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut ts)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ts))
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut ts)
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstr ts)
forall a b. (a -> b) -> a -> b
$ case SomeInstrOut '[it]
lamI of
Instr '[it] out
lam ::: HST out
lo -> do
case forall (t :: T) (st :: [T]).
(SingI st, WellTyped t) =>
HST st -> Either TCTypeError (st :~: '[t])
eqHST1 @ot HST out
lo of
Right out :~: '[ot]
Refl -> do
SomeInstrOut ts
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Anns '[VarAnn, Notes it, Notes ot]
-> Value' Instr ('TLambda it ot) -> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (inp :: [T]).
(SingI i, SingI o) =>
Anns '[VarAnn, Notes i, Notes o]
-> Value' Instr ('TLambda i o) -> Instr inp ('TLambda i o : inp)
AnnLAMBDA Anns '[VarAnn, Notes it, Notes ot]
anns (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall (inp :: T) (out :: T) (instr :: [T] -> [T] -> *).
(SingI inp, SingI out,
forall (i :: [T]) (o :: [T]). Show (instr i o),
forall (i :: [T]) (o :: [T]). Eq (instr i o),
forall (i :: [T]) (o :: [T]). NFData (instr i o)) =>
RemFail instr '[inp] '[out] -> Value' instr ('TLambda inp out)
VLam (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot))
-> RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall a b. (a -> b) -> a -> b
$ Instr '[it] out -> RemFail Instr '[it] out
forall {k} (instr :: k -> k -> *) (i :: k) (o :: k).
instr i o -> RemFail instr i o
RfNormal Instr '[it] out
lam) Instr ts ('TLambda it ot : ts)
-> HST ('TLambda it ot : ts) -> SomeInstrOut ts
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
ons)
Left TCTypeError
m -> ExpandedInstr
-> SomeHST
-> Maybe TypeContext
-> TCTypeError
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut ts)
forall (m :: * -> *) a.
(MonadReader TypeCheckInstrEnv m, MonadError TCError m) =>
ExpandedInstr -> SomeHST -> Maybe TypeContext -> TCTypeError -> m a
typeCheckInstrErr' ExpandedInstr
instr (HST ts -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST ts
i) (TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
LambdaCode) TCTypeError
m
AnyOutInstr forall (out :: [T]). Instr '[it] out
lam ->
SomeInstrOut ts
-> ReaderT
TypeCheckInstrEnv
(ReaderT
TypeCheckEnv (ReaderT TypeCheckOptions (ExceptT TCError Identity)))
(SomeInstrOut ts)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Anns '[VarAnn, Notes it, Notes ot]
-> Value' Instr ('TLambda it ot) -> Instr ts ('TLambda it ot : ts)
forall (i :: T) (o :: T) (inp :: [T]).
(SingI i, SingI o) =>
Anns '[VarAnn, Notes i, Notes o]
-> Value' Instr ('TLambda i o) -> Instr inp ('TLambda i o : inp)
AnnLAMBDA Anns '[VarAnn, Notes it, Notes ot]
anns (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall (inp :: T) (out :: T) (instr :: [T] -> [T] -> *).
(SingI inp, SingI out,
forall (i :: [T]) (o :: [T]). Show (instr i o),
forall (i :: [T]) (o :: [T]). Eq (instr i o),
forall (i :: [T]) (o :: [T]). NFData (instr i o)) =>
RemFail instr '[inp] '[out] -> Value' instr ('TLambda inp out)
VLam (RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot))
-> RemFail Instr '[it] '[ot] -> Value' Instr ('TLambda it ot)
forall a b. (a -> b) -> a -> b
$ (forall (out :: [T]). Instr '[it] out) -> RemFail Instr '[it] '[ot]
forall {k} (instr :: k -> k -> *) (i :: k) (o :: k).
(forall (o' :: k). instr i o') -> RemFail instr i o
RfAlwaysFails forall (out :: [T]). Instr '[it] out
lam) Instr ts ('TLambda it ot : ts)
-> HST ('TLambda it ot : ts) -> SomeInstrOut ts
forall (out :: [T]) (inp :: [T]).
SingI out =>
Instr inp out -> HST out -> SomeInstrOut inp
::: SingT ot -> HST ('TLambda it ot : ts)
lamSt SingT ot
ons)
where
tcInstr :: ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
tcInstr = (IsNotInView =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
forall r. (IsNotInView => r) -> r
giveNotInView ((IsNotInView =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it]))
-> (IsNotInView =>
ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
forall a b. (a -> b) -> a -> b
$ (TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (ASetter
TypeCheckInstrEnv
TypeCheckInstrEnv
(Maybe (Dict IsNotInView))
(Maybe (Dict IsNotInView))
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
TypeCheckInstrEnv
TypeCheckInstrEnv
(Maybe (Dict IsNotInView))
(Maybe (Dict IsNotInView))
Lens' TypeCheckInstrEnv (Maybe (Dict IsNotInView))
tcieNotInView (Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv -> TypeCheckInstrEnv)
-> Maybe (Dict IsNotInView)
-> TypeCheckInstrEnv
-> TypeCheckInstrEnv
forall a b. (a -> b) -> a -> b
$ Dict IsNotInView -> Maybe (Dict IsNotInView)
forall a. a -> Maybe a
Just Dict IsNotInView
forall (a :: Constraint). a => Dict a
Dict) (ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it]))
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
(TypeCheckedSeq '[it])
forall a b. (a -> b) -> a -> b
$ [ExpandedOp]
-> HST '[it] -> TypeCheckInstrNoExcept (TypeCheckedSeq '[it])
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
is ((SingT it
ins, Dict (WellTyped it)
forall (a :: Constraint). a => Dict a
Dict) (SingT it, Dict (WellTyped it)) -> HST '[] -> HST '[it]
forall (x :: T) (xs :: [T]).
(SingI x, SingI xs) =>
(SingT x, Dict (WellTyped x)) -> HST xs -> HST (x : xs)
::& HST '[]
SNil)
hasSelf :: U.ExpandedOp -> First U.ExpandedInstr
hasSelf :: ExpandedOp -> First ExpandedInstr
hasSelf = (First ExpandedInstr -> First ExpandedInstr -> First ExpandedInstr)
-> GenericQ (First ExpandedInstr) -> GenericQ (First ExpandedInstr)
forall r. (r -> r -> r) -> GenericQ r -> GenericQ r
everything First ExpandedInstr -> First ExpandedInstr -> First ExpandedInstr
forall a. Semigroup a => a -> a -> a
(<>)
(First ExpandedInstr
-> (ExpandedInstr -> First ExpandedInstr)
-> a
-> First ExpandedInstr
forall a b r. (Typeable a, Typeable b) => r -> (b -> r) -> a -> r
mkQ (Maybe ExpandedInstr -> First ExpandedInstr
forall a. Maybe a -> First a
First Maybe ExpandedInstr
forall a. Maybe a
Nothing)
(\case
selfInstr :: ExpandedInstr
selfInstr@(U.SELF{} :: U.InstrAbstract U.ExpandedOp) -> Maybe ExpandedInstr -> First ExpandedInstr
forall a. Maybe a -> First a
First (Maybe ExpandedInstr -> First ExpandedInstr)
-> Maybe ExpandedInstr -> First ExpandedInstr
forall a b. (a -> b) -> a -> b
$ ExpandedInstr -> Maybe ExpandedInstr
forall a. a -> Maybe a
Just ExpandedInstr
selfInstr
ExpandedInstr
_ -> Maybe ExpandedInstr -> First ExpandedInstr
forall a. Maybe a -> First a
First Maybe ExpandedInstr
forall a. Maybe a
Nothing
)
)
data TCDipHelper inp where
TCDipHelperOk ::
forall (n :: Peano) inp out s s'.
(SingI out, ConstraintDIPN n inp out s s') =>
PeanoNatural n -> Instr s s' -> HST out -> TCDipHelper inp
TCDipHelperErr :: TCError -> [IllTypedInstr] -> TCDipHelper inp
typeCheckDipBody
:: SingI inp
=> ([TypeCheckedOp] -> TypeCheckedInstr)
-> U.ExpandedInstr
-> [U.ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall out. SingI out => Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody :: forall (inp :: [T]) r.
SingI inp =>
([TypeCheckedOp] -> TypeCheckedInstr)
-> ExpandedInstr
-> [ExpandedOp]
-> HST inp
-> (TCError -> [IllTypedInstr] -> r)
-> (forall (out :: [T]).
SingI out =>
Instr inp out -> HST out -> r)
-> TypeCheckInstrNoExcept r
typeCheckDipBody [TypeCheckedOp] -> TypeCheckedInstr
cons ExpandedInstr
mainInstr [ExpandedOp]
instructions HST inp
inputHST TCError -> [IllTypedInstr] -> r
onErr forall (out :: [T]). SingI out => Instr inp out -> HST out -> r
onOk = do
TypeCheckedSeq inp
listRes <- [ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
forall (inp :: [T]).
SingI inp =>
[ExpandedOp]
-> HST inp -> TypeCheckInstrNoExcept (TypeCheckedSeq inp)
tcList [ExpandedOp]
instructions HST inp
inputHST
ErrorSrcPos
pos <- Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
-> ReaderT
TypeCheckInstrEnv
(ReaderT TypeCheckEnv (ReaderT TypeCheckOptions Identity))
ErrorSrcPos
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ErrorSrcPos TypeCheckInstrEnv ErrorSrcPos
Lens' TypeCheckInstrEnv ErrorSrcPos
tcieErrorPos
pure $ TypeCheckedSeq inp
listRes TypeCheckedSeq inp -> (TypeCheckedSeq inp -> r) -> r
forall a b. a -> (a -> b) -> b
& ([TypeCheckedOp] -> TCError -> r)
-> (SomeInstr inp -> r) -> TypeCheckedSeq inp -> r
forall a (inp :: [T]).
([TypeCheckedOp] -> TCError -> a)
-> (SomeInstr inp -> a) -> TypeCheckedSeq inp -> a
tcsEither
(\[TypeCheckedOp]
tcOps TCError
err -> TCError -> [IllTypedInstr] -> r
onErr TCError
err [TypeCheckedInstr -> IllTypedInstr
SemiTypedInstr (TypeCheckedInstr -> IllTypedInstr)
-> TypeCheckedInstr -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ [TypeCheckedOp] -> TypeCheckedInstr
cons [TypeCheckedOp]
tcOps])
(\someInstr :: SomeInstr inp
someInstr@(HST inp
_ :/ SomeInstrOut inp
iAndOut) -> case SomeInstrOut inp
iAndOut of
AnyOutInstr forall (out :: [T]). Instr inp out
_ ->
let err :: TCError
err = ExpandedInstr
-> SomeHST
-> ErrorSrcPos
-> Maybe TypeContext
-> Maybe TCTypeError
-> TCError
TCFailedOnInstr ExpandedInstr
mainInstr
(HST inp -> SomeHST
forall (ts :: [T]). SingI ts => HST ts -> SomeHST
SomeHST HST inp
inputHST)
ErrorSrcPos
pos
(TypeContext -> Maybe TypeContext
forall a. a -> Maybe a
Just TypeContext
DipCode)
(TCTypeError -> Maybe TCTypeError
forall a. a -> Maybe a
Just TCTypeError
CodeAlwaysFails)
in TCError -> [IllTypedInstr] -> r
onErr TCError
err [TypeCheckedInstr -> IllTypedInstr
SemiTypedInstr (TypeCheckedInstr -> IllTypedInstr)
-> TypeCheckedInstr -> IllTypedInstr
forall a b. (a -> b) -> a -> b
$ [TypeCheckedOp] -> TypeCheckedInstr
cons [SomeInstr inp -> TypeCheckedOp
forall (inp :: [T]). SomeInstr inp -> TypeCheckedOp
someInstrToOp SomeInstr inp
someInstr]]
Instr inp out
subI ::: HST out
t -> Instr inp out -> HST out -> r
forall (out :: [T]). SingI out => Instr inp out -> HST out -> r
onOk Instr inp out
subI HST out
t)