Safe Haskell	Safe-Inferred
Language	Haskell2010

Morley.Michelson.Typed

Synopsis

withDict :: HasDict c e => e -> (c => r) -> r
data Dict a where
- Dict :: forall a. a => Dict a
newtype a :- b = Sub (a => Dict b)
class SingI (a :: k) where
- sing :: Sing a
type Path = [Branch]
data Branch
- = L
- | S
- | R
data Constrained c f where
- pattern SomePackedVal :: () => PackedValScope t => Value t -> SomePackedVal
- pattern SomeConstant :: () => ConstantScope t => Value t -> SomeConstant
- pattern SomeConstrainedValue :: forall c. () => forall a. c a => Value a -> SomeConstrainedValue c
- pattern SomeStorage :: () => StorageScope t => Value t -> SomeStorage
- pattern SomeValue :: () => SingI t => Value t -> SomeValue
ligoLayout :: GenericStrategy
ligoCombLayout :: GenericStrategy
data T
- = TKey
- | TUnit
- | TSignature
- | TChainId
- | TOption T
- | TList T
- | TSet T
- | TOperation
- | TContract T
- | TTicket T
- | TPair T T
- | TOr T T
- | TLambda T T
- | TMap T T
- | TBigMap T T
- | TInt
- | TNat
- | TString
- | TBytes
- | TMutez
- | TBool
- | TKeyHash
- | TBls12381Fr
- | TBls12381G1
- | TBls12381G2
- | TTimestamp
- | TAddress
- | TChest
- | TChestKey
- | TSaplingState Peano
- | TSaplingTransaction Peano
- | TNever
toUType :: T -> Ty
buildStack :: [T] -> Builder
data SingT :: T -> Type where
- STKey :: SingT ('TKey :: T)
- STUnit :: SingT ('TUnit :: T)
- STSignature :: SingT ('TSignature :: T)
- STChainId :: SingT ('TChainId :: T)
- STOption :: forall (n :: T). (Sing n) -> SingT ('TOption n :: T)
- STList :: forall (n :: T). (Sing n) -> SingT ('TList n :: T)
- STSet :: forall (n :: T). (Sing n) -> SingT ('TSet n :: T)
- STOperation :: SingT ('TOperation :: T)
- STContract :: forall (n :: T). (Sing n) -> SingT ('TContract n :: T)
- STTicket :: forall (n :: T). (Sing n) -> SingT ('TTicket n :: T)
- STPair :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TPair n n :: T)
- STOr :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TOr n n :: T)
- STLambda :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TLambda n n :: T)
- STMap :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TMap n n :: T)
- STBigMap :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TBigMap n n :: T)
- STInt :: SingT ('TInt :: T)
- STNat :: SingT ('TNat :: T)
- STString :: SingT ('TString :: T)
- STBytes :: SingT ('TBytes :: T)
- STMutez :: SingT ('TMutez :: T)
- STBool :: SingT ('TBool :: T)
- STKeyHash :: SingT ('TKeyHash :: T)
- STBls12381Fr :: SingT ('TBls12381Fr :: T)
- STBls12381G1 :: SingT ('TBls12381G1 :: T)
- STBls12381G2 :: SingT ('TBls12381G2 :: T)
- STTimestamp :: SingT ('TTimestamp :: T)
- STAddress :: SingT ('TAddress :: T)
- STChest :: SingT ('TChest :: T)
- STChestKey :: SingT ('TChestKey :: T)
- STSaplingState :: forall (n :: Nat). (Sing n) -> SingT ('TSaplingState n :: T)
- STSaplingTransaction :: forall (n :: Nat). (Sing n) -> SingT ('TSaplingTransaction n :: T)
- STNever :: SingT ('TNever :: T)
castSingE :: forall (a :: T) (b :: T) t. (SingI a, SingI b) => t a -> Either Text (t b)
castM :: forall (a :: T) (b :: T) t m. (SingI a, SingI b, Monad m) => t a -> (forall x. MismatchError T -> m x) -> m (t b)
requireEq :: forall (a :: T) (b :: T) m. (SingI a, SingI b, Monad m) => (forall x. MismatchError T -> m x) -> m (a :~: b)
eqP :: forall (a :: T) (b :: T). (SingI a, SingI b) => Proxy a -> Proxy b -> Maybe (a :~: b)
data Comparability t where
- CanBeCompared :: Comparable t => Comparability t
- CannotBeCompared :: IsComparable t ~ 'False => Comparability t
data NotWellTyped = NotWellTyped {
- nwtBadType :: T
- nwtCause :: BadTypeForScope
}
class (SingI t, WellTypedSuperC t) => WellTyped (t :: T) where
- type WellTypedSuperC t :: Constraint
class (IsComparable t ~ 'True, SingI t, ComparableSuperC t) => Comparable t where
- type ComparableSuperC t :: Constraint
type ProperNonComparableValBetterErrors t = (SingI t, ForbidNonComparable t)
type ProperUntypedValBetterErrors t = (SingI t, ForbidOp t)
type ProperViewableBetterErrors t = (SingI t, ForbidOp t, ForbidBigMap t, ForbidTicket t)
type ProperUnpackedValBetterErrors t = (ProperPackedValBetterErrors t, ProperConstantBetterErrors t)
type ProperPackedValBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidBigMap t, ForbidTicket t, ForbidSaplingState t)
type ProperDupableBetterErrors t = (SingI t, ForbidTicket t)
type ProperConstantBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidBigMap t, ForbidContract t, ForbidTicket t, ForbidSaplingState t)
type ProperStorageBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidNestedBigMaps t, ForbidContract t)
type ProperParameterBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidNestedBigMaps t)
class WithDeMorganScope (c :: T -> Constraint) t a b where
- withDeMorganScope :: c (t a b) => ((c a, c b) => ret) -> ret
class (SingI t, Comparable t) => ComparabilityScope t
class CheckScope (c :: Constraint) where
- checkScope :: Either BadTypeForScope (Dict c)
type UntypedValScope t = (SingI t, HasNoOp t)
class (SingI t, HasNoOp t, HasNoBigMap t, HasNoTicket t) => ViewableScope t
class (WellTyped t, PackedValScope t, ConstantScope t) => UnpackedValScope t
class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoTicket t, HasNoSaplingState t) => PackedValScope t
type family IsDupableScope (t :: T) :: Bool where ...
class (SingI t, HasNoTicket t) => DupableScope t
class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope t
class (SingI t, WellTyped t, HasNoOp t, HasNoNestedBigMaps t, HasNoContract t) => StorageScope t
class (SingI t, WellTyped t, HasNoOp t, HasNoNestedBigMaps t) => ParameterScope t
data BadTypeForScope
- = BtNotComparable
- | BtIsOperation
- | BtHasBigMap
- | BtHasNestedBigMap
- | BtHasContract
- | BtHasTicket
- | BtHasSaplingState
data NestedBigMapsPresence (t :: T)
- = ContainsNestedBigMaps t ~ 'True => NestedBigMapsPresent
- | ContainsNestedBigMaps t ~ 'False => NestedBigMapsAbsent
data BigMapPresence (t :: T)
- = ContainsBigMap t ~ 'True => BigMapPresent
- | ContainsBigMap t ~ 'False => BigMapAbsent
data TicketPresence (t :: T)
- = ContainsTicket t ~ 'True => TicketPresent
- | ContainsTicket t ~ 'False => TicketAbsent
data ContractPresence (t :: T)
- = ContainsContract t ~ 'True => ContractPresent
- | ContainsContract t ~ 'False => ContractAbsent
data OpPresence (t :: T)
- = ContainsOp t ~ 'True => OpPresent
- | ContainsOp t ~ 'False => OpAbsent
type ForbidNonComparable t = FailUnless (IsComparable t) ('Text "Only comparable types are allowed here")
type ForbidNestedBigMaps t = FailWhen (ContainsNestedBigMaps t) ('Text "Nested BigMaps are not allowed")
type ForbidBigMap t = FailWhen (ContainsBigMap t) ('Text "BigMaps are not allowed in this scope")
type ForbidTicket t = FailWhen (ContainsTicket t) ('Text "Type `ticket` is not allowed in this scope")
type ForbidContract t = FailWhen (ContainsContract t) ('Text "Type `contract` is not allowed in this scope")
type ForbidOp t = FailWhen (ContainsOp t) ('Text "Operations are not allowed in this scope")
class ContainsNestedBigMaps t ~ 'False => HasNoNestedBigMaps t
class ContainsBigMap t ~ 'False => HasNoBigMap t
class ContainsTicket t ~ 'False => HasNoTicket t
class ContainsContract t ~ 'False => HasNoContract t
class ContainsOp t ~ 'False => HasNoOp t
type family IsComparable (t :: T) :: Bool where ...
type family ContainsNestedBigMaps (t :: T) :: Bool where ...
type family ContainsBigMap (t :: T) :: Bool where ...
type family ContainsTicket (t :: T) :: Bool where ...
type family ContainsContract (t :: T) :: Bool where ...
type family ContainsOp (t :: T) :: Bool where ...
checkOpPresence :: Sing (ty :: T) -> OpPresence ty
checkContractTypePresence :: Sing (ty :: T) -> ContractPresence ty
checkTicketPresence :: Sing (ty :: T) -> TicketPresence ty
checkBigMapPresence :: Sing (ty :: T) -> BigMapPresence ty
checkNestedBigMapsPresence :: Sing (ty :: T) -> NestedBigMapsPresence ty
opAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoOp t)
contractTypeAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoContract t)
bigMapAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoBigMap t)
nestedBigMapsAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoNestedBigMaps t)
comparabilityPresence :: Sing t -> Maybe (Dict (Comparable t))
getWTP :: forall t. SingI t => Either NotWellTyped (Dict (WellTyped t))
getWTP' :: Sing t -> Either NotWellTyped (Dict (WellTyped t))
getComparableProofS :: Sing (a :: T) -> Maybe (Dict (Comparable a))
checkComparability :: Sing t -> Comparability t
comparabilityImpliesNoNestedBigMaps :: forall t. (SingI t, IsComparable t ~ 'True) => ContainsNestedBigMaps t :~: 'False
comparabilityImpliesNoOp :: forall t. (SingI t, IsComparable t ~ 'True) => ContainsOp t :~: 'False
type FieldDescriptions = [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
newtype EpName = UnsafeEpName {
- unEpName :: Text
}
data HandleImplicitDefaultEp
- = WithoutImplicitDefaultEp
- | WithImplicitDefaultEp
data EpNameFromRefAnnError = InEpNameBadAnnotation FieldAnn
pattern DefEpName :: EpName
epNameFromParamAnn :: FieldAnn -> Maybe EpName
epNameToParamAnn :: EpName -> FieldAnn
epNameFromRefAnn :: FieldAnn -> Either EpNameFromRefAnnError EpName
epNameToRefAnn :: EpName -> FieldAnn
newtype ViewName where
- UnsafeViewName {
  - unViewName :: Text
  }
- pattern ViewName :: Text -> ViewName
data BadViewNameError
- = BadViewTooLong Int
- | BadViewIllegalChars Text
mkViewName :: Text -> Either BadViewNameError ViewName
viewNameToMText :: ViewName -> MText
data ViewsSetError = DuplicatedViewName ViewName
data Notes t where
- NTKey :: TypeAnn -> Notes 'TKey
- NTUnit :: TypeAnn -> Notes 'TUnit
- NTSignature :: TypeAnn -> Notes 'TSignature
- NTChainId :: TypeAnn -> Notes 'TChainId
- NTOption :: TypeAnn -> Notes t -> Notes ('TOption t)
- NTList :: TypeAnn -> Notes t -> Notes ('TList t)
- NTSet :: TypeAnn -> Notes t -> Notes ('TSet t)
- NTOperation :: TypeAnn -> Notes 'TOperation
- NTContract :: TypeAnn -> Notes t -> Notes ('TContract t)
- NTTicket :: TypeAnn -> Notes t -> Notes ('TTicket t)
- NTPair :: TypeAnn -> FieldAnn -> FieldAnn -> VarAnn -> VarAnn -> Notes p -> Notes q -> Notes ('TPair p q)
- NTOr :: TypeAnn -> FieldAnn -> FieldAnn -> Notes p -> Notes q -> Notes ('TOr p q)
- NTLambda :: TypeAnn -> Notes p -> Notes q -> Notes ('TLambda p q)
- NTMap :: TypeAnn -> Notes k -> Notes v -> Notes ('TMap k v)
- NTBigMap :: TypeAnn -> Notes k -> Notes v -> Notes ('TBigMap k v)
- NTInt :: TypeAnn -> Notes 'TInt
- NTNat :: TypeAnn -> Notes 'TNat
- NTString :: TypeAnn -> Notes 'TString
- NTBytes :: TypeAnn -> Notes 'TBytes
- NTMutez :: TypeAnn -> Notes 'TMutez
- NTBool :: TypeAnn -> Notes 'TBool
- NTKeyHash :: TypeAnn -> Notes 'TKeyHash
- NTBls12381Fr :: TypeAnn -> Notes 'TBls12381Fr
- NTBls12381G1 :: TypeAnn -> Notes 'TBls12381G1
- NTBls12381G2 :: TypeAnn -> Notes 'TBls12381G2
- NTTimestamp :: TypeAnn -> Notes 'TTimestamp
- NTAddress :: TypeAnn -> Notes 'TAddress
- NTChest :: TypeAnn -> Notes 'TChest
- NTChestKey :: TypeAnn -> Notes 'TChestKey
- NTNever :: TypeAnn -> Notes 'TNever
- NTSaplingState :: forall (n :: Peano). TypeAnn -> Sing n -> Notes ('TSaplingState n)
- NTSaplingTransaction :: forall (n :: Peano). TypeAnn -> Sing n -> Notes ('TSaplingTransaction n)
data Anns xs where
- AnnsCons :: Typeable tag => !(Annotation tag) -> Anns xs -> Anns (Annotation tag ': xs)
- AnnsTyCons :: SingI t => !(Notes t) -> Anns xs -> Anns (Notes t ': xs)
- AnnsNil :: Anns '[]
- pattern Anns5' :: (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]
- pattern Anns4'' :: (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]
- pattern Anns4 :: Each '[Typeable] '[a, b, c, d] => Annotation a -> Annotation b -> Annotation c -> Annotation d -> Anns '[Annotation a, Annotation b, Annotation c, Annotation d]
- pattern Anns3'' :: (Typeable a, SingI t, SingI u) => Annotation a -> Notes t -> Notes u -> Anns '[Annotation a, Notes t, Notes u]
- pattern Anns3' :: (Each '[Typeable] '[a, b], SingI t) => Annotation a -> Annotation b -> Notes t -> Anns '[Annotation a, Annotation b, Notes t]
- pattern Anns3 :: Each '[Typeable] '[a, b, c] => Annotation a -> Annotation b -> Annotation c -> Anns '[Annotation a, Annotation b, Annotation c]
- pattern Anns2' :: (Typeable a, SingI t) => Annotation a -> Notes t -> Anns '[Annotation a, Notes t]
- pattern Anns1 :: Typeable a => Annotation a -> Anns '[Annotation a]
- pattern Anns2 :: Each '[Typeable] '[a, b] => Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]
notesSing :: Notes t -> Sing t
notesT :: Notes t -> T
mkUType :: Notes x -> Ty
starNotes :: forall t. SingI t => Notes t
isStar :: SingI t => Notes t -> Bool
insertTypeAnn :: forall (b :: T). TypeAnn -> Notes b -> Notes b
class AnnotateInstr (xs :: [Type]) r where
- annotateInstr :: Anns xs -> AnnotateInstrArg xs r -> r
type AnnVar = Anns '[VarAnn]
pattern AsUTypeExt :: () => SingI t => Sing t -> Notes t -> Ty
pattern AsUType :: () => SingI t => Notes t -> Ty
fromUType :: Ty -> T
withUType :: Ty -> (forall t. SingI t => Notes t -> r) -> r
data SomeViewsSet' instr where
- SomeViewsSet :: SingI st => ViewsSet' instr st -> SomeViewsSet' instr
newtype ViewsSet' instr st where
- UnsafeViewsSet {
  - unViewsSet :: Map ViewName (SomeView' instr st)
  }
- pattern ViewsList :: [SomeView' instr st] -> ViewsSet' instr st
data SomeView' instr st where
- SomeView :: View' instr arg st ret -> SomeView' instr st
data View' instr arg st ret = (ViewableScope arg, SingI st, ViewableScope ret) => View {
- vName :: ViewName
- vArgument :: Notes arg
- vReturn :: Notes ret
- vCode :: ViewCode' instr arg st ret
}
type ViewCode' instr arg st ret = instr '['TPair arg st] '[ret]
someViewName :: SomeView' instr st -> ViewName
mkViewsSet :: [SomeView' instr st] -> Either ViewsSetError (ViewsSet' instr st)
emptyViewsSet :: forall instr st. ViewsSet' instr st
addViewToSet :: View' instr arg st ret -> ViewsSet' instr st -> Either ViewsSetError (ViewsSet' instr st)
lookupView :: forall instr st. ViewName -> ViewsSet' instr st -> Maybe (SomeView' instr st)
viewsSetNames :: forall instr st. ViewsSet' instr st -> Set ViewName
data EpLiftSequence (arg :: T) (param :: T) where
- EplArgHere :: EpLiftSequence arg arg
- EplWrapLeft :: (SingI subparam, SingI r) => EpLiftSequence arg subparam -> EpLiftSequence arg ('TOr subparam r)
- EplWrapRight :: (SingI l, SingI subparam) => EpLiftSequence arg subparam -> EpLiftSequence arg ('TOr l subparam)
data ParamEpError
- = ParamEpDuplicatedNames (NonEmpty EpName)
- | ParamEpUncallableArm ArmCoords
data ArmCoord
- = AcLeft
- | AcRight
type ArmCoords = [ArmCoord]
data ParamNotes (t :: T) = UnsafeParamNotes {
- pnNotes :: Notes t
- pnRootAnn :: RootAnn
}
data ParseEpAddressError
- = ParseEpAddressBadAddress ParseAddressError
- | ParseEpAddressRawBadAddress ParseAddressRawError
- | ParseEpAddressBadEntryopint ByteString UnicodeException
- | ParseEpAddressBadRefAnn Text
- | ParseEpAddressRefAnnError EpNameFromRefAnnError
- | ParseEpAddressInvalidLength Int
data EpAddress where
- EpAddress' {
  - eaAddress :: Address
  - eaEntrypoint :: EpName
  }
- pattern EpAddress :: KindedAddress kind -> EpName -> EpAddress
pattern ParamNotes :: Notes t -> RootAnn -> ParamNotes t
formatEpAddress :: EpAddress -> Text
mformatEpAddress :: EpAddress -> MText
parseEpAddress :: Text -> Either ParseEpAddressError EpAddress
parseEpAddressRaw :: ByteString -> Either ParseEpAddressError EpAddress
starParamNotes :: SingI t => ParamNotes t
mkParamNotes :: Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)
data MkEntrypointCallRes param where
- MkEntrypointCallRes :: ParameterScope arg => Notes arg -> EntrypointCallT param arg -> MkEntrypointCallRes param
data SomeEntrypointCallT (arg :: T) = forall param.ParameterScope param => SomeEpc (EntrypointCallT param arg)
type family ForbidOr (t :: T) :: Constraint where ...
data EntrypointCallT (param :: T) (arg :: T) = ParameterScope arg => EntrypointCall {
- epcName :: EpName
- epcParamProxy :: Proxy param
- epcLiftSequence :: EpLiftSequence arg param
}
unsafeEpcCallRoot :: ParameterScope param => EntrypointCallT param param
epcPrimitive :: forall p. (ParameterScope p, ForbidOr p) => EntrypointCallT p p
unsafeSepcCallRoot :: ParameterScope param => SomeEntrypointCallT param
sepcPrimitive :: forall t. (ParameterScope t, ForbidOr t) => SomeEntrypointCallT t
sepcName :: SomeEntrypointCallT arg -> EpName
mkEntrypointCall :: ParameterScope param => EpName -> ParamNotes param -> Maybe (MkEntrypointCallRes param)
mkDefEntrypointCall :: ParameterScope param => ParamNotes param -> MkEntrypointCallRes param
tyImplicitAccountParam :: ParamNotes 'TUnit
data Contract' instr cp st = (ParameterScope cp, StorageScope st) => Contract {
- cCode :: ContractCode' instr cp st
- cParamNotes :: ParamNotes cp
- cStoreNotes :: Notes st
- cViews :: ViewsSet' instr st
- cEntriesOrder :: EntriesOrder
}
class IsNotInView
newtype ContractCode' instr cp st = ContractCode {
- unContractCode :: instr (ContractInp cp st) (ContractOut st)
}
type ContractOut st = '[ContractOut1 st]
type ContractOut1 st = 'TPair ('TList 'TOperation) st
type ContractInp param st = '[ContractInp1 param st]
type ContractInp1 param st = 'TPair param st
mkContractCode :: (IsNotInView => instr (ContractInp cp st) (ContractOut st)) -> ContractCode' instr cp st
defaultContract :: (ParameterScope cp, StorageScope st) => (IsNotInView => instr (ContractInp cp st) (ContractOut st)) -> Contract' instr cp st
mapContractCodeBlock :: (instr (ContractInp cp st) (ContractOut st) -> instr (ContractInp cp st) (ContractOut st)) -> Contract' instr cp st -> Contract' instr cp st
mapContractCodeBlockM :: Monad m => (instr (ContractInp cp st) (ContractOut st) -> m (instr (ContractInp cp st) (ContractOut st))) -> Contract' instr cp st -> m (Contract' instr cp st)
mapContractViewBlocks :: (forall arg ret. ViewCode' instr arg st ret -> ViewCode' instr arg st ret) -> Contract' instr cp st -> Contract' instr cp st
mapContractViewBlocksM :: Monad m => (forall arg ret. ViewCode' instr arg st ret -> m (ViewCode' instr arg st ret)) -> Contract' instr cp st -> m (Contract' instr cp st)
mapContractCode :: (forall i o. instr i o -> instr i o) -> Contract' instr cp st -> Contract' instr cp st
mapContractCodeM :: Monad m => (forall i o. instr i o -> m (instr i o)) -> Contract' instr cp st -> m (Contract' instr cp st)
mapEntriesOrdered :: Contract' instr cp st -> (ParamNotes cp -> a) -> (Notes st -> a) -> (ContractCode' instr cp st -> a) -> (forall arg ret. View' instr arg st ret -> a) -> [a]
data LambdaCode' instr inp out where
- LambdaCode :: (forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => RemFail instr (inp ': '[]) (out ': '[]) -> LambdaCode' instr inp out
- LambdaCodeRec :: (forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => RemFail instr (inp ': ('TLambda inp out ': '[])) (out ': '[]) -> LambdaCode' instr inp out
data Value' instr t where
- VKey :: PublicKey -> Value' instr 'TKey
- VUnit :: Value' instr 'TUnit
- VSignature :: Signature -> Value' instr 'TSignature
- VChainId :: ChainId -> Value' instr 'TChainId
- VOption :: forall t instr. SingI t => Maybe (Value' instr t) -> Value' instr ('TOption t)
- VList :: forall t instr. SingI t => [Value' instr t] -> Value' instr ('TList t)
- VSet :: forall t instr. (SingI t, Comparable t) => Set (Value' instr t) -> Value' instr ('TSet t)
- VOp :: Operation' instr -> Value' instr 'TOperation
- VContract :: forall arg instr. (SingI arg, HasNoOp arg) => Address -> SomeEntrypointCallT arg -> Value' instr ('TContract arg)
- VTicket :: forall arg instr. Comparable arg => Address -> Value' instr arg -> Natural -> Value' instr ('TTicket arg)
- VPair :: forall l r instr. (Value' instr l, Value' instr r) -> Value' instr ('TPair l r)
- VOr :: forall l r instr. (SingI l, SingI r) => Either (Value' instr l) (Value' instr r) -> Value' instr ('TOr l r)
- VLam :: forall inp out instr. (SingI inp, SingI out, forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => LambdaCode' instr inp out -> Value' instr ('TLambda inp out)
- VMap :: forall k v instr. (SingI k, SingI v, Comparable k) => Map (Value' instr k) (Value' instr v) -> Value' instr ('TMap k v)
- VBigMap :: forall k v instr. (SingI k, SingI v, Comparable k, HasNoBigMap v) => Maybe Natural -> Map (Value' instr k) (Value' instr v) -> Value' instr ('TBigMap k v)
- VInt :: Integer -> Value' instr 'TInt
- VNat :: Natural -> Value' instr 'TNat
- VString :: MText -> Value' instr 'TString
- VBytes :: ByteString -> Value' instr 'TBytes
- VMutez :: Mutez -> Value' instr 'TMutez
- VBool :: Bool -> Value' instr 'TBool
- VKeyHash :: KeyHash -> Value' instr 'TKeyHash
- VTimestamp :: Timestamp -> Value' instr 'TTimestamp
- VAddress :: EpAddress -> Value' instr 'TAddress
- VBls12381Fr :: Bls12381Fr -> Value' instr 'TBls12381Fr
- VBls12381G1 :: Bls12381G1 -> Value' instr 'TBls12381G1
- VBls12381G2 :: Bls12381G2 -> Value' instr 'TBls12381G2
- VChest :: Chest -> Value' instr 'TChest
- VChestKey :: ChestKey -> Value' instr 'TChestKey
data RemFail (instr :: k -> k -> Type) (i :: k) (o :: k) where
- RfNormal :: instr i o -> RemFail instr i o
- RfAlwaysFails :: (forall o'. instr i o') -> RemFail instr i o
data Emit instr t = PackedValScope t => Emit {
- emTag :: Text
- emNotes :: Notes t
- emValue :: Value' instr t
- emCounter :: GlobalCounter
}
data CreateContract instr cp st = (forall i o. Show (instr i o), forall i o. Eq (instr i o)) => CreateContract {
- ccOriginator :: L1Address
- ccDelegate :: Maybe KeyHash
- ccBalance :: Mutez
- ccStorageVal :: Value' instr st
- ccContract :: Contract' instr cp st
- ccCounter :: GlobalCounter
}
data SetDelegate = SetDelegate {
- sdMbKeyHash :: Maybe KeyHash
- sdCounter :: GlobalCounter
}
data TransferTokens instr p = TransferTokens {
- ttTransferArgument :: Value' instr p
- ttAmount :: Mutez
- ttContract :: Value' instr ('TContract p)
- ttCounter :: GlobalCounter
}
data Operation' instr where
- OpTransferTokens :: ParameterScope p => TransferTokens instr p -> Operation' instr
- OpSetDelegate :: SetDelegate -> Operation' instr
- OpCreateContract :: (forall i o. Show (instr i o), forall i o. NFData (instr i o), Typeable instr, ParameterScope cp, StorageScope st) => CreateContract instr cp st -> Operation' instr
- OpEmit :: PackedValScope t => Emit instr t -> Operation' instr
rfMerge :: (forall o'. instr i1 o' -> instr i2 o' -> instr i3 o') -> RemFail instr i1 o -> RemFail instr i2 o -> RemFail instr i3 o
rfAnyInstr :: RemFail instr i o -> instr i o
rfMapAnyInstr :: (forall o'. instr i1 o' -> instr i2 o') -> RemFail instr i1 o -> RemFail instr i2 o
addressToVContract :: forall t instr kind. (ParameterScope t, ForbidOr t) => KindedAddress kind -> Value' instr ('TContract t)
buildVContract :: Value' instr ('TContract arg) -> Builder
compileEpLiftSequence :: EpLiftSequence arg param -> Value' instr arg -> Value' instr param
liftCallArg :: EntrypointCallT param arg -> Value' instr arg -> Value' instr param
valueTypeSanity :: Value' instr t -> Dict (SingI t)
mkVLam :: (SingI inp, SingI out, forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => (IsNotInView => RemFail instr '[inp] '[out]) -> Value' instr ('TLambda inp out)
mkVLamRec :: (SingI inp, SingI out, forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => (IsNotInView => RemFail instr '[inp, 'TLambda inp out] '[out]) -> Value' instr ('TLambda inp out)
withValueTypeSanity :: Value' instr t -> (SingI t => a) -> a
eqValueExt :: Value' instr t1 -> Value' instr t2 -> Bool
class EDivOp (n :: T) (m :: T) where
- type EDivOpRes n m :: T
- type EModOpRes n m :: T
- evalEDivOp :: Value' instr n -> Value' instr m -> Value' instr ('TOption ('TPair (EDivOpRes n m) (EModOpRes n m)))
class SliceOp (c :: T) where
- evalSlice :: Natural -> Natural -> Value' instr c -> Maybe (Value' instr c)
class ConcatOp (c :: T) where
- evalConcat :: Value' instr c -> Value' instr c -> Value' instr c
- evalConcat' :: [Value' instr c] -> Value' instr c
class GetOp (c :: T) where
- type GetOpKey c :: T
- type GetOpVal c :: T
- evalGet :: Value' instr (GetOpKey c) -> Value' instr c -> Maybe (Value' instr (GetOpVal c))
class UpdOp (c :: T) where
- type UpdOpKey c :: T
- type UpdOpParams c :: T
- evalUpd :: Value' instr (UpdOpKey c) -> Value' instr (UpdOpParams c) -> Value' instr c -> Value' instr c
class SizeOp (c :: T) where
- evalSize :: Value' instr c -> Int
class IterOp (c :: T) where
- type IterOpEl c :: T
- iterOpDetachOne :: Value' instr c -> (Maybe (Value' instr (IterOpEl c)), Value' instr c)
- iterOpNotes :: Notes c -> Notes (IterOpEl c)
class MapOp (c :: T) where
- type MapOpInp c :: T
- type MapOpRes c :: T -> T
- mapOpToList :: Value' instr c -> [Value' instr (MapOpInp c)]
- mapOpFromList :: SingI b => Value' instr c -> [Value' instr b] -> Value' instr (MapOpRes c b)
- mapOpNotes :: Notes c -> Notes (MapOpInp c)
class MemOp (c :: T) where
- type MemOpKey c :: T
- evalMem :: Value' instr (MemOpKey c) -> Value' instr c -> Bool
divMich :: Integral a => a -> a -> a
modMich :: Integral a => a -> a -> a
type Bls12381MulBadOrder a1 a2 = DelayError (((('Text "Multiplication of " :<>: 'ShowType a2) :<>: 'Text " and ") :<>: 'ShowType a1) :<>: 'Text " works only other way around")
data Ge
data Le
data Gt
data Lt
data Neq
data Eq'
data Compare
data Lsr
data Lsl
data Not
data Xor
data And
data Or
data Neg
data Abs
data EDiv
data Mul
data SubMutez
data Sub
data Add
class ToBytesArithOp (n :: T) where
- evalToBytesOp :: Value' instr n -> Value' instr 'TBytes
class ToIntArithOp (n :: T) where
- evalToIntOp :: Value' instr n -> Value' instr 'TInt
class UnaryArithOp aop (n :: T) where
- type UnaryArithRes aop n :: T
- evalUnaryArithOp :: proxy aop -> Value' instr n -> Value' instr (UnaryArithRes aop n)
data ArithError n m
- = MutezArithError MutezArithErrorType n m
- | ShiftArithError ShiftArithErrorType n m
data MutezArithErrorType
- = AddOverflow
- | MulOverflow
data ShiftArithErrorType
- = LslOverflow
- | LsrUnderflow
class (Typeable n, Typeable m) => ArithOp aop (n :: T) (m :: T) where
- type ArithRes aop n m :: T
- evalOp :: proxy aop -> Value' instr n -> Value' instr m -> Either (ArithError (Value' instr n) (Value' instr m)) (Value' instr (ArithRes aop n m))
- commutativityProof :: Maybe $ Dict (ArithRes aop n m ~ ArithRes aop m n, ArithOp aop m n)
compareOp :: Comparable t => Value' i t -> Value' i t -> Integer
evalToNatOp :: Value' instr 'TBytes -> Value' instr 'TNat
data SomeMeta where
- SomeMeta :: forall meta. With [NFData, Show, Typeable] meta => meta -> SomeMeta
data ExtInstr s
- = TEST_ASSERT (TestAssert s)
- | PRINT (PrintComment s)
- | DOC_ITEM SomeDocItem
- | COMMENT_ITEM CommentType
- | STACKTYPE StackTypePattern
data CommentType
- = FunctionStarts Text
- | FunctionEnds Text
- | StatementStarts Text
- | StatementEnds Text
- | JustComment Text
- | StackTypeComment (Maybe [T])
newtype PrintComment (st :: [T]) = PrintComment {
- unPrintComment :: [Either Text (StackRef st)]
}
data StackRef (st :: [T]) where
- StackRef :: RequireLongerThan st idx => PeanoNatural idx -> StackRef st
data TestAssert (s :: [T]) where
- TestAssert :: Text -> PrintComment inp -> Instr inp ('TBool ': out) -> TestAssert inp
data Instr (inp :: [T]) (out :: [T]) where
- WithLoc :: ErrorSrcPos -> Instr a b -> Instr a b
- Meta :: SomeMeta -> Instr a b -> Instr a b
- Seq :: Instr a b -> Instr b c -> Instr a c
- Nop :: Instr s s
- Ext :: ExtInstr s -> Instr s s
- Nested :: Instr inp out -> Instr inp out
- DocGroup :: DocGrouping -> Instr inp out -> Instr inp out
- AnnCAR :: Anns '[VarAnn, FieldAnn] -> Instr ('TPair a b ': s) (a ': s)
- AnnCDR :: Anns '[VarAnn, FieldAnn] -> Instr ('TPair a b ': s) (b ': s)
- DROP :: Instr (a ': s) s
- DROPN :: forall (n :: Peano) s. RequireLongerOrSameLength s n => PeanoNatural n -> Instr s (Drop n s)
- AnnDUP :: DupableScope a => AnnVar -> Instr (a ': s) (a ': (a ': s))
- AnnDUPN :: forall (n :: Peano) inp out a. (ConstraintDUPN n inp out a, DupableScope a) => AnnVar -> PeanoNatural n -> Instr inp out
- SWAP :: Instr (a ': (b ': s)) (b ': (a ': s))
- DIG :: forall (n :: Peano) inp out a. ConstraintDIG n inp out a => PeanoNatural n -> Instr inp out
- DUG :: forall (n :: Peano) inp out a. ConstraintDUG n inp out a => PeanoNatural n -> Instr inp out
- AnnPUSH :: forall t s. ConstantScope t => Anns '[VarAnn, Notes t] -> Value' Instr t -> Instr s (t ': s)
- AnnSOME :: Anns '[TypeAnn, VarAnn] -> Instr (a ': s) ('TOption a ': s)
- AnnNONE :: forall a s. SingI a => Anns '[TypeAnn, VarAnn, Notes a] -> Instr s ('TOption a ': s)
- AnnUNIT :: Anns '[TypeAnn, VarAnn] -> Instr s ('TUnit ': s)
- IF_NONE :: Instr s s' -> Instr (a ': s) s' -> Instr ('TOption a ': s) s'
- AnnPAIR :: Anns '[TypeAnn, VarAnn, FieldAnn, FieldAnn] -> Instr (a ': (b ': s)) ('TPair a b ': s)
- AnnUNPAIR :: Anns '[VarAnn, VarAnn, FieldAnn, FieldAnn] -> Instr ('TPair a b ': s) (a ': (b ': s))
- AnnPAIRN :: forall n inp. ConstraintPairN n inp => AnnVar -> PeanoNatural n -> Instr inp (PairN n inp)
- UNPAIRN :: forall (n :: Peano) (pair :: T) (s :: [T]). ConstraintUnpairN n pair => PeanoNatural n -> Instr (pair ': s) (UnpairN n pair ++ s)
- AnnLEFT :: SingI b => Anns '[TypeAnn, VarAnn, FieldAnn, FieldAnn, Notes b] -> Instr (a ': s) ('TOr a b ': s)
- AnnRIGHT :: SingI a => Anns '[TypeAnn, VarAnn, FieldAnn, FieldAnn, Notes a] -> Instr (b ': s) ('TOr a b ': s)
- IF_LEFT :: Instr (a ': s) s' -> Instr (b ': s) s' -> Instr ('TOr a b ': s) s'
- AnnNIL :: SingI p => Anns '[TypeAnn, VarAnn, Notes p] -> Instr s ('TList p ': s)
- AnnCONS :: AnnVar -> Instr (a ': ('TList a ': s)) ('TList a ': s)
- IF_CONS :: Instr (a ': ('TList a ': s)) s' -> Instr s s' -> Instr ('TList a ': s) s'
- AnnSIZE :: SizeOp c => AnnVar -> Instr (c ': s) ('TNat ': s)
- AnnEMPTY_SET :: (SingI e, Comparable e) => Anns '[TypeAnn, VarAnn, Notes e] -> Instr s ('TSet e ': s)
- AnnEMPTY_MAP :: (SingI a, SingI b, Comparable a) => Anns '[TypeAnn, VarAnn, Notes a, Notes b] -> Instr s ('TMap a b ': s)
- AnnEMPTY_BIG_MAP :: (SingI a, SingI b, Comparable a, HasNoBigMap b) => Anns '[TypeAnn, VarAnn, Notes a, Notes b] -> Instr s ('TBigMap a b ': s)
- AnnMAP :: (MapOp c, SingI b) => AnnVar -> Instr (MapOpInp c ': s) (b ': s) -> Instr (c ': s) (MapOpRes c b ': s)
- ITER :: IterOp c => Instr (IterOpEl c ': s) s -> Instr (c ': s) s
- AnnMEM :: MemOp c => AnnVar -> Instr (MemOpKey c ': (c ': s)) ('TBool ': s)
- AnnGET :: (GetOp c, SingI (GetOpVal c)) => AnnVar -> Instr (GetOpKey c ': (c ': s)) ('TOption (GetOpVal c) ': s)
- AnnGETN :: forall (ix :: Peano) (pair :: T) (s :: [T]). ConstraintGetN ix pair => AnnVar -> PeanoNatural ix -> Instr (pair ': s) (GetN ix pair ': s)
- AnnUPDATE :: UpdOp c => AnnVar -> Instr (UpdOpKey c ': (UpdOpParams c ': (c ': s))) (c ': s)
- AnnUPDATEN :: forall (ix :: Peano) (val :: T) (pair :: T) (s :: [T]). ConstraintUpdateN ix pair => AnnVar -> PeanoNatural ix -> Instr (val ': (pair ': s)) (UpdateN ix val pair ': s)
- AnnGET_AND_UPDATE :: (GetOp c, UpdOp c, SingI (GetOpVal c), UpdOpKey c ~ GetOpKey c) => AnnVar -> Instr (UpdOpKey c ': (UpdOpParams c ': (c ': s))) ('TOption (GetOpVal c) ': (c ': s))
- IF :: Instr s s' -> Instr s s' -> Instr ('TBool ': s) s'
- LOOP :: Instr s ('TBool ': s) -> Instr ('TBool ': s) s
- LOOP_LEFT :: Instr (a ': s) ('TOr a b ': s) -> Instr ('TOr a b ': s) (b ': s)
- AnnLAMBDA :: forall i o s. (SingI i, SingI o) => Anns '[VarAnn, Notes i, Notes o] -> RemFail Instr '[i] '[o] -> Instr s ('TLambda i o ': s)
- AnnLAMBDA_REC :: forall i o s. (SingI i, SingI o) => Anns '[VarAnn, Notes i, Notes o] -> RemFail Instr '[i, 'TLambda i o] '[o] -> Instr s ('TLambda i o ': s)
- AnnEXEC :: AnnVar -> Instr (t1 ': ('TLambda t1 t2 ': s)) (t2 ': s)
- AnnAPPLY :: forall a b c s. (ConstantScope a, SingI b) => AnnVar -> Instr (a ': ('TLambda ('TPair a b) c ': s)) ('TLambda b c ': s)
- DIP :: Instr a c -> Instr (b ': a) (b ': c)
- DIPN :: forall (n :: Peano) inp out s s'. ConstraintDIPN n inp out s s' => PeanoNatural n -> Instr s s' -> Instr inp out
- FAILWITH :: (SingI a, ConstantScope a) => Instr (a ': s) t
- AnnCAST :: forall a s. SingI a => Anns '[VarAnn, Notes a] -> Instr (a ': s) (a ': s)
- AnnRENAME :: AnnVar -> Instr (a ': s) (a ': s)
- AnnPACK :: PackedValScope a => AnnVar -> Instr (a ': s) ('TBytes ': s)
- AnnUNPACK :: (UnpackedValScope a, SingI a) => Anns '[TypeAnn, VarAnn, Notes a] -> Instr ('TBytes ': s) ('TOption a ': s)
- AnnCONCAT :: ConcatOp c => AnnVar -> Instr (c ': (c ': s)) (c ': s)
- AnnCONCAT' :: ConcatOp c => AnnVar -> Instr ('TList c ': s) (c ': s)
- AnnSLICE :: (SliceOp c, SingI c) => AnnVar -> Instr ('TNat ': ('TNat ': (c ': s))) ('TOption c ': s)
- AnnISNAT :: AnnVar -> Instr ('TInt ': s) ('TOption 'TNat ': s)
- AnnADD :: ArithOp Add n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Add n m ': s)
- AnnSUB :: ArithOp Sub n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Sub n m ': s)
- AnnSUB_MUTEZ :: AnnVar -> Instr ('TMutez ': ('TMutez ': s)) ('TOption 'TMutez ': s)
- AnnMUL :: ArithOp Mul n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Mul n m ': s)
- AnnEDIV :: ArithOp EDiv n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes EDiv n m ': s)
- AnnABS :: UnaryArithOp Abs n => AnnVar -> Instr (n ': s) (UnaryArithRes Abs n ': s)
- AnnNEG :: UnaryArithOp Neg n => AnnVar -> Instr (n ': s) (UnaryArithRes Neg n ': s)
- AnnLSL :: ArithOp Lsl n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Lsl n m ': s)
- AnnLSR :: ArithOp Lsr n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Lsr n m ': s)
- AnnOR :: ArithOp Or n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Or n m ': s)
- AnnAND :: ArithOp And n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes And n m ': s)
- AnnXOR :: ArithOp Xor n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Xor n m ': s)
- AnnNOT :: (SingI n, UnaryArithOp Not n) => AnnVar -> Instr (n ': s) (UnaryArithRes Not n ': s)
- AnnCOMPARE :: (Comparable n, SingI n) => AnnVar -> Instr (n ': (n ': s)) ('TInt ': s)
- AnnEQ :: UnaryArithOp Eq' n => AnnVar -> Instr (n ': s) (UnaryArithRes Eq' n ': s)
- AnnNEQ :: UnaryArithOp Neq n => AnnVar -> Instr (n ': s) (UnaryArithRes Neq n ': s)
- AnnLT :: UnaryArithOp Lt n => AnnVar -> Instr (n ': s) (UnaryArithRes Lt n ': s)
- AnnGT :: UnaryArithOp Gt n => AnnVar -> Instr (n ': s) (UnaryArithRes Gt n ': s)
- AnnLE :: UnaryArithOp Le n => AnnVar -> Instr (n ': s) (UnaryArithRes Le n ': s)
- AnnGE :: UnaryArithOp Ge n => AnnVar -> Instr (n ': s) (UnaryArithRes Ge n ': s)
- AnnINT :: ToIntArithOp n => AnnVar -> Instr (n ': s) ('TInt ': s)
- AnnBYTES :: ToBytesArithOp n => AnnVar -> Instr (n ': s) ('TBytes ': s)
- AnnNAT :: AnnVar -> Instr ('TBytes ': s) ('TNat ': s)
- AnnVIEW :: (SingI arg, ViewableScope ret) => Anns '[VarAnn, Notes ret] -> ViewName -> Instr (arg ': ('TAddress ': s)) ('TOption ret ': s)
- AnnSELF :: forall (arg :: T) s. (ParameterScope arg, IsNotInView) => AnnVar -> SomeEntrypointCallT arg -> Instr s ('TContract arg ': s)
- AnnCONTRACT :: ParameterScope p => Anns '[VarAnn, Notes p] -> EpName -> Instr ('TAddress ': s) ('TOption ('TContract p) ': s)
- AnnTRANSFER_TOKENS :: (ParameterScope p, IsNotInView) => AnnVar -> Instr (p ': ('TMutez ': ('TContract p ': s))) ('TOperation ': s)
- AnnSET_DELEGATE :: IsNotInView => AnnVar -> Instr ('TOption 'TKeyHash ': s) ('TOperation ': s)
- AnnCREATE_CONTRACT :: (ParameterScope p, StorageScope g, IsNotInView) => Anns '[VarAnn, VarAnn] -> Contract' Instr p g -> Instr ('TOption 'TKeyHash ': ('TMutez ': (g ': s))) ('TOperation ': ('TAddress ': s))
- AnnIMPLICIT_ACCOUNT :: AnnVar -> Instr ('TKeyHash ': s) ('TContract 'TUnit ': s)
- AnnNOW :: AnnVar -> Instr s ('TTimestamp ': s)
- AnnAMOUNT :: AnnVar -> Instr s ('TMutez ': s)
- AnnBALANCE :: AnnVar -> Instr s ('TMutez ': s)
- AnnVOTING_POWER :: AnnVar -> Instr ('TKeyHash ': s) ('TNat ': s)
- AnnTOTAL_VOTING_POWER :: AnnVar -> Instr s ('TNat ': s)
- AnnCHECK_SIGNATURE :: AnnVar -> Instr ('TKey ': ('TSignature ': ('TBytes ': s))) ('TBool ': s)
- AnnSHA256 :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
- AnnSHA512 :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
- AnnBLAKE2B :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
- AnnSHA3 :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
- AnnKECCAK :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
- AnnHASH_KEY :: AnnVar -> Instr ('TKey ': s) ('TKeyHash ': s)
- AnnPAIRING_CHECK :: AnnVar -> Instr ('TList ('TPair 'TBls12381G1 'TBls12381G2) ': s) ('TBool ': s)
- AnnSOURCE :: AnnVar -> Instr s ('TAddress ': s)
- AnnSENDER :: AnnVar -> Instr s ('TAddress ': s)
- AnnADDRESS :: AnnVar -> Instr ('TContract a ': s) ('TAddress ': s)
- AnnCHAIN_ID :: AnnVar -> Instr s ('TChainId ': s)
- AnnLEVEL :: AnnVar -> Instr s ('TNat ': s)
- AnnSELF_ADDRESS :: AnnVar -> Instr s ('TAddress ': s)
- NEVER :: Instr ('TNever ': s) t
- AnnTICKET_DEPRECATED :: Comparable a => AnnVar -> Instr (a ': ('TNat ': s)) ('TTicket a ': s)
- AnnTICKET :: Comparable a => AnnVar -> Instr (a ': ('TNat ': s)) ('TOption ('TTicket a) ': s)
- AnnREAD_TICKET :: AnnVar -> Instr ('TTicket a ': s) (RightComb ['TAddress, a, 'TNat] ': ('TTicket a ': s))
- AnnSPLIT_TICKET :: AnnVar -> Instr ('TTicket a ': ('TPair 'TNat 'TNat ': s)) ('TOption ('TPair ('TTicket a) ('TTicket a)) ': s)
- AnnJOIN_TICKETS :: AnnVar -> Instr ('TPair ('TTicket a) ('TTicket a) ': s) ('TOption ('TTicket a) ': s)
- AnnOPEN_CHEST :: AnnVar -> Instr ('TChestKey ': ('TChest ': ('TNat ': s))) ('TOr 'TBytes 'TBool ': s)
- AnnSAPLING_EMPTY_STATE :: AnnVar -> Sing n -> Instr s ('TSaplingState n ': s)
- AnnSAPLING_VERIFY_UPDATE :: AnnVar -> Instr ('TSaplingTransaction n ': ('TSaplingState n ': s)) ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) ': s)
- AnnMIN_BLOCK_TIME :: [AnyAnn] -> Instr s ('TNat ': s)
- AnnEMIT :: PackedValScope t => AnnVar -> FieldAnn -> Maybe (Notes t) -> Instr (t ': s) ('TOperation ': s)
- pattern NAT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TNat s) => Instr inp out
- pattern BYTES :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) 'TBytes s, ToBytesArithOp n) => Instr inp out
- pattern EMIT :: forall {inp} {out}. () => forall (t :: T) (s :: [T]). (inp ~ '(:) t s, out ~ '(:) 'TOperation s, PackedValScope t) => FieldAnn -> Maybe (Notes t) -> Instr inp out
- pattern MIN_BLOCK_TIME :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TNat s) => Instr inp out
- pattern SAPLING_VERIFY_UPDATE :: forall {inp} {out}. () => forall (n :: Peano) (s :: [T]). (inp ~ '(:) ('TSaplingTransaction n) ('(:) ('TSaplingState n) s), out ~ '(:) ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))) s) => Instr inp out
- pattern SAPLING_EMPTY_STATE :: forall {inp} {out}. () => forall (n :: Peano) (s :: [T]). (inp ~ s, out ~ '(:) ('TSaplingState n) s) => Sing n -> Instr inp out
- pattern OPEN_CHEST :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TChestKey ('(:) 'TChest ('(:) 'TNat s)), out ~ '(:) ('TOr 'TBytes 'TBool) s) => Instr inp out
- pattern JOIN_TICKETS :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TPair ('TTicket a) ('TTicket a)) s, out ~ '(:) ('TOption ('TTicket a)) s) => Instr inp out
- pattern SPLIT_TICKET :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TTicket a) ('(:) ('TPair 'TNat 'TNat) s), out ~ '(:) ('TOption ('TPair ('TTicket a) ('TTicket a))) s) => Instr inp out
- pattern READ_TICKET :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TTicket a) s, out ~ '(:) (RightComb ('(:) 'TAddress ('(:) a ('(:) 'TNat ('[] :: [T]))))) ('(:) ('TTicket a) s)) => Instr inp out
- pattern TICKET_DEPRECATED :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a ('(:) 'TNat s), out ~ '(:) ('TTicket a) s, Comparable a) => Instr inp out
- pattern TICKET :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a ('(:) 'TNat s), out ~ '(:) ('TOption ('TTicket a)) s, Comparable a) => Instr inp out
- pattern SELF_ADDRESS :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TAddress s) => Instr inp out
- pattern LEVEL :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TNat s) => Instr inp out
- pattern CHAIN_ID :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TChainId s) => Instr inp out
- pattern ADDRESS :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TContract a) s, out ~ '(:) 'TAddress s) => Instr inp out
- pattern SENDER :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TAddress s) => Instr inp out
- pattern SOURCE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TAddress s) => Instr inp out
- pattern PAIRING_CHECK :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) ('TList ('TPair 'TBls12381G1 'TBls12381G2)) s, out ~ '(:) 'TBool s) => Instr inp out
- pattern HASH_KEY :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKey s, out ~ '(:) 'TKeyHash s) => Instr inp out
- pattern KECCAK :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
- pattern SHA3 :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
- pattern BLAKE2B :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
- pattern CHECK_SIGNATURE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKey ('(:) 'TSignature ('(:) 'TBytes s)), out ~ '(:) 'TBool s) => Instr inp out
- pattern TOTAL_VOTING_POWER :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TNat s) => Instr inp out
- pattern VOTING_POWER :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKeyHash s, out ~ '(:) 'TNat s) => Instr inp out
- pattern BALANCE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TMutez s) => Instr inp out
- pattern AMOUNT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TMutez s) => Instr inp out
- pattern NOW :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TTimestamp s) => Instr inp out
- pattern IMPLICIT_ACCOUNT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKeyHash s, out ~ '(:) ('TContract 'TUnit) s) => Instr inp out
- pattern CREATE_CONTRACT :: forall {inp} {out}. () => forall (p :: T) (g :: T) (s :: [T]). (inp ~ '(:) ('TOption 'TKeyHash) ('(:) 'TMutez ('(:) g s)), out ~ '(:) 'TOperation ('(:) 'TAddress s), ParameterScope p, StorageScope g, IsNotInView) => Contract' Instr p g -> Instr inp out
- pattern SET_DELEGATE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) ('TOption 'TKeyHash) s, out ~ '(:) 'TOperation s, IsNotInView) => Instr inp out
- pattern TRANSFER_TOKENS :: forall {inp} {out}. () => forall (p :: T) (s :: [T]). (inp ~ '(:) p ('(:) 'TMutez ('(:) ('TContract p) s)), out ~ '(:) 'TOperation s, ParameterScope p, IsNotInView) => Instr inp out
- pattern CONTRACT :: forall {inp} {out}. () => forall (p :: T) (s :: [T]). (inp ~ '(:) 'TAddress s, out ~ '(:) ('TOption ('TContract p)) s, ParameterScope p) => EpName -> Instr inp out
- pattern SELF :: forall {inp} {out}. () => forall (arg :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TContract arg) s, ParameterScope arg, IsNotInView) => SomeEntrypointCallT arg -> Instr inp out
- pattern VIEW :: forall {inp} {out}. () => forall (arg :: T) (ret :: T) (s :: [T]). (inp ~ '(:) arg ('(:) 'TAddress s), out ~ '(:) ('TOption ret) s, SingI arg, ViewableScope ret) => ViewName -> Instr inp out
- pattern INT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) 'TInt s, ToIntArithOp n) => Instr inp out
- pattern NEQ :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Neq n) s, UnaryArithOp Neq n) => Instr inp out
- pattern COMPARE :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n ('(:) n s), out ~ '(:) 'TInt s, Comparable n, SingI n) => Instr inp out
- pattern NOT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Not n) s, SingI n, UnaryArithOp Not n) => Instr inp out
- pattern XOR :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Xor n m) s, ArithOp Xor n m) => Instr inp out
- pattern AND :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes And n m) s, ArithOp And n m) => Instr inp out
- pattern OR :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Or n m) s, ArithOp Or n m) => Instr inp out
- pattern LSR :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Lsr n m) s, ArithOp Lsr n m) => Instr inp out
- pattern LSL :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Lsl n m) s, ArithOp Lsl n m) => Instr inp out
- pattern NEG :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Neg n) s, UnaryArithOp Neg n) => Instr inp out
- pattern ABS :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Abs n) s, UnaryArithOp Abs n) => Instr inp out
- pattern EDIV :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes EDiv n m) s, ArithOp EDiv n m) => Instr inp out
- pattern MUL :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Mul n m) s, ArithOp Mul n m) => Instr inp out
- pattern SUB_MUTEZ :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TMutez ('(:) 'TMutez s), out ~ '(:) ('TOption 'TMutez) s) => Instr inp out
- pattern SUB :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Sub n m) s, ArithOp Sub n m) => Instr inp out
- pattern ADD :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Add n m) s, ArithOp Add n m) => Instr inp out
- pattern ISNAT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TInt s, out ~ '(:) ('TOption 'TNat) s) => Instr inp out
- pattern SLICE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) 'TNat ('(:) 'TNat ('(:) c s)), out ~ '(:) ('TOption c) s, SliceOp c, SingI c) => Instr inp out
- pattern CONCAT' :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) ('TList c) s, out ~ '(:) c s, ConcatOp c) => Instr inp out
- pattern CONCAT :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) c ('(:) c s), out ~ '(:) c s, ConcatOp c) => Instr inp out
- pattern UNPACK :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) ('TOption a) s, UnpackedValScope a, SingI a) => Instr inp out
- pattern PACK :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) 'TBytes s, PackedValScope a) => Instr inp out
- pattern RENAME :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) a s) => Instr inp out
- pattern CAST :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) a s, SingI a) => Instr inp out
- pattern APPLY :: forall {inp} {out}. () => forall (a :: T) (b :: T) (c :: T) (s :: [T]). (inp ~ '(:) a ('(:) ('TLambda ('TPair a b) c) s), out ~ '(:) ('TLambda b c) s, ConstantScope a, SingI b) => Instr inp out
- pattern EXEC :: forall {inp} {out}. () => forall (t1 :: T) (t2 :: T) (s :: [T]). (inp ~ '(:) t1 ('(:) ('TLambda t1 t2) s), out ~ '(:) t2 s) => Instr inp out
- pattern LAMBDA_REC :: forall s r. () => forall i o. (SingI i, SingI o, r ~ ('TLambda i o ': s)) => (IsNotInView => RemFail Instr '[i, 'TLambda i o] '[o]) -> Instr s r
- pattern LAMBDA :: forall s r. () => forall i o. (SingI i, SingI o, r ~ ('TLambda i o ': s)) => (IsNotInView => RemFail Instr '[i] '[o]) -> Instr s r
- pattern GET_AND_UPDATE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (UpdOpKey c) ('(:) (UpdOpParams c) ('(:) c s)), out ~ '(:) ('TOption (GetOpVal c)) ('(:) c s), GetOp c, UpdOp c, SingI (GetOpVal c), (~) (UpdOpKey c) (GetOpKey c)) => Instr inp out
- pattern UPDATEN :: forall {inp} {out}. () => forall (ix :: Peano) (val :: T) (pair :: T) (s :: [T]). (inp ~ '(:) val ('(:) pair s), out ~ '(:) (UpdateN ix val pair) s, ConstraintUpdateN ix pair) => PeanoNatural ix -> Instr inp out
- pattern UPDATE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (UpdOpKey c) ('(:) (UpdOpParams c) ('(:) c s)), out ~ '(:) c s, UpdOp c) => Instr inp out
- pattern GETN :: forall {inp} {out}. () => forall (ix :: Peano) (pair :: T) (s :: [T]). (inp ~ '(:) pair s, out ~ '(:) (GetN ix pair) s, ConstraintGetN ix pair) => PeanoNatural ix -> Instr inp out
- pattern GET :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (GetOpKey c) ('(:) c s), out ~ '(:) ('TOption (GetOpVal c)) s, GetOp c, SingI (GetOpVal c)) => Instr inp out
- pattern MEM :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (MemOpKey c) ('(:) c s), out ~ '(:) 'TBool s, MemOp c) => Instr inp out
- pattern MAP :: forall {inp} {out}. () => forall (c :: T) (b :: T) (s :: [T]). (inp ~ '(:) c s, out ~ '(:) (MapOpRes c b) s, MapOp c, SingI b) => Instr ('(:) (MapOpInp c) s) ('(:) b s) -> Instr inp out
- pattern EMPTY_BIG_MAP :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TBigMap a b) s, SingI a, SingI b, Comparable a, HasNoBigMap b) => Instr inp out
- pattern EMPTY_MAP :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TMap a b) s, SingI a, SingI b, Comparable a) => Instr inp out
- pattern EMPTY_SET :: forall {inp} {out}. () => forall (e :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TSet e) s, SingI e, Comparable e) => Instr inp out
- pattern SIZE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) c s, out ~ '(:) 'TNat s, SizeOp c) => Instr inp out
- pattern CONS :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a ('(:) ('TList a) s), out ~ '(:) ('TList a) s) => Instr inp out
- pattern NIL :: forall {inp} {out}. () => forall (p :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TList p) s, SingI p) => Instr inp out
- pattern RIGHT :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) b s, out ~ '(:) ('TOr a b) s, SingI a) => Instr inp out
- pattern LEFT :: forall {inp} {out}. () => forall (b :: T) (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) ('TOr a b) s, SingI b) => Instr inp out
- pattern PAIRN :: forall {inp} {out}. () => forall (n :: Peano) (inp :: [T]). (inp ~ inp, out ~ PairN n inp, ConstraintPairN n inp) => PeanoNatural n -> Instr inp out
- pattern UNPAIR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) ('TPair a b) s, out ~ '(:) a ('(:) b s)) => Instr inp out
- pattern PAIR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) a ('(:) b s), out ~ '(:) ('TPair a b) s) => Instr inp out
- pattern UNIT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TUnit s) => Instr inp out
- pattern SOME :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) ('TOption a) s) => Instr inp out
- pattern PUSH :: forall {inp} {out}. () => forall (t :: T) (s :: [T]). (inp ~ s, out ~ '(:) t s, ConstantScope t) => Value' Instr t -> Instr inp out
- pattern DUPN :: forall {inp} {out}. () => forall (n :: Peano) (inp :: [T]) (out :: [T]) (a :: T). (inp ~ inp, out ~ out, ConstraintDUPN n inp out a, DupableScope a) => PeanoNatural n -> Instr inp out
- pattern DUP :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) a ('(:) a s), DupableScope a) => Instr inp out
- pattern CDR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) ('TPair a b) s, out ~ '(:) b s) => Instr inp out
- pattern CAR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) ('TPair a b) s, out ~ '(:) a s) => Instr inp out
- pattern GE :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Ge n) s, UnaryArithOp Ge n) => Instr inp out
- pattern SHA256 :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
- pattern SHA512 :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
- pattern LE :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Le n) s, UnaryArithOp Le n) => Instr inp out
- pattern NONE :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TOption a) s, SingI a) => Instr inp out
- pattern GT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Gt n) s, UnaryArithOp Gt n) => Instr inp out
- pattern LT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Lt n) s, UnaryArithOp Lt n) => Instr inp out
- pattern EQ :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Eq' n) s, UnaryArithOp Eq' n) => Instr inp out
pattern ConcreteMeta :: Typeable meta => meta -> Instr i o -> Instr i o
pattern (:#) :: Instr a b -> Instr b c -> Instr a c
castInstr :: forall inp1 out1 inp2 out2. (SingI inp1, SingI out1, SingI inp2, SingI out2) => Instr inp1 out1 -> Maybe (Instr inp2 out2)
mkStackRef :: forall (gn :: Nat) st n. (n ~ ToPeano gn, SingIPeano gn, RequireLongerThan st n) => StackRef st
frameInstr :: forall s a b. Instr a b -> Instr (a ++ s) (b ++ s)
type SomeViewsSet = SomeViewsSet' Instr
type ViewsSet = ViewsSet' Instr
type SomeView = SomeView' Instr
type View = View' Instr
type ViewCode arg st ret = ViewCode' Instr arg st ret
type Contract = Contract' Instr
type ContractCode cp st = ContractCode' Instr cp st
type Operation = Operation' Instr
type Value = Value' Instr
data SomeAnns where
- SomeAnns :: Anns xs -> SomeAnns
- SomeUncheckedAnns :: NonEmpty AnyAnn -> SomeAnns
data PushableStorageSplit s st where
- ConstantStorage :: ConstantScope st => Value st -> PushableStorageSplit s st
- PushableValueStorage :: StorageScope st => Instr s (st ': s) -> PushableStorageSplit s st
- PartlyPushableStorage :: (StorageScope heavy, StorageScope st) => Value heavy -> Instr (heavy ': s) (st ': s) -> PushableStorageSplit s st
data CtorEffectsApp m = CtorEffectsApp {
- ceaName :: Text
- ceaPostStep :: forall i o. Monad m => Instr i o -> m (Instr i o) -> m (Instr i o)
}
data DfsSettings m = DfsSettings {
- dsGoToValues :: Bool
- dsCtorEffectsApp :: CtorEffectsApp m
- dsInstrStep :: forall i o. Instr i o -> m (Instr i o)
- dsValueStep :: forall t'. Value t' -> m (Value t')
}
dfsTraverseInstr :: forall m inp out. Monad m => DfsSettings m -> Instr inp out -> m (Instr inp out)
dfsFoldInstr :: forall x inp out. Monoid x => DfsSettings (Writer x) -> (forall i o. Instr i o -> x) -> Instr inp out -> x
dfsModifyInstr :: DfsSettings Identity -> (forall i o. Instr i o -> Instr i o) -> Instr inp out -> Instr inp out
analyzeInstrFailure :: Instr i o -> RemFail Instr i o
linearizeLeft :: Instr inp out -> Instr inp out
linearizeLeftDeep :: Instr inp out -> Instr inp out
dfsMapValue :: forall t. DfsSettings Identity -> Value t -> Value t
dfsTraverseValue :: forall t m. Monad m => DfsSettings m -> Value t -> m (Value t)
dfsFoldMapValue :: Monoid x => (forall t'. Value t' -> x) -> Value t -> x
dfsFoldMapValueM :: (Monoid x, Monad m) => (forall t'. Value t' -> m x) -> Value t -> m x
isStringValue :: Value t -> Maybe MText
isBytesValue :: Value t -> Maybe ByteString
allAtomicValues :: forall t a. (forall t'. Value t' -> Maybe a) -> Value t -> [a]
splitPushableStorage :: StorageScope t => Value t -> PushableStorageSplit s t
isMichelsonInstr :: Instr i o -> Bool
instrAnns :: Instr i o -> Maybe SomeAnns
class IsoValuesStack (ts :: [Type]) where
- toValStack :: Rec Identity ts -> Rec Value (ToTs ts)
- fromValStack :: Rec Value (ToTs ts) -> Rec Identity ts
type family ToTs' t where ...
type family ToTs (ts :: [Type]) :: [T] where ...
type GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t))
class ToBigMap m where
- type ToBigMapKey m
- type ToBigMapValue m
- mkBigMap :: m -> BigMap (ToBigMapKey m) (ToBigMapValue m)
data BigMap k v
newtype BigMapId k v = BigMapId {
- unBigMapId :: Natural
}
data Ticket (arg :: Type) = Ticket {
- tTicketer :: Address
- tData :: arg
- tAmount :: Natural
}
data ContractRef (arg :: Type) = ContractRef {
- crAddress :: Address
- crEntrypoint :: SomeEntrypointCall arg
}
type HasNoOpToT a = (IsoValue a, HasNoOp (ToT a))
type WellTypedToT a = (IsoValue a, WellTyped (ToT a))
type SomeEntrypointCall arg = SomeEntrypointCallT (ToT arg)
type EntrypointCall param arg = EntrypointCallT (ToT param) (ToT arg)
type family ToT' t where ...
class WellTypedToT a => IsoValue a where
- type ToT a :: T
- toVal :: a -> Value (ToT a)
- fromVal :: Value (ToT a) -> a
type KnownIsoT a = (IsoValue a, SingI (ToT a))
isoValue :: (IsoValue a, IsoValue b) => Iso (Value (ToT a)) (Value (ToT b)) a b
coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b
contractRefToAddr :: ContractRef cp -> EpAddress
totsKnownLemma :: forall s. KnownList s :- KnownList (ToTs s)
totsAppendLemma :: forall a b. KnownList a => Dict (ToTs (a ++ b) ~ (ToTs a ++ ToTs b))
type InstrUnwrapC dt name = (GenericIsoValue dt, GInstrUnwrap (Rep dt) (LnrBranch (GetNamed name dt)) (CtorOnlyField name dt))
type family GCaseBranchInput ctor x :: CaseClauseParam
type family GCaseBranchInput ctor x :: CaseClauseParam
type family GCaseClauses x rest :: [CaseClauseParam]
type family GCaseClauses x rest :: [CaseClauseParam]
type CaseClauses a = GCaseClauses (Rep a) '[]
data CaseClause (inp :: [T]) (out :: [T]) (param :: CaseClauseParam) where
- CaseClause :: RemFail Instr (AppendCtorField x inp) out -> CaseClause inp out ('CaseClauseParam ctor x)
data CaseClauseParam = CaseClauseParam Symbol CtorField
type InstrCaseC dt = (GenericIsoValue dt, GInstrCase (Rep dt) '[])
data MyCompoundType
type InstrWrapOneC dt name = (InstrWrapC dt name, GetCtorField dt name ~ 'OneField (CtorOnlyField name dt))
type InstrWrapC dt name = (GenericIsoValue dt, GInstrWrap (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)))
type CtorOnlyField name dt = RequireOneField name (GetCtorField dt name)
type CtorHasOnlyField ctor dt f = GetCtorField dt ctor ~ 'OneField f
type GetCtorField dt ctor = LnrFieldType (GetNamed ctor dt)
type family IsPrimitiveValue (x :: Type) :: Bool where ...
type AppendCtorFieldAxiom (cf :: CtorField) (st :: [Type]) = ToTs (AppendCtorField cf st) ~ AppendCtorField cf (ToTs st)
type family AppendCtorField cf l where ...
type family ExtractCtorField (cf :: CtorField) where ...
data CtorField
- = OneField Type
- | NoFields
appendCtorFieldAxiom :: (AppendCtorFieldAxiom ('OneField Word) '[Int], AppendCtorFieldAxiom 'NoFields '[Int]) => Dict (AppendCtorFieldAxiom cf st)
instrWrap :: forall dt name st. InstrWrapC dt name => Label name -> Instr (AppendCtorField (GetCtorField dt name) st) (ToT dt ': st)
instrWrapOne :: forall dt name st. InstrWrapOneC dt name => Label name -> Instr (ToT (CtorOnlyField name dt) ': st) (ToT dt ': st)
hsWrap :: forall dt name. InstrWrapC dt name => Label name -> ExtractCtorField (GetCtorField dt name) -> dt
instrCase :: forall dt out inp. InstrCaseC dt => Rec (CaseClause inp out) (CaseClauses dt) -> RemFail Instr (ToT dt ': inp) out
(//->) :: Label ("c" `AppendSymbol` ctor) -> RemFail Instr (AppendCtorField x inp) out -> CaseClause inp out ('CaseClauseParam ctor x)
unsafeInstrUnwrap :: forall dt name st. InstrUnwrapC dt name => Label name -> Instr (ToT dt ': st) (ToT (CtorOnlyField name dt) ': st)
hsUnwrap :: forall dt name. InstrUnwrapC dt name => Label name -> dt -> Maybe (CtorOnlyField name dt)
type InstrDeconstructC dt st = (GenericIsoValue dt, GInstrDeconstruct (Rep dt) '[] st)
type family GFieldTypes x rest :: [Type]
type family GFieldTypes x rest :: [Type]
type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep dt) '[])
type ConstructorFieldNames dt = GFieldNames (Rep dt)
type ConstructorFieldTypes dt = GFieldTypes (Rep dt) '[]
class ToTs xs ~ ToTs ys => CastFieldConstructors xs ys where
- castFieldConstructorsImpl :: Rec (FieldConstructor st) xs -> Rec (FieldConstructor st) ys
newtype FieldConstructor (st :: [k]) (field :: Type) = FieldConstructor (Instr (ToTs' st) (ToT field ': ToTs' st))
type InstrSetFieldC dt name = (GenericIsoValue dt, GInstrSetField name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)))
type InstrGetFieldC dt name = (GenericIsoValue dt, GInstrGet name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)))
type GetFieldType dt name = LnrFieldType (GetNamed name dt)
type family GLookupNamed (name :: Symbol) (x :: Type -> Type) :: Maybe LookupNamedResult where ...
instrToField :: forall dt name st. InstrGetFieldC dt name => Label name -> Instr (ToT dt ': st) (ToT (GetFieldType dt name) ': st)
instrGetField :: forall dt name st. (InstrGetFieldC dt name, DupableScope (ToT (GetFieldType dt name))) => Label name -> Instr (ToT dt ': st) (ToT (GetFieldType dt name) ': (ToT dt ': st))
instrGetFieldOpen :: forall dt name res st. InstrGetFieldC dt name => Instr '[ToT (GetFieldType dt name)] '[res, ToT (GetFieldType dt name)] -> Instr '[ToT (GetFieldType dt name)] '[res] -> Label name -> Instr (ToT dt ': st) (res ': (ToT dt ': st))
instrSetField :: forall dt name st. InstrSetFieldC dt name => Label name -> Instr (ToT (GetFieldType dt name) ': (ToT dt ': st)) (ToT dt ': st)
instrSetFieldOpen :: forall dt name new st. InstrSetFieldC dt name => Instr '[new, ToT (GetFieldType dt name)] '[ToT (GetFieldType dt name)] -> Label name -> Instr (new ': (ToT dt ': st)) (ToT dt ': st)
instrConstruct :: forall dt st. InstrConstructC dt => Rec (FieldConstructor st) (ConstructorFieldTypes dt) -> Instr st (ToT dt ': st)
instrConstructStack :: forall dt stack st. (InstrConstructC dt, stack ~ ToTs (ConstructorFieldTypes dt)) => Instr (stack ++ st) (ToT dt ': st)
instrDeconstruct :: forall dt stack (st :: [T]). (InstrDeconstructC dt st, stack ~ ToTs (GFieldTypes (Rep dt) '[])) => Instr (ToT dt ': st) (stack ++ st)
convertParamNotes :: ParamNotes cp -> ParameterType
convertContractCode :: forall param store. (SingI param, SingI store) => ContractCode param store -> Contract
convertView :: forall arg store ret. View arg store ret -> View
convertSomeView :: SomeView st -> View
convertContract :: Contract param store -> Contract
untypeValue :: HasNoOp t => Value' Instr t -> Value
untypeValueHashable :: HasNoOp t => Value' Instr t -> Value
untypeValueOptimized :: HasNoOp t => Value' Instr t -> Value
untypeDemoteT :: forall (t :: T). SingI t => Ty
instrToOpsOptimized :: HasCallStack => Instr inp out -> [ExpandedOp]
instrToOps :: HasCallStack => Instr inp out -> [ExpandedOp]
eqInstrExt :: Instr i1 o1 -> Instr i2 o2 -> Bool
sampleTypedValue :: forall t. WellTyped t => Sing t -> Maybe (Value t)
flattenEntrypoints :: HandleImplicitDefaultEp -> ParamNotes t -> Map EpName Ty
data SomeVBigMap where
- SomeVBigMap :: forall k v. Value ('TBigMap k v) -> SomeVBigMap
data SomeContractAndStorage where
- SomeContractAndStorage :: forall cp st. (StorageScope st, ParameterScope cp) => Contract cp st -> Value st -> SomeContractAndStorage
data SomeContract where
- SomeContract :: Contract cp st -> SomeContract
data SomeIsoValue where
- SomeIsoValue :: KnownIsoT a => a -> SomeIsoValue
type SomePackedVal = SomeConstrainedValue PackedValScope
type SomeStorage = SomeConstrainedValue StorageScope
type SomeConstant = SomeConstrainedValue ConstantScope
type SomeValue = SomeConstrainedValue SingI
type SomeConstrainedValue c = Constrained c Value
type LooseSumC dt = (Generic dt, GLooseSum (Rep dt))
data ComposeResult a
- = ComposeOk a
- | ComposeCtorNotFound
- | ComposeFieldTypeMismatch T T
toTaggedVal :: LooseSumC dt => dt -> (Text, SomeValue)
fromTaggedVal :: LooseSumC dt => (Text, SomeValue) -> ComposeResult dt
data SomeAnnotatedValue where
- SomeAnnotatedValue :: forall t. SingI t => Notes t -> Value t -> SomeAnnotatedValue
data AnnotatedValue v = AnnotatedValue {
- avNotes :: Notes (ToT v)
- avValue :: Value (ToT v)
}
data FieldRep a = FieldRep {
- frName :: Maybe Text
- frDescription :: Maybe Text
- frTypeRep :: a
}
data ConstructorRep a = ConstructorRep {
- crName :: Text
- crDescription :: Maybe Text
- crFields :: [FieldRep a]
}
type ADTRep a = [ConstructorRep a]
crDescriptionL :: forall a. Lens' (ConstructorRep a) (Maybe Text)
crFieldsL :: forall a a. Lens (ConstructorRep a) (ConstructorRep a) [FieldRep a] [FieldRep a]
crNameL :: forall a. Lens' (ConstructorRep a) Text
type PolyTypeHasDocC ts = Each '[TypeHasDoc] ts
class GProductHasDoc (x :: Type -> Type)
class GTypeHasDoc (x :: Type -> Type)
class IsHomomorphic a
class HaveCommonTypeCtor a b
newtype DStorageType = DStorageType DType
data DType where
- DType :: TypeHasDoc a => Proxy a -> DType
data SomeTypeWithDoc where
- SomeTypeWithDoc :: TypeHasDoc td => Proxy td -> SomeTypeWithDoc
type TypeDocMichelsonRep a = Proxy a -> (Maybe DocTypeRepLHS, T)
type TypeDocHaskellRep a = Proxy a -> FieldDescriptionsV -> Maybe (Maybe DocTypeRepLHS, ADTRep SomeTypeWithDoc)
class (Typeable a, SingI (TypeDocFieldDescriptions a), FieldDescriptionsValid (TypeDocFieldDescriptions a) a) => TypeHasDoc a where
- type TypeDocFieldDescriptions a :: FieldDescriptions
- typeDocName :: Proxy a -> Text
- typeDocMdDescription :: Markdown
- typeDocMdReference :: Proxy a -> WithinParens -> Markdown
- typeDocDependencies :: Proxy a -> [SomeDocDefinitionItem]
- typeDocHaskellRep :: TypeDocHaskellRep a
- typeDocMichelsonRep :: TypeDocMichelsonRep a
data FieldSnakeCase
data FieldCamelCase
class TypeHasFieldNamingStrategy a where
- typeFieldNamingStrategy :: Text -> Text
newtype WithinParens = WithinParens Bool
frDescriptionL :: forall a. Lens' (FieldRep a) (Maybe Text)
frNameL :: forall a. Lens' (FieldRep a) (Maybe Text)
frTypeRepL :: forall a a. Lens (FieldRep a) (FieldRep a) a a
buildADTRep :: forall a. (WithinParens -> a -> Markdown) -> ADTRep a -> Markdown
applyWithinParens :: WithinParens -> Markdown -> Markdown
buildTypeWithinParens :: forall a. Typeable a => WithinParens -> Markdown
typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder
dTypeDep :: forall (t :: Type). TypeHasDoc t => SomeDocDefinitionItem
dTypeDepP :: forall (t :: Type). TypeHasDoc t => Proxy t -> SomeDocDefinitionItem
dStorage :: forall store. TypeHasDoc store => DStorageType
customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown
customTypeDocMdReference' :: (Text, DType) -> [WithinParens -> Markdown] -> WithinParens -> Markdown
homomorphicTypeDocMdReference :: forall (t :: Type). (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown
poly1TypeDocMdReference :: forall t (r :: Type) (a :: Type). (r ~ t a, Typeable t, Each '[TypeHasDoc] [r, a], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown
poly2TypeDocMdReference :: forall t (r :: Type) (a :: Type) (b :: Type). (r ~ t a b, Typeable t, Each '[TypeHasDoc] [r, a, b], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown
genericTypeDocDependencies :: forall a. (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem]
homomorphicTypeDocHaskellRep :: forall a. (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a
concreteTypeDocHaskellRep :: forall a b. (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b
unsafeConcreteTypeDocHaskellRep :: forall a b. (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b
haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepMap :: (Text -> Text) -> TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepStripFieldPrefix :: TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepAdjust :: (Maybe Text -> Maybe Text) -> TypeDocHaskellRep a -> TypeDocHaskellRep a
homomorphicTypeDocMichelsonRep :: forall a. KnownIsoT a => TypeDocMichelsonRep a
concreteTypeDocMichelsonRep :: forall a b. (Typeable a, KnownIsoT a, HaveCommonTypeCtor b a) => TypeDocMichelsonRep b
unsafeConcreteTypeDocMichelsonRep :: forall a b. (Typeable a, KnownIsoT a) => TypeDocMichelsonRep b
docInstr :: DocItem di => di -> Instr s s
cutInstrNonDoc :: (forall i o. Instr i o -> Instr i o) -> Instr inp out -> Instr s s

Documentation

withDict :: HasDict c e => e -> (c => r) -> r #

From a Dict, takes a value in an environment where the instance witnessed by the Dict is in scope, and evaluates it.

Essentially a deconstruction of a Dict into its continuation-style form.

Can also be used to deconstruct an entailment, a :- b, using a context a.

withDict :: Dict c -> (c => r) -> r
withDict :: a => (a :- c) -> (c => r) -> r

data Dict a where #

Values of type Dict p capture a dictionary for a constraint of type p.

e.g.

Dict :: Dict (Eq Int)

captures a dictionary that proves we have an:

instance Eq Int

Pattern matching on the Dict constructor will bring this instance into scope.

Constructors

Dict :: forall a. a => Dict a

Instances

Instances details

() :=> (Semigroup (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup (Dict a) #
() :=> (Show (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Show (Dict a) #
() :=> (Eq (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Eq (Dict a) #
() :=> (Ord (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Ord (Dict a) #
a :=> (Monoid (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Monoid (Dict a) #
a :=> (Bounded (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Bounded (Dict a) #
a :=> (Enum (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Enum (Dict a) #
a :=> (Read (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Read (Dict a) #
HasDict a (Dict a)
Instance details Defined in Data.Constraint Methods evidence :: Dict a -> Dict a #
(Typeable p, p) => Data (Dict p)
Instance details Defined in Data.Constraint Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dict p -> c (Dict p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dict p) # toConstr :: Dict p -> Constr # dataTypeOf :: Dict p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dict p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dict p)) # gmapT :: (forall b. Data b => b -> b) -> Dict p -> Dict p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r # gmapQ :: (forall d. Data d => d -> u) -> Dict p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dict p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p) #
a => Monoid (Dict a)
Instance details Defined in Data.Constraint Methods mempty :: Dict a # mappend :: Dict a -> Dict a -> Dict a # mconcat :: [Dict a] -> Dict a #
Semigroup (Dict a)
Instance details Defined in Data.Constraint Methods (<>) :: Dict a -> Dict a -> Dict a # sconcat :: NonEmpty (Dict a) -> Dict a # stimes :: Integral b => b -> Dict a -> Dict a #
a => Bounded (Dict a)
Instance details Defined in Data.Constraint Methods minBound :: Dict a # maxBound :: Dict a #
a => Enum (Dict a)
Instance details Defined in Data.Constraint Methods succ :: Dict a -> Dict a # pred :: Dict a -> Dict a # toEnum :: Int -> Dict a # fromEnum :: Dict a -> Int # enumFrom :: Dict a -> [Dict a] # enumFromThen :: Dict a -> Dict a -> [Dict a] # enumFromTo :: Dict a -> Dict a -> [Dict a] # enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a] #
a => Read (Dict a)
Instance details Defined in Data.Constraint Methods readsPrec :: Int -> ReadS (Dict a) # readList :: ReadS [Dict a] # readPrec :: ReadPrec (Dict a) # readListPrec :: ReadPrec [Dict a] #
Show (Dict a)
Instance details Defined in Data.Constraint Methods showsPrec :: Int -> Dict a -> ShowS # show :: Dict a -> String # showList :: [Dict a] -> ShowS #
NFData (Dict c)
Instance details Defined in Data.Constraint Methods rnf :: Dict c -> () #
Eq (Dict a)
Instance details Defined in Data.Constraint Methods (==) :: Dict a -> Dict a -> Bool # (/=) :: Dict a -> Dict a -> Bool #
Ord (Dict a)
Instance details Defined in Data.Constraint Methods compare :: Dict a -> Dict a -> Ordering # (<) :: Dict a -> Dict a -> Bool # (<=) :: Dict a -> Dict a -> Bool # (>) :: Dict a -> Dict a -> Bool # (>=) :: Dict a -> Dict a -> Bool # max :: Dict a -> Dict a -> Dict a # min :: Dict a -> Dict a -> Dict a #

newtype a :- b infixr 9 #

This is the type of entailment.

a :- b is read as a "entails" b.

With this we can actually build a category for Constraint resolution.

e.g.

Because Eq a is a superclass of Ord a, we can show that Ord a entails Eq a.

Because instance Ord a => Ord [a] exists, we can show that Ord a entails Ord [a] as well.

This relationship is captured in the :- entailment type here.

Since p :- p and entailment composes, :- forms the arrows of a Category of constraints. However, Category only became sufficiently general to support this instance in GHC 7.8, so prior to 7.8 this instance is unavailable.

But due to the coherence of instance resolution in Haskell, this Category has some very interesting properties. Notably, in the absence of IncoherentInstances, this category is "thin", which is to say that between any two objects (constraints) there is at most one distinguishable arrow.

This means that for instance, even though there are two ways to derive Ord a :- Eq [a], the answers from these two paths _must_ by construction be equal. This is a property that Haskell offers that is pretty much unique in the space of languages with things they call "type classes".

What are the two ways?

Well, we can go from Ord a :- Eq a via the superclass relationship, and then from Eq a :- Eq [a] via the instance, or we can go from Ord a :- Ord [a] via the instance then from Ord [a] :- Eq [a] through the superclass relationship and this diagram by definition must "commute".

Diagrammatically,

                   Ord a
               ins /     \ cls
                  v       v
            Ord [a]     Eq a
               cls \     / ins
                    v   v
                   Eq [a]

This safety net ensures that pretty much anything you can write with this library is sensible and can't break any assumptions on the behalf of library authors.

Constructors

Sub (a => Dict b)

Instances

Instances details

Category (:-)	Possible since GHC 7.8, when `Category` was made polykinded.
Instance details Defined in Data.Constraint Methods id :: forall (a :: k). a :- a # (.) :: forall (b :: k) (c :: k) (a :: k). (b :- c) -> (a :- b) -> a :- c #
() :=> (Show (a :- b))
Instance details Defined in Data.Constraint Methods ins :: () :- Show (a :- b) #
() :=> (Eq (a :- b))
Instance details Defined in Data.Constraint Methods ins :: () :- Eq (a :- b) #
() :=> (Ord (a :- b))
Instance details Defined in Data.Constraint Methods ins :: () :- Ord (a :- b) #
a => HasDict b (a :- b)
Instance details Defined in Data.Constraint Methods evidence :: (a :- b) -> Dict b #
(Typeable p, Typeable q, p, q) => Data (p :- q)
Instance details Defined in Data.Constraint Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (p :- q) -> c (p :- q) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (p :- q) # toConstr :: (p :- q) -> Constr # dataTypeOf :: (p :- q) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (p :- q)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (p :- q)) # gmapT :: (forall b. Data b => b -> b) -> (p :- q) -> p :- q # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r # gmapQ :: (forall d. Data d => d -> u) -> (p :- q) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (p :- q) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q) #
Show (a :- b)
Instance details Defined in Data.Constraint Methods showsPrec :: Int -> (a :- b) -> ShowS # show :: (a :- b) -> String # showList :: [a :- b] -> ShowS #
a => NFData (a :- b)
Instance details Defined in Data.Constraint Methods rnf :: (a :- b) -> () #
Eq (a :- b)	Assumes `IncoherentInstances` doesn't exist.
Instance details Defined in Data.Constraint Methods (==) :: (a :- b) -> (a :- b) -> Bool # (/=) :: (a :- b) -> (a :- b) -> Bool #
Ord (a :- b)	Assumes `IncoherentInstances` doesn't exist.
Instance details Defined in Data.Constraint Methods compare :: (a :- b) -> (a :- b) -> Ordering # (<) :: (a :- b) -> (a :- b) -> Bool # (<=) :: (a :- b) -> (a :- b) -> Bool # (>) :: (a :- b) -> (a :- b) -> Bool # (>=) :: (a :- b) -> (a :- b) -> Bool # max :: (a :- b) -> (a :- b) -> a :- b # min :: (a :- b) -> (a :- b) -> a :- b #

class SingI (a :: k) where #

A SingI constraint is essentially an implicitly-passed singleton. If you need to satisfy this constraint with an explicit singleton, please see withSingI or the Sing pattern synonym.

Methods

sing :: Sing a #

Produce the singleton explicitly. You will likely need the ScopedTypeVariables extension to use this method the way you want.

Instances

Instances details

SingI 'AlwaysFailing Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'AlwaysFailing #
SingI 'FailingNormal Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'FailingNormal #
SingI 'DoesHaveNonStandardAnns Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'DoesHaveNonStandardAnns #
SingI 'DoesHaveStandardAnns Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'DoesHaveStandardAnns #
SingI 'DoesNotHaveAnns Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'DoesNotHaveAnns #
SingI 'Additional Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'Additional #
SingI 'FromMichelson Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'FromMichelson #
SingI 'Phantom Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'Phantom #
SingI 'Structural Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'Structural #
SingI 'HasIndirectChildren Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'HasIndirectChildren #
SingI 'MayHaveChildren Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'MayHaveChildren #
SingI 'NoChildren Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'NoChildren #
SingI 'OneChild Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'OneChild #
SingI 'TwoChildren Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing 'TwoChildren #
SingI 'TAddress Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TAddress #
SingI 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBls12381Fr #
SingI 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBls12381G1 #
SingI 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBls12381G2 #
SingI 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBool #
SingI 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBytes #
SingI 'TChainId Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TChainId #
SingI 'TChest Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TChest #
SingI 'TChestKey Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TChestKey #
SingI 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TInt #
SingI 'TKey Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TKey #
SingI 'TKeyHash Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TKeyHash #
SingI 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TMutez #
SingI 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TNat #
SingI 'TNever Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TNever #
SingI 'TOperation Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TOperation #
SingI 'TSignature Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TSignature #
SingI 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TString #
SingI 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TTimestamp #
SingI 'TUnit Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TUnit #
SingI 'AddressKindContract Source #
Instance details Defined in Morley.Tezos.Address.Kinds Methods sing :: Sing 'AddressKindContract #
SingI 'AddressKindImplicit Source #
Instance details Defined in Morley.Tezos.Address.Kinds Methods sing :: Sing 'AddressKindImplicit #
SingI 'AddressKindSmartRollup Source #
Instance details Defined in Morley.Tezos.Address.Kinds Methods sing :: Sing 'AddressKindSmartRollup #
SingI 'Z Source #
Instance details Defined in Morley.Util.Peano Methods sing :: Sing 'Z #
SingI n => SingI ('TContract n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TContract n) #
SingI n => SingI ('TList n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TList n) #
SingI n => SingI ('TOption n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TOption n) #
SingI n => SingI ('TSaplingState n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TSaplingState n) #
SingI n => SingI ('TSaplingTransaction n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TSaplingTransaction n) #
SingI n => SingI ('TSet n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TSet n) #
SingI n => SingI ('TTicket n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TTicket n) #
SingI n => SingI ('S n :: Nat) Source #
Instance details Defined in Morley.Util.Peano Methods sing :: Sing ('S n) #
(SingI n1, SingI n2) => SingI ('TBigMap n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TBigMap n1 n2) #
(SingI n1, SingI n2) => SingI ('TLambda n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TLambda n1 n2) #
(SingI n1, SingI n2) => SingI ('TMap n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TMap n1 n2) #
(SingI n1, SingI n2) => SingI ('TOr n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TOr n1 n2) #
(SingI n1, SingI n2) => SingI ('TPair n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TPair n1 n2) #
(SingI n1, SingI n2, SingI n3, SingI n4) => SingI ('InstrClass n1 n2 n3 n4 :: InstrClass) Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing ('InstrClass n1 n2 n3 n4) #
SingI n => SingI ('MaxInternal n :: MaxInternal a)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ('MaxInternal n) #
SingI n => SingI ('MinInternal n :: MinInternal a)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ('MinInternal n) #
SingI GetAllSym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetAllSym0 #
SingI GetAnySym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetAnySym0 #
SingI ThenCmpSym0
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ThenCmpSym0 #
SingI InstrClassSym0 Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing InstrClassSym0 #
SingI AllSym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing AllSym0 #
SingI All_Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing All_Sym0 #
SingI AnySym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing AnySym0 #
SingI Any_Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing Any_Sym0 #
SingI ShowParenSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowParenSym0 #
SingI EfdtNatDnSym0
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing EfdtNatDnSym0 #
SingI EfdtNatSym0
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing EfdtNatSym0 #
SingI EfdtNatUpSym0
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing EfdtNatUpSym0 #
SingI EftNatSym0
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing EftNatSym0 #
SingI ShowCharSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowCharSym0 #
SingI ShowStringSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowStringSym0 #
SingI ShowCommaSpaceSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowCommaSpaceSym0 #
SingI ShowSpaceSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowSpaceSym0 #
SingI Show_tupleSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing Show_tupleSym0 #
SingI AndSym0
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing AndSym0 #
SingI OrSym0
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing OrSym0 #
SingI UnlinesSym0
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnlinesSym0 #
SingI UnwordsSym0
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnwordsSym0 #
SingI (&&@#@$)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (&&@#@$) #
SingI (\|\|@#@$)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (\|\|@#@$) #
SingI NotSym0
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing NotSym0 #
SingI (<=?@#@$)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing (<=?@#@$) #
SingI DivSym0
Instance details Defined in GHC.TypeLits.Singletons Methods sing :: Sing DivSym0 #
SingI ModSym0
Instance details Defined in GHC.TypeLits.Singletons Methods sing :: Sing ModSym0 #
SingI (^@#@$)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing (^@#@$) #
SingI Log2Sym0
Instance details Defined in GHC.TypeLits.Singletons Methods sing :: Sing Log2Sym0 #
SingI (RunIdentitySym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing RunIdentitySym0 #
SingI (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing GetFirstSym0 #
SingI (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing GetLastSym0 #
SingI (GetDownSym0 :: TyFun (Down a) a -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing GetDownSym0 #
SingI (GetFirstSym0 :: TyFun (First a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetFirstSym0 #
SingI (GetLastSym0 :: TyFun (Last a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetLastSym0 #
SingI (GetMaxSym0 :: TyFun (Max a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetMaxSym0 #
SingI (GetMinSym0 :: TyFun (Min a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetMinSym0 #
SingI (UnwrapMonoidSym0 :: TyFun (WrappedMonoid m) m -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing UnwrapMonoidSym0 #
SingI (GetDualSym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetDualSym0 #
SingI (GetProductSym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetProductSym0 #
SingI (GetSumSym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetSumSym0 #
SSemigroup a => SingI (SconcatSym0 :: TyFun (NonEmpty a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing SconcatSym0 #
SingI d => SingI (ThenCmpSym1 d :: TyFun Ordering Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (ThenCmpSym1 d) #
SingI d => SingI (InstrClassSym1 d :: TyFun FailureType (IsMichelson ~> (HasAnns ~> InstrClass)) -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing (InstrClassSym1 d) #
SingI d => SingI (ShowParenSym1 d :: TyFun (Symbol ~> Symbol) (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowParenSym1 d) #
SingI (ShowListWithSym0 :: TyFun (a ~> (Symbol ~> Symbol)) ([a] ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowListWithSym0 #
SingI (SortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SortBySym0 #
SingI (ListsortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListsortBySym0 #
SingI (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MaximumBySym0 #
SingI (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MinimumBySym0 #
SingI (InsertBySym0 :: TyFun (a ~> (a ~> Ordering)) (a ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing InsertBySym0 #
SingI (DeleteFirstsBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DeleteFirstsBySym0 #
SingI (IntersectBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IntersectBySym0 #
SingI (UnionBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnionBySym0 #
SingI (GroupBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [[a]]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing GroupBySym0 #
SingI (NubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NubBySym0 #
SingI (ListnubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListnubBySym0 #
SingI (Elem_bySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> Bool)) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Elem_bySym0 #
SingI (DeleteBySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DeleteBySym0 #
SingI (Scanl1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Scanl1Sym0 #
SingI (Scanr1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Scanr1Sym0 #
SingI (Listscanr1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing Listscanr1Sym0 #
SingI (Foldl1'Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Foldl1'Sym0 #
SingI (Foldl1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Foldl1Sym0 #
SingI (Foldr1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Foldr1Sym0 #
SingI (Listfoldl1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing Listfoldl1Sym0 #
SingI (Listfoldr1Sym0 :: TyFun (a ~> (a ~> a)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing Listfoldr1Sym0 #
SingI (UntilSym0 :: TyFun (a ~> Bool) ((a ~> a) ~> (a ~> a)) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing UntilSym0 #
SingI (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindIndexSym0 #
SingI (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindSym0 #
SingI (BreakSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing BreakSym0 #
SingI (PartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing PartitionSym0 #
SingI (SpanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SpanSym0 #
SingI (ListpartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListpartitionSym0 #
SingI (ListspanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListspanSym0 #
SingI (AllSym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing AllSym0 #
SingI (AnySym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing AnySym0 #
SingI (FindIndicesSym0 :: TyFun (a ~> Bool) ([a] ~> [Nat]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindIndicesSym0 #
SingI (DropWhileEndSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DropWhileEndSym0 #
SingI (DropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DropWhileSym0 #
SingI (FilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FilterSym0 #
SingI (TakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing TakeWhileSym0 #
SingI (ListdropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListdropWhileSym0 #
SingI (ListfilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListfilterSym0 #
SingI (ListtakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListtakeWhileSym0 #
SingI (SelectSym0 :: TyFun (a ~> Bool) (a ~> (([a], [a]) ~> ([a], [a]))) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SelectSym0 #
SingI (AppEndoSym0 :: TyFun (Endo a) (a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AppEndoSym0 #
SingI (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing GetMaxInternalSym0 #
SingI (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing GetMinInternalSym0 #
SingI (FirstSym0 :: TyFun (Maybe a) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing FirstSym0 #
SingI (LastSym0 :: TyFun (Maybe a) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing LastSym0 #
SingI (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MaxInternalSym0 #
SingI (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MinInternalSym0 #
SingI (IsJustSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing IsJustSym0 #
SingI (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing IsNothingSym0 #
SingI (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing MaybeToListSym0 #
SingI (FromJustSym0 :: TyFun (Maybe a) a -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing FromJustSym0 #
SApplicative f => SingI (UnlessSym0 :: TyFun Bool (f () ~> f ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing UnlessSym0 #
SApplicative f => SingI (WhenSym0 :: TyFun Bool (f () ~> f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing WhenSym0 #
SAlternative f => SingI (GuardSym0 :: TyFun Bool (f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing GuardSym0 #
SingI d => SingI (EfdtNatDnSym1 d :: TyFun Nat (Nat ~> [Nat]) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EfdtNatDnSym1 d) #
SingI d => SingI (EfdtNatSym1 d :: TyFun Nat (Nat ~> [Nat]) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EfdtNatSym1 d) #
SingI d => SingI (EfdtNatUpSym1 d :: TyFun Nat (Nat ~> [Nat]) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EfdtNatUpSym1 d) #
SingI (SplitAtSym0 :: TyFun Nat ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SplitAtSym0 #
SingI (ListsplitAtSym0 :: TyFun Nat ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListsplitAtSym0 #
SingI (DropSym0 :: TyFun Nat ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DropSym0 #
SingI (TakeSym0 :: TyFun Nat ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing TakeSym0 #
SingI (ListdropSym0 :: TyFun Nat ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListdropSym0 #
SingI (ListtakeSym0 :: TyFun Nat ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListtakeSym0 #
SShow a => SingI (ShowsPrecSym0 :: TyFun Nat (a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowsPrecSym0 #
SingI (ReplicateSym0 :: TyFun Nat (a ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ReplicateSym0 #
SingI d => SingI (EftNatSym1 d :: TyFun Nat [Nat] -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EftNatSym1 d) #
SEnum a => SingI (ToEnumSym0 :: TyFun Nat a -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing ToEnumSym0 #
SNum a => SingI (FromIntegerSym0 :: TyFun Nat a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing FromIntegerSym0 #
SingI d => SingI (ShowCharSym1 d :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowCharSym1 d) #
SingI d => SingI (ShowStringSym1 d :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowStringSym1 d) #
SingI d => SingI (Show_tupleSym1 d :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (Show_tupleSym1 d) #
SingI (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing CatMaybesSym0 #
SingI (TransposeSym0 :: TyFun [[a]] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing TransposeSym0 #
SingI (ListtransposeSym0 :: TyFun [[a]] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListtransposeSym0 #
SingI (ConcatSym0 :: TyFun [[a]] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ConcatSym0 #
SingI ((!!@#@$) :: TyFun [a] (Nat ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (!!@#@$) #
SingI (ListindexSym0 :: TyFun [a] (Nat ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListindexSym0 #
SShow a => SingI (ShowListSym0 :: TyFun [a] (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowListSym0 #
SingI (IntercalateSym0 :: TyFun [a] ([[a]] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IntercalateSym0 #
SEq a => SingI (IsInfixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IsInfixOfSym0 #
SEq a => SingI (IsPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IsPrefixOfSym0 #
SEq a => SingI (IsSuffixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IsSuffixOfSym0 #
SEq a => SingI (ListisPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListisPrefixOfSym0 #
SEq a => SingI (IntersectSym0 :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IntersectSym0 #
SEq a => SingI (UnionSym0 :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnionSym0 #
SEq a => SingI ((\\@#@$) :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (\\@#@$) #
SingI ((++@#@$) :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (++@#@$) #
SingI (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing ListToMaybeSym0 #
SingI (NullSym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NullSym0 #
SingI (ListnullSym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListnullSym0 #
SingI (LengthSym0 :: TyFun [a] Nat -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing LengthSym0 #
SingI (ListlengthSym0 :: TyFun [a] Nat -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListlengthSym0 #
SEq a => SingI (GroupSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing GroupSym0 #
SingI (InitsSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing InitsSym0 #
SingI (NonEmptySubsequencesSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NonEmptySubsequencesSym0 #
SingI (PermutationsSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing PermutationsSym0 #
SingI (SubsequencesSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SubsequencesSym0 #
SingI (TailsSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing TailsSym0 #
SingI (ListinitsSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListinitsSym0 #
SingI (ListtailsSym0 :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListtailsSym0 #
SingI (InitSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing InitSym0 #
SEq a => SingI (NubSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NubSym0 #
SingI (ReverseSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ReverseSym0 #
SOrd a => SingI (SortSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SortSym0 #
SingI (TailSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing TailSym0 #
SingI (ListinitSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListinitSym0 #
SingI (ListreverseSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListreverseSym0 #
SOrd a => SingI (ListsortSym0 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListsortSym0 #
SingI (HeadSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing HeadSym0 #
SingI (LastSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing LastSym0 #
SOrd a => SingI (MaximumSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MaximumSym0 #
SOrd a => SingI (MinimumSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MinimumSym0 #
SNum a => SingI (ProductSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ProductSym0 #
SNum a => SingI (SumSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SumSym0 #
SingI (ListlastSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListlastSym0 #
SOrd a => SingI (ListmaximumSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListmaximumSym0 #
SOrd a => SingI (ListminimumSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListminimumSym0 #
SNum a => SingI (ListproductSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListproductSym0 #
SNum a => SingI (ListsumSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListsumSym0 #
SMonoid a => SingI (MconcatSym0 :: TyFun [a] a -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing MconcatSym0 #
SingI (IdentitySym0 :: TyFun a (Identity a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing IdentitySym0 #
SingI (DownSym0 :: TyFun a (Down a) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing DownSym0 #
SingI (FirstSym0 :: TyFun a (First a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing FirstSym0 #
SingI (LastSym0 :: TyFun a (Last a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing LastSym0 #
SingI (MaxSym0 :: TyFun a (Max a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing MaxSym0 #
SingI (MinSym0 :: TyFun a (Min a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing MinSym0 #
SingI (DualSym0 :: TyFun a (Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing DualSym0 #
SingI (ProductSym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing ProductSym0 #
SingI (Product_Sym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing Product_Sym0 #
SingI (SumSym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing SumSym0 #
SingI (Sum_Sym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing Sum_Sym0 #
SingI (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing FromMaybeSym0 #
SShow a => SingI (ShowsSym0 :: TyFun a (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowsSym0 #
SingI ((:\|@#@$) :: TyFun a ([a] ~> NonEmpty a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (:\|@#@$) #
SEq a => SingI (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ElemIndexSym0 #
SEq a => SingI (ElemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ElemSym0 #
SEq a => SingI (NotElemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NotElemSym0 #
SEq a => SingI (ListelemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListelemSym0 #
SEq a => SingI (ElemIndicesSym0 :: TyFun a ([a] ~> [Nat]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ElemIndicesSym0 #
SEq a => SingI (DeleteSym0 :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DeleteSym0 #
SOrd a => SingI (InsertSym0 :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing InsertSym0 #
SingI (IntersperseSym0 :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IntersperseSym0 #
SingI (PrependToAllSym0 :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing PrependToAllSym0 #
SOrd a => SingI (ListinsertSym0 :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListinsertSym0 #
SingI (ListintersperseSym0 :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListintersperseSym0 #
SingI ((:@#@$) :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (:@#@$) #
SOrd a => SingI (CompareSym0 :: TyFun a (a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing CompareSym0 #
SingI (Bool_Sym0 :: TyFun a (a ~> (Bool ~> a)) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing Bool_Sym0 #
SEnum a => SingI (EnumFromThenToSym0 :: TyFun a (a ~> (a ~> [a])) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing EnumFromThenToSym0 #
SEq a => SingI ((/=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing (/=@#@$) #
SEq a => SingI ((==@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing (==@#@$) #
SOrd a => SingI ((<=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (<=@#@$) #
SOrd a => SingI ((<@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (<@#@$) #
SOrd a => SingI ((>=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (>=@#@$) #
SOrd a => SingI ((>@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (>@#@$) #
SEnum a => SingI (EnumFromToSym0 :: TyFun a (a ~> [a]) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing EnumFromToSym0 #
SMonoid a => SingI (MappendSym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing MappendSym0 #
SOrd a => SingI (MaxSym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing MaxSym0 #
SOrd a => SingI (MinSym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing MinSym0 #
SOrd a => SingI (Max_Sym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in Data.Ord.Singletons.Disambiguation Methods sing :: Sing Max_Sym0 #
SOrd a => SingI (Min_Sym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in Data.Ord.Singletons.Disambiguation Methods sing :: Sing Min_Sym0 #
SSemigroup a => SingI ((<>@#@$) :: TyFun a (a ~> a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing (<>@#@$) #
SingI (AsTypeOfSym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing AsTypeOfSym0 #
SNum a => SingI ((*@#@$) :: TyFun a (a ~> a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing (*@#@$) #
SNum a => SingI ((+@#@$) :: TyFun a (a ~> a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing (+@#@$) #
SNum a => SingI ((-@#@$) :: TyFun a (a ~> a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing (-@#@$) #
SNum a => SingI (SubtractSym0 :: TyFun a (a ~> a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing SubtractSym0 #
SingI (JustSym0 :: TyFun a (Maybe a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing JustSym0 #
SEnum a => SingI (FromEnumSym0 :: TyFun a Nat -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing FromEnumSym0 #
SShow a => SingI (Show_Sym0 :: TyFun a Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing Show_Sym0 #
SEnum a => SingI (PredSym0 :: TyFun a a -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing PredSym0 #
SEnum a => SingI (SuccSym0 :: TyFun a a -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing SuccSym0 #
SingI (IdSym0 :: TyFun a a -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing IdSym0 #
SNum a => SingI (AbsSym0 :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing AbsSym0 #
SNum a => SingI (NegateSym0 :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing NegateSym0 #
SNum a => SingI (SignumSym0 :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing SignumSym0 #
SingI (WrapMonoidSym0 :: TyFun m (WrappedMonoid m) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing WrapMonoidSym0 #
SFoldable t => SingI (AndSym0 :: TyFun (t Bool) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AndSym0 #
SFoldable t => SingI (OrSym0 :: TyFun (t Bool) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing OrSym0 #
SingI (IfSym0 :: TyFun Bool (k ~> (k ~> k)) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing IfSym0 #
SingI x => SingI ((&&@#@$$) x :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing ((&&@#@$$) x) #
SingI x => SingI ((\|\|@#@$$) x :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing ((\|\|@#@$$) x) #
SingI x => SingI ((<=?@#@$$) x :: TyFun Nat Bool -> Type)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing ((<=?@#@$$) x) #
SingI x => SingI (DivSym1 x :: TyFun Nat Nat -> Type)
Instance details Defined in GHC.TypeLits.Singletons Methods sing :: Sing (DivSym1 x) #
SingI x => SingI (ModSym1 x :: TyFun Nat Nat -> Type)
Instance details Defined in GHC.TypeLits.Singletons Methods sing :: Sing (ModSym1 x) #
SingI x => SingI ((^@#@$$) x :: TyFun Nat Nat -> Type)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing ((^@#@$$) x) #
SingI (IsLeftSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing IsLeftSym0 #
SingI (IsRightSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing IsRightSym0 #
(SingI d1, SingI d2) => SingI (InstrClassSym2 d1 d2 :: TyFun IsMichelson (HasAnns ~> InstrClass) -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing (InstrClassSym2 d1 d2) #
SFoldable t => SingI (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MaximumBySym0 #
SFoldable t => SingI (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MinimumBySym0 #
SFoldable t => SingI (Foldl1Sym0 :: TyFun (a ~> (a ~> a)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing Foldl1Sym0 #
SFoldable t => SingI (Foldr1Sym0 :: TyFun (a ~> (a ~> a)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing Foldr1Sym0 #
SingI (ScanrSym0 :: TyFun (a ~> (b ~> b)) (b ~> ([a] ~> [b])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ScanrSym0 #
SingI (ListscanrSym0 :: TyFun (a ~> (b ~> b)) (b ~> ([a] ~> [b])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListscanrSym0 #
SingI (ListfoldrSym0 :: TyFun (a ~> (b ~> b)) (b ~> ([a] ~> b)) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListfoldrSym0 #
SingI (FoldrSym0 :: TyFun (a ~> (b ~> b)) (b ~> ([a] ~> b)) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing FoldrSym0 #
SingI (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing MapMaybeSym0 #
SMonadPlus m => SingI (MfilterSym0 :: TyFun (a ~> Bool) (m a ~> m a) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing MfilterSym0 #
SFoldable t => SingI (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FindSym0 #
SFoldable t => SingI (AllSym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AllSym0 #
SFoldable t => SingI (AnySym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AnySym0 #
SingI (ConcatMapSym0 :: TyFun (a ~> [b]) ([a] ~> [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ConcatMapSym0 #
SingI d => SingI (UntilSym1 d :: TyFun (a ~> a) (a ~> a) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (UntilSym1 d) #
SingI (ListmapSym0 :: TyFun (a ~> b) ([a] ~> [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListmapSym0 #
SingI (MapSym0 :: TyFun (a ~> b) ([a] ~> [b]) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing MapSym0 #
SingI (($!@#@$) :: TyFun (a ~> b) (a ~> b) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing ($!@#@$) #
SingI (($@#@$) :: TyFun (a ~> b) (a ~> b) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing ($@#@$) #
SApplicative m => SingI (FilterMSym0 :: TyFun (a ~> m Bool) ([a] ~> m [a]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing FilterMSym0 #
SingI (ScanlSym0 :: TyFun (b ~> (a ~> b)) (b ~> ([a] ~> [b])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ScanlSym0 #
SingI (ListscanlSym0 :: TyFun (b ~> (a ~> b)) (b ~> ([a] ~> [b])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListscanlSym0 #
SingI (Foldl'Sym0 :: TyFun (b ~> (a ~> b)) (b ~> ([a] ~> b)) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Foldl'Sym0 #
SingI (Listfoldl'Sym0 :: TyFun (b ~> (a ~> b)) (b ~> ([a] ~> b)) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing Listfoldl'Sym0 #
SingI (ListfoldlSym0 :: TyFun (b ~> (a ~> b)) (b ~> ([a] ~> b)) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListfoldlSym0 #
SingI (FoldlSym0 :: TyFun (b ~> (a ~> b)) (b ~> ([a] ~> b)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing FoldlSym0 #
SingI (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnfoldrSym0 #
SOrd a => SingI (ComparingSym0 :: TyFun (b ~> a) (b ~> (b ~> Ordering)) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ComparingSym0 #
SingI (RunStateLSym0 :: TyFun (StateL s a) (s ~> (s, a)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing RunStateLSym0 #
SingI (RunStateRSym0 :: TyFun (StateR s a) (s ~> (s, a)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing RunStateRSym0 #
SingI d => SingI (FromMaybeSym1 d :: TyFun (Maybe a) a -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (FromMaybeSym1 d) #
SingI (SwapSym0 :: TyFun (a, b) (b, a) -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing SwapSym0 #
SingI (FstSym0 :: TyFun (a, b) a -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing FstSym0 #
SingI (SndSym0 :: TyFun (a, b) b -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing SndSym0 #
SApplicative m => SingI (ReplicateM_Sym0 :: TyFun Nat (m a ~> m ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ReplicateM_Sym0 #
SApplicative m => SingI (ReplicateMSym0 :: TyFun Nat (m a ~> m [a]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ReplicateMSym0 #
(SingI d1, SingI d2) => SingI (EfdtNatDnSym2 d1 d2 :: TyFun Nat [Nat] -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EfdtNatDnSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (EfdtNatSym2 d1 d2 :: TyFun Nat [Nat] -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EfdtNatSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (EfdtNatUpSym2 d1 d2 :: TyFun Nat [Nat] -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EfdtNatUpSym2 d1 d2) #
SingI d => SingI ((!!@#@$$) d :: TyFun Nat a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ((!!@#@$$) d) #
SingI d => SingI (ListindexSym1 d :: TyFun Nat a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListindexSym1 d) #
(SShow a, SingI d) => SingI (ShowListSym1 d :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowListSym1 d) #
(SingI d1, SingI d2) => SingI (ShowParenSym2 d1 d2 :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowParenSym2 d1 d2) #
(SShow a, SingI d) => SingI (ShowsSym1 d :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowsSym1 d) #
SingI (ErrorSym0 :: TyFun Symbol a -> Type)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing ErrorSym0 #
SingI (ErrorWithoutStackTraceSym0 :: TyFun Symbol a -> Type)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing ErrorWithoutStackTraceSym0 #
SingI (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing PartitionEithersSym0 #
SingI (LeftsSym0 :: TyFun [Either a b] [a] -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing LeftsSym0 #
SingI (RightsSym0 :: TyFun [Either a b] [b] -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing RightsSym0 #
SingI (UnzipSym0 :: TyFun [(a, b)] ([a], [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnzipSym0 #
SingI (ListunzipSym0 :: TyFun [(a, b)] ([a], [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListunzipSym0 #
SingI d => SingI (IntercalateSym1 d :: TyFun [[a]] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IntercalateSym1 d) #
SingI d => SingI ((:\|@#@$$) d :: TyFun [a] (NonEmpty a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing ((:\|@#@$$) d) #
SingI d => SingI (ShowListWithSym1 d :: TyFun [a] (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowListWithSym1 d) #
SingI d => SingI (DeleteFirstsBySym1 d :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DeleteFirstsBySym1 d) #
SingI d => SingI (IntersectBySym1 d :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IntersectBySym1 d) #
SingI d => SingI (UnionBySym1 d :: TyFun [a] ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (UnionBySym1 d) #
SingI (ZipSym0 :: TyFun [a] ([b] ~> [(a, b)]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ZipSym0 #
SingI (ListzipSym0 :: TyFun [a] ([b] ~> [(a, b)]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListzipSym0 #
(SEq a, SingI d) => SingI (ElemIndexSym1 d :: TyFun [a] (Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ElemIndexSym1 d) #
SingI d => SingI (FindIndexSym1 d :: TyFun [a] (Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (FindIndexSym1 d) #
SingI d => SingI (FindSym1 d :: TyFun [a] (Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (FindSym1 d) #
SingI d => SingI (BreakSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (BreakSym1 d) #
SingI d => SingI (PartitionSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (PartitionSym1 d) #
SingI d => SingI (SpanSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (SpanSym1 d) #
SingI d => SingI (SplitAtSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (SplitAtSym1 d) #
SingI d => SingI (ListpartitionSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListpartitionSym1 d) #
SingI d => SingI (ListspanSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListspanSym1 d) #
SingI d => SingI (ListsplitAtSym1 d :: TyFun [a] ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListsplitAtSym1 d) #
SingI d => SingI (AllSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (AllSym1 d) #
SingI d => SingI (AnySym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (AnySym1 d) #
(SEq a, SingI d) => SingI (ElemSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ElemSym1 d) #
(SEq a, SingI d) => SingI (IsInfixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IsInfixOfSym1 d) #
(SEq a, SingI d) => SingI (IsPrefixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IsPrefixOfSym1 d) #
(SEq a, SingI d) => SingI (IsSuffixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IsSuffixOfSym1 d) #
(SEq a, SingI d) => SingI (NotElemSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (NotElemSym1 d) #
(SEq a, SingI d) => SingI (ListelemSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListelemSym1 d) #
(SEq a, SingI d) => SingI (ListisPrefixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListisPrefixOfSym1 d) #
(SEq a, SingI d) => SingI (ElemIndicesSym1 d :: TyFun [a] [Nat] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ElemIndicesSym1 d) #
SingI d => SingI (FindIndicesSym1 d :: TyFun [a] [Nat] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (FindIndicesSym1 d) #
SingI d => SingI (GroupBySym1 d :: TyFun [a] [[a]] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (GroupBySym1 d) #
(SEq a, SingI d) => SingI (DeleteSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DeleteSym1 d) #
SingI d => SingI (DropSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DropSym1 d) #
SingI d => SingI (DropWhileEndSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DropWhileEndSym1 d) #
SingI d => SingI (DropWhileSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DropWhileSym1 d) #
SingI d => SingI (FilterSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (FilterSym1 d) #
(SOrd a, SingI d) => SingI (InsertSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (InsertSym1 d) #
(SEq a, SingI d) => SingI (IntersectSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IntersectSym1 d) #
SingI d => SingI (IntersperseSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IntersperseSym1 d) #
SingI d => SingI (NubBySym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (NubBySym1 d) #
SingI d => SingI (PrependToAllSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (PrependToAllSym1 d) #
SingI d => SingI (Scanl1Sym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Scanl1Sym1 d) #
SingI d => SingI (Scanr1Sym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Scanr1Sym1 d) #
SingI d => SingI (SortBySym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (SortBySym1 d) #
SingI d => SingI (TakeSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (TakeSym1 d) #
SingI d => SingI (TakeWhileSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (TakeWhileSym1 d) #
(SEq a, SingI d) => SingI (UnionSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (UnionSym1 d) #
(SEq a, SingI d) => SingI ((\\@#@$$) d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ((\\@#@$$) d) #
SingI d => SingI (ListdropSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListdropSym1 d) #
SingI d => SingI (ListdropWhileSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListdropWhileSym1 d) #
SingI d => SingI (ListfilterSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListfilterSym1 d) #
(SOrd a, SingI d) => SingI (ListinsertSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListinsertSym1 d) #
SingI d => SingI (ListintersperseSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListintersperseSym1 d) #
SingI d => SingI (ListnubBySym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListnubBySym1 d) #
SingI d => SingI (Listscanr1Sym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (Listscanr1Sym1 d) #
SingI d => SingI (ListsortBySym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListsortBySym1 d) #
SingI d => SingI (ListtakeSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListtakeSym1 d) #
SingI d => SingI (ListtakeWhileSym1 d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListtakeWhileSym1 d) #
SingI d => SingI ((:@#@$$) d :: TyFun [a] [a] -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing ((:@#@$$) d) #
SingI d => SingI ((++@#@$$) d :: TyFun [a] [a] -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing ((++@#@$$) d) #
SingI d => SingI (Foldl1'Sym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Foldl1'Sym1 d) #
SingI d => SingI (Foldl1Sym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Foldl1Sym1 d) #
SingI d => SingI (Foldr1Sym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Foldr1Sym1 d) #
SingI d => SingI (MaximumBySym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (MaximumBySym1 d) #
SingI d => SingI (MinimumBySym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (MinimumBySym1 d) #
SingI d => SingI (Listfoldl1Sym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (Listfoldl1Sym1 d) #
SingI d => SingI (Listfoldr1Sym1 d :: TyFun [a] a -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (Listfoldr1Sym1 d) #
SNum i => SingI (GenericLengthSym0 :: TyFun [a] i -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing GenericLengthSym0 #
SingI (LeftSym0 :: TyFun a (Either a b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing LeftSym0 #
(SOrd a, SingI d) => SingI (CompareSym1 d :: TyFun a Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (CompareSym1 d) #
SingI d => SingI (SelectSym1 d :: TyFun a (([a], [a]) ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (SelectSym1 d) #
SingI d => SingI (Bool_Sym1 d :: TyFun a (Bool ~> a) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (Bool_Sym1 d) #
(SShow a, SingI d) => SingI (ShowsPrecSym1 d :: TyFun a (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowsPrecSym1 d) #
SEq a => SingI (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing LookupSym0 #
SingI d => SingI (Elem_bySym1 d :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Elem_bySym1 d) #
SingI d => SingI (DeleteBySym1 d :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DeleteBySym1 d) #
SingI d => SingI (InsertBySym1 d :: TyFun a ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (InsertBySym1 d) #
(SEnum a, SingI d) => SingI (EnumFromThenToSym1 d :: TyFun a (a ~> [a]) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EnumFromThenToSym1 d) #
SingI (ArgSym0 :: TyFun a (b ~> Arg a b) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods sing :: Sing ArgSym0 #
SingI (Tuple2Sym0 :: TyFun a (b ~> (a, b)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing Tuple2Sym0 #
SingI (ConstSym0 :: TyFun a (b ~> a) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing ConstSym0 #
SingI (SeqSym0 :: TyFun a (b ~> b) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing SeqSym0 #
SingI (AsProxyTypeOfSym0 :: TyFun a (proxy a ~> a) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods sing :: Sing AsProxyTypeOfSym0 #
(SFoldable t, SEq a) => SingI (ElemSym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ElemSym0 #
(SFoldable t, SEq a) => SingI (NotElemSym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing NotElemSym0 #
(SEq a, SingI d) => SingI ((/=@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing ((/=@#@$$) d) #
(SEq a, SingI d) => SingI ((==@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing ((==@#@$$) d) #
(SOrd a, SingI d) => SingI ((<=@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((<=@#@$$) d) #
(SOrd a, SingI d) => SingI ((<@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((<@#@$$) d) #
(SOrd a, SingI d) => SingI ((>=@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((>=@#@$$) d) #
(SOrd a, SingI d) => SingI ((>@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((>@#@$$) d) #
SingI d => SingI (ReplicateSym1 d :: TyFun a [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ReplicateSym1 d) #
(SEnum a, SingI d) => SingI (EnumFromToSym1 d :: TyFun a [a] -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EnumFromToSym1 d) #
SingI d => SingI (AppEndoSym1 d :: TyFun a a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (AppEndoSym1 d) #
(SMonoid a, SingI d) => SingI (MappendSym1 d :: TyFun a a -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing (MappendSym1 d) #
(SOrd a, SingI d) => SingI (MaxSym1 d :: TyFun a a -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (MaxSym1 d) #
(SOrd a, SingI d) => SingI (MinSym1 d :: TyFun a a -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (MinSym1 d) #
(SOrd a, SingI d) => SingI (Max_Sym1 d :: TyFun a a -> Type)
Instance details Defined in Data.Ord.Singletons.Disambiguation Methods sing :: Sing (Max_Sym1 d) #
(SOrd a, SingI d) => SingI (Min_Sym1 d :: TyFun a a -> Type)
Instance details Defined in Data.Ord.Singletons.Disambiguation Methods sing :: Sing (Min_Sym1 d) #
(SSemigroup a, SingI d) => SingI ((<>@#@$$) d :: TyFun a a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing ((<>@#@$$) d) #
SingI d => SingI (AsTypeOfSym1 d :: TyFun a a -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (AsTypeOfSym1 d) #
(SNum a, SingI d) => SingI ((*@#@$$) d :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing ((*@#@$$) d) #
(SNum a, SingI d) => SingI ((+@#@$$) d :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing ((+@#@$$) d) #
(SNum a, SingI d) => SingI ((-@#@$$) d :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing ((-@#@$$) d) #
(SNum a, SingI d) => SingI (SubtractSym1 d :: TyFun a a -> Type)
Instance details Defined in GHC.Num.Singletons Methods sing :: Sing (SubtractSym1 d) #
SApplicative f => SingI (PureSym0 :: TyFun a (f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing PureSym0 #
SMonad m => SingI (ReturnSym0 :: TyFun a (m a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ReturnSym0 #
SingI (RightSym0 :: TyFun b (Either a b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing RightSym0 #
SingI (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing Maybe_Sym0 #
(SApplicative f, SingI d) => SingI (UnlessSym1 d :: TyFun (f ()) (f ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (UnlessSym1 d) #
(SApplicative f, SingI d) => SingI (WhenSym1 d :: TyFun (f ()) (f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (WhenSym1 d) #
SAlternative f => SingI (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type)
Instance details Defined in Control.Applicative.Singletons Methods sing :: Sing OptionalSym0 #
SFunctor f => SingI (VoidSym0 :: TyFun (f a) (f ()) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing VoidSym0 #
SMonad m => SingI (JoinSym0 :: TyFun (m (m a)) (m a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing JoinSym0 #
SFoldable t => SingI (ConcatSym0 :: TyFun (t [a]) [a] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ConcatSym0 #
SFoldable t => SingI (ToListSym0 :: TyFun (t a) [a] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ToListSym0 #
(SFoldable t, SOrd a) => SingI (MaximumSym0 :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MaximumSym0 #
(SFoldable t, SOrd a) => SingI (MinimumSym0 :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MinimumSym0 #
(SFoldable t, SNum a) => SingI (ProductSym0 :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ProductSym0 #
(SFoldable t, SNum a) => SingI (SumSym0 :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing SumSym0 #
(SFoldable t, SMonoid m) => SingI (FoldSym0 :: TyFun (t m) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FoldSym0 #
SingI c => SingI (IfSym1 c :: TyFun k (k ~> k) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (IfSym1 c) #
SingI a => SingI ('WrapSing s :: WrappedSing a)
Instance details Defined in Data.Singletons Methods sing :: Sing ('WrapSing s) #
SingI (GetConstSym0 :: TyFun (Const a b) a -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods sing :: Sing GetConstSym0 #
(SingI d1, SingI d2, SingI d3) => SingI (InstrClassSym3 d1 d2 d3 :: TyFun HasAnns InstrClass -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods sing :: Sing (InstrClassSym3 d1 d2 d3) #
SingI (CurrySym0 :: TyFun ((a, b) ~> c) (a ~> (b ~> c)) -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing CurrySym0 #
SFoldable t => SingI (Foldr'Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (t a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing Foldr'Sym0 #
SFoldable t => SingI (FoldrSym0 :: TyFun (a ~> (b ~> b)) (b ~> (t a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FoldrSym0 #
SingI (UncurrySym0 :: TyFun (a ~> (b ~> c)) ((a, b) ~> c) -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing UncurrySym0 #
SingI (ZipWithSym0 :: TyFun (a ~> (b ~> c)) ([a] ~> ([b] ~> [c])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ZipWithSym0 #
SingI (ListzipWithSym0 :: TyFun (a ~> (b ~> c)) ([a] ~> ([b] ~> [c])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListzipWithSym0 #
SingI (FlipSym0 :: TyFun (a ~> (b ~> c)) (b ~> (a ~> c)) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing FlipSym0 #
SFoldable t => SingI (ConcatMapSym0 :: TyFun (a ~> [b]) (t a ~> [b]) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ConcatMapSym0 #
SingI d => SingI (Maybe_Sym1 d :: TyFun (a ~> b) (Maybe a ~> b) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (Maybe_Sym1 d) #
SFunctor f => SingI (FmapSym0 :: TyFun (a ~> b) (f a ~> f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing FmapSym0 #
SApplicative f => SingI (LiftASym0 :: TyFun (a ~> b) (f a ~> f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftASym0 #
SFunctor f => SingI ((<$>@#@$) :: TyFun (a ~> b) (f a ~> f b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing (<$>@#@$) #
SMonad m => SingI ((<$!>@#@$) :: TyFun (a ~> b) (m a ~> m b) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (<$!>@#@$) #
STraversable t => SingI (FmapDefaultSym0 :: TyFun (a ~> b) (t a ~> t b) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing FmapDefaultSym0 #
SingI (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing Either_Sym0 #
(SFoldable t, SMonoid m) => SingI (FoldMapSym0 :: TyFun (a ~> m) (t a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FoldMapSym0 #
(STraversable t, SMonoid m) => SingI (FoldMapDefaultSym0 :: TyFun (a ~> m) (t a ~> m) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing FoldMapDefaultSym0 #
SMonad m => SingI ((=<<@#@$) :: TyFun (a ~> m b) (m a ~> m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (=<<@#@$) #
SMonad m => SingI (LiftMSym0 :: TyFun (a1 ~> r) (m a1 ~> m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftMSym0 #
SingI (MapAccumLSym0 :: TyFun (acc ~> (x ~> (acc, y))) (acc ~> ([x] ~> (acc, [y]))) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MapAccumLSym0 #
SingI (MapAccumRSym0 :: TyFun (acc ~> (x ~> (acc, y))) (acc ~> ([x] ~> (acc, [y]))) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MapAccumRSym0 #
SFoldable t => SingI (Foldl'Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (t a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing Foldl'Sym0 #
SFoldable t => SingI (FoldlSym0 :: TyFun (b ~> (a ~> b)) (b ~> (t a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FoldlSym0 #
SingI ((.@#@$) :: TyFun (b ~> c) ((a ~> b) ~> (a ~> c)) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (.@#@$) #
(SingI d1, SingI d2) => SingI (SelectSym2 d1 d2 :: TyFun ([a], [a]) ([a], [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (SelectSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (Bool_Sym2 d1 d2 :: TyFun Bool a -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (Bool_Sym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ShowListWithSym2 d1 d2 :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowListWithSym2 d1 d2) #
(SShow a, SingI d1, SingI d2) => SingI (ShowsPrecSym2 d1 d2 :: TyFun Symbol Symbol -> Type)
Instance details Defined in Text.Show.Singletons Methods sing :: Sing (ShowsPrecSym2 d1 d2) #
(SEq a, SingI d) => SingI (LookupSym1 d :: TyFun [(a, b)] (Maybe b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (LookupSym1 d) #
SingI (Unzip3Sym0 :: TyFun [(a, b, c)] ([a], [b], [c]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Unzip3Sym0 #
SMonadFail m => SingI (FailSym0 :: TyFun [Char] (m a) -> Type)
Instance details Defined in Control.Monad.Fail.Singletons Methods sing :: Sing FailSym0 #
SingI (Zip3Sym0 :: TyFun [a] ([b] ~> ([c] ~> [(a, b, c)])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Zip3Sym0 #
(SingI d1, SingI d2) => SingI (Elem_bySym2 d1 d2 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Elem_bySym2 d1 d2) #
(SingI d1, SingI d2) => SingI (DeleteBySym2 d1 d2 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DeleteBySym2 d1 d2) #
(SingI d1, SingI d2) => SingI (DeleteFirstsBySym2 d1 d2 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (DeleteFirstsBySym2 d1 d2) #
(SingI d1, SingI d2) => SingI (InsertBySym2 d1 d2 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (InsertBySym2 d1 d2) #
(SingI d1, SingI d2) => SingI (IntersectBySym2 d1 d2 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IntersectBySym2 d1 d2) #
(SingI d1, SingI d2) => SingI (UnionBySym2 d1 d2 :: TyFun [a] [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (UnionBySym2 d1 d2) #
SingI d => SingI (ConcatMapSym1 d :: TyFun [a] [b] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ConcatMapSym1 d) #
SingI d => SingI (ListmapSym1 d :: TyFun [a] [b] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListmapSym1 d) #
SingI d => SingI (MapMaybeSym1 d :: TyFun [a] [b] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (MapMaybeSym1 d) #
SingI d => SingI (MapSym1 d :: TyFun [a] [b] -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (MapSym1 d) #
(SApplicative m, SingI d) => SingI (FilterMSym1 d :: TyFun [a] (m [a]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (FilterMSym1 d) #
SingI d => SingI (ZipSym1 d :: TyFun [b] [(a, b)] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ZipSym1 d) #
SingI d => SingI (ListzipSym1 d :: TyFun [b] [(a, b)] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListzipSym1 d) #
SingI (Tuple3Sym0 :: TyFun a (b ~> (c ~> (a, b, c))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing Tuple3Sym0 #
SFunctor f => SingI ((<$@#@$) :: TyFun a (f b ~> f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (<$@#@$) #
(SEnum a, SingI d1, SingI d2) => SingI (EnumFromThenToSym2 d1 d2 :: TyFun a [a] -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods sing :: Sing (EnumFromThenToSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (UntilSym2 d1 d2 :: TyFun a a -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (UntilSym2 d1 d2) #
SingI d => SingI (($!@#@$$) d :: TyFun a b -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (($!@#@$$) d) #
SingI d => SingI (($@#@$$) d :: TyFun a b -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (($@#@$$) d) #
SingI d => SingI (ArgSym1 d :: TyFun b (Arg a b) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods sing :: Sing (ArgSym1 d) #
SingI d => SingI (ScanlSym1 d :: TyFun b ([a] ~> [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ScanlSym1 d) #
SingI d => SingI (ScanrSym1 d :: TyFun b ([a] ~> [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ScanrSym1 d) #
SingI d => SingI (ListscanlSym1 d :: TyFun b ([a] ~> [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListscanlSym1 d) #
SingI d => SingI (ListscanrSym1 d :: TyFun b ([a] ~> [b]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListscanrSym1 d) #
SingI d => SingI (Foldl'Sym1 d :: TyFun b ([a] ~> b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Foldl'Sym1 d) #
SingI d => SingI (Listfoldl'Sym1 d :: TyFun b ([a] ~> b) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (Listfoldl'Sym1 d) #
SingI d => SingI (ListfoldlSym1 d :: TyFun b ([a] ~> b) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListfoldlSym1 d) #
SingI d => SingI (ListfoldrSym1 d :: TyFun b ([a] ~> b) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListfoldrSym1 d) #
SingI d => SingI (FoldlSym1 d :: TyFun b ([a] ~> b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (FoldlSym1 d) #
SingI d => SingI (FoldrSym1 d :: TyFun b ([a] ~> b) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (FoldrSym1 d) #
(SOrd a, SingI d) => SingI (ComparingSym1 d :: TyFun b (b ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (ComparingSym1 d) #
SingI d => SingI (Tuple2Sym1 d :: TyFun b (a, b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple2Sym1 d) #
SingI d => SingI (UnfoldrSym1 d :: TyFun b [a] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (UnfoldrSym1 d) #
SingI d => SingI (ConstSym1 d :: TyFun b a -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (ConstSym1 d) #
SingI d => SingI (SeqSym1 d :: TyFun b b -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (SeqSym1 d) #
SApplicative f => SingI ((<*>@#@$) :: TyFun (f (a ~> b)) (f a ~> f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (<*>@#@$) #
SFunctor f => SingI ((<&>@#@$) :: TyFun (f a) ((a ~> b) ~> f b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing (<&>@#@$) #
SFunctor f => SingI (($>@#@$) :: TyFun (f a) (b ~> f b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing ($>@#@$) #
SApplicative f => SingI ((<**>@#@$) :: TyFun (f a) (f (a ~> b) ~> f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (<**>@#@$) #
SAlternative f => SingI ((<\|>@#@$) :: TyFun (f a) (f a ~> f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (<\|>@#@$) #
(forall (a :: k1). SingI a => SingI (f a), (ApplyTyCon :: (k1 -> kr) -> k1 ~> kr) ~ (ApplyTyConAux1 :: (k1 -> kr) -> TyFun k1 kr -> Type)) => SingI (TyCon1 f :: k1 ~> kr)
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon1 f) #
SMonad m => SingI (ApSym0 :: TyFun (m (a ~> b)) (m a ~> m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ApSym0 #
SMonad m => SingI ((>>=@#@$) :: TyFun (m a) ((a ~> m b) ~> m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (>>=@#@$) #
SMonadPlus m => SingI (MplusSym0 :: TyFun (m a) (m a ~> m a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing MplusSym0 #
(SApplicative m, SingI d) => SingI (ReplicateM_Sym1 d :: TyFun (m a) (m ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (ReplicateM_Sym1 d) #
(SApplicative m, SingI d) => SingI (ReplicateMSym1 d :: TyFun (m a) (m [a]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (ReplicateMSym1 d) #
(SMonadPlus m, SingI d) => SingI (MfilterSym1 d :: TyFun (m a) (m a) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (MfilterSym1 d) #
SingI d => SingI (AsProxyTypeOfSym1 d :: TyFun (proxy a) a -> Type)
Instance details Defined in Data.Proxy.Singletons Methods sing :: Sing (AsProxyTypeOfSym1 d) #
SingI d => SingI (RunStateLSym1 d :: TyFun s (s, a) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (RunStateLSym1 d) #
SingI d => SingI (RunStateRSym1 d :: TyFun s (s, a) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (RunStateRSym1 d) #
(SFoldable t, SingI d) => SingI (FindSym1 d :: TyFun (t a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FindSym1 d) #
(SFoldable t, SingI d) => SingI (AllSym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (AllSym1 d) #
(SFoldable t, SingI d) => SingI (AnySym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (AnySym1 d) #
(SFoldable t, SEq a, SingI d) => SingI (ElemSym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (ElemSym1 d) #
(SFoldable t, SEq a, SingI d) => SingI (NotElemSym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (NotElemSym1 d) #
SFoldable t => SingI (NullSym0 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing NullSym0 #
SFoldable t => SingI (LengthSym0 :: TyFun (t a) Nat -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing LengthSym0 #
(SFoldable t, SingI d) => SingI (Foldl1Sym1 d :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Foldl1Sym1 d) #
(SFoldable t, SingI d) => SingI (Foldr1Sym1 d :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Foldr1Sym1 d) #
(SFoldable t, SingI d) => SingI (MaximumBySym1 d :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (MaximumBySym1 d) #
(SFoldable t, SingI d) => SingI (MinimumBySym1 d :: TyFun (t a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (MinimumBySym1 d) #
(SFoldable t, SApplicative f) => SingI (SequenceA_Sym0 :: TyFun (t (f a)) (f ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing SequenceA_Sym0 #
(STraversable t, SApplicative f) => SingI (SequenceASym0 :: TyFun (t (f a)) (f (t a)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing SequenceASym0 #
(SFoldable t, SMonad m) => SingI (Sequence_Sym0 :: TyFun (t (m a)) (m ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing Sequence_Sym0 #
(STraversable t, SMonad m) => SingI (SequenceSym0 :: TyFun (t (m a)) (m (t a)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing SequenceSym0 #
SingI (ConstSym0 :: TyFun a (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods sing :: Sing ConstSym0 #
(SingI c, SingI t) => SingI (IfSym2 c t :: TyFun k k -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (IfSym2 c t) #
SingI (ZipWith3Sym0 :: TyFun (a ~> (b ~> (c ~> d))) ([a] ~> ([b] ~> ([c] ~> [d]))) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ZipWith3Sym0 #
STraversable t => SingI (MapAccumLSym0 :: TyFun (a ~> (b ~> (a, c))) (a ~> (t b ~> (a, t c))) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing MapAccumLSym0 #
STraversable t => SingI (MapAccumRSym0 :: TyFun (a ~> (b ~> (a, c))) (a ~> (t b ~> (a, t c))) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing MapAccumRSym0 #
SApplicative f => SingI (LiftA2Sym0 :: TyFun (a ~> (b ~> c)) (f a ~> (f b ~> f c)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftA2Sym0 #
(SFoldable t, SMonad m) => SingI (FoldrMSym0 :: TyFun (a ~> (b ~> m b)) (b ~> (t a ~> m b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FoldrMSym0 #
SApplicative m => SingI (ZipWithM_Sym0 :: TyFun (a ~> (b ~> m c)) ([a] ~> ([b] ~> m ())) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ZipWithM_Sym0 #
SApplicative m => SingI (ZipWithMSym0 :: TyFun (a ~> (b ~> m c)) ([a] ~> ([b] ~> m [c])) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ZipWithMSym0 #
SingI d => SingI ((.@#@$$) d :: TyFun (a ~> b) (a ~> c) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing ((.@#@$$) d) #
(SFunctor f, SingI d) => SingI ((<&>@#@$$) d :: TyFun (a ~> b) (f b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing ((<&>@#@$$) d) #
(SFoldable t, SApplicative f) => SingI (Traverse_Sym0 :: TyFun (a ~> f b) (t a ~> f ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing Traverse_Sym0 #
(STraversable t, SApplicative f) => SingI (TraverseSym0 :: TyFun (a ~> f b) (t a ~> f (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing TraverseSym0 #
SApplicative m => SingI (MapAndUnzipMSym0 :: TyFun (a ~> m (b, c)) ([a] ~> m ([b], [c])) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing MapAndUnzipMSym0 #
SMonad m => SingI ((>=>@#@$) :: TyFun (a ~> m b) ((b ~> m c) ~> (a ~> m c)) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (>=>@#@$) #
(SFoldable t, SMonad m) => SingI (MapM_Sym0 :: TyFun (a ~> m b) (t a ~> m ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MapM_Sym0 #
(STraversable t, SMonad m) => SingI (MapMSym0 :: TyFun (a ~> m b) (t a ~> m (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing MapMSym0 #
(SMonad m, SingI d) => SingI ((>>=@#@$$) d :: TyFun (a ~> m b) (m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((>>=@#@$$) d) #
SMonad m => SingI (LiftM2Sym0 :: TyFun (a1 ~> (a2 ~> r)) (m a1 ~> (m a2 ~> m r)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftM2Sym0 #
(SFoldable t, SMonad m) => SingI (FoldM_Sym0 :: TyFun (b ~> (a ~> m b)) (b ~> (t a ~> m ())) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing FoldM_Sym0 #
(SFoldable t, SMonad m) => SingI (FoldMSym0 :: TyFun (b ~> (a ~> m b)) (b ~> (t a ~> m b)) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing FoldMSym0 #
(SFoldable t, SMonad m) => SingI (FoldlMSym0 :: TyFun (b ~> (a ~> m b)) (b ~> (t a ~> m b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FoldlMSym0 #
SingI d => SingI (Either_Sym1 d :: TyFun (b ~> c) (Either a b ~> c) -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing (Either_Sym1 d) #
SMonad m => SingI ((<=<@#@$) :: TyFun (b ~> m c) ((a ~> m b) ~> (a ~> m c)) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (<=<@#@$) #
(SingI d1, SingI d2) => SingI (Maybe_Sym2 d1 d2 :: TyFun (Maybe a) b -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (Maybe_Sym2 d1 d2) #
SingI d => SingI (UncurrySym1 d :: TyFun (a, b) c -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing (UncurrySym1 d) #
SingI (Unzip4Sym0 :: TyFun [(a, b, c, d)] ([a], [b], [c], [d]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Unzip4Sym0 #
SingI d => SingI (ZipWithSym1 d :: TyFun [a] ([b] ~> [c]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ZipWithSym1 d) #
SingI d => SingI (ListzipWithSym1 d :: TyFun [a] ([b] ~> [c]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListzipWithSym1 d) #
(SingI d1, SingI d2) => SingI (ScanlSym2 d1 d2 :: TyFun [a] [b] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ScanlSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ScanrSym2 d1 d2 :: TyFun [a] [b] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ScanrSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ListscanlSym2 d1 d2 :: TyFun [a] [b] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListscanlSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ListscanrSym2 d1 d2 :: TyFun [a] [b] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListscanrSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (Foldl'Sym2 d1 d2 :: TyFun [a] b -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Foldl'Sym2 d1 d2) #
(SingI d1, SingI d2) => SingI (Listfoldl'Sym2 d1 d2 :: TyFun [a] b -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (Listfoldl'Sym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ListfoldlSym2 d1 d2 :: TyFun [a] b -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListfoldlSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ListfoldrSym2 d1 d2 :: TyFun [a] b -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListfoldrSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (FoldlSym2 d1 d2 :: TyFun [a] b -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (FoldlSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (FoldrSym2 d1 d2 :: TyFun [a] b -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (FoldrSym2 d1 d2) #
SingI d => SingI (Zip3Sym1 d :: TyFun [b] ([c] ~> [(a, b, c)]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Zip3Sym1 d) #
SingI (Tuple4Sym0 :: TyFun a (b ~> (c ~> (d ~> (a, b, c, d)))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing Tuple4Sym0 #
SingI d => SingI (CurrySym1 d :: TyFun a (b ~> c) -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing (CurrySym1 d) #
SingI d => SingI (MapAccumLSym1 d :: TyFun acc ([x] ~> (acc, [y])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (MapAccumLSym1 d) #
SingI d => SingI (MapAccumRSym1 d :: TyFun acc ([x] ~> (acc, [y])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (MapAccumRSym1 d) #
(SOrd a, SingI d1, SingI d2) => SingI (ComparingSym2 d1 d2 :: TyFun b Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (ComparingSym2 d1 d2) #
SingI d => SingI (FlipSym1 d :: TyFun b (a ~> c) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (FlipSym1 d) #
SingI d => SingI (Tuple3Sym1 d :: TyFun b (c ~> (a, b, c)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple3Sym1 d) #
(SFoldable t, SingI d) => SingI (Foldl'Sym1 d :: TyFun b (t a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Foldl'Sym1 d) #
(SFoldable t, SingI d) => SingI (FoldlSym1 d :: TyFun b (t a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldlSym1 d) #
(SFoldable t, SingI d) => SingI (Foldr'Sym1 d :: TyFun b (t a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Foldr'Sym1 d) #
(SFoldable t, SingI d) => SingI (FoldrSym1 d :: TyFun b (t a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldrSym1 d) #
(SFunctor f, SingI d) => SingI (($>@#@$$) d :: TyFun b (f b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing (($>@#@$$) d) #
(SApplicative f, SingI d) => SingI ((<**>@#@$$) d :: TyFun (f (a ~> b)) (f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((<**>@#@$$) d) #
SApplicative f => SingI ((<*@#@$) :: TyFun (f a) (f b ~> f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (<*@#@$) #
SApplicative f => SingI ((*>@#@$) :: TyFun (f a) (f b ~> f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (*>@#@$) #
(SAlternative f, SingI d) => SingI ((<\|>@#@$$) d :: TyFun (f a) (f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((<\|>@#@$$) d) #
(SApplicative f, SingI d) => SingI ((<*>@#@$$) d :: TyFun (f a) (f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((<*>@#@$$) d) #
(SFunctor f, SingI d) => SingI (FmapSym1 d :: TyFun (f a) (f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (FmapSym1 d) #
(SApplicative f, SingI d) => SingI (LiftASym1 d :: TyFun (f a) (f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftASym1 d) #
(SFunctor f, SingI d) => SingI ((<$>@#@$$) d :: TyFun (f a) (f b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods sing :: Sing ((<$>@#@$$) d) #
(SFunctor f, SingI d) => SingI ((<$@#@$$) d :: TyFun (f b) (f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((<$@#@$$) d) #
(forall (a :: k1) (b :: k2). (SingI a, SingI b) => SingI (f a b), (ApplyTyCon :: (k2 -> kr) -> k2 ~> kr) ~ (ApplyTyConAux1 :: (k2 -> kr) -> TyFun k2 kr -> Type)) => SingI (TyCon2 f :: k1 ~> (k2 ~> kr))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon2 f) #
SMonad m => SingI ((>>@#@$) :: TyFun (m a) (m b ~> m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (>>@#@$) #
(SMonadPlus m, SingI d) => SingI (MplusSym1 d :: TyFun (m a) (m a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (MplusSym1 d) #
(SMonad m, SingI d) => SingI ((<$!>@#@$$) d :: TyFun (m a) (m b) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ((<$!>@#@$$) d) #
(SMonad m, SingI d) => SingI ((=<<@#@$$) d :: TyFun (m a) (m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((=<<@#@$$) d) #
(SMonad m, SingI d) => SingI (ApSym1 d :: TyFun (m a) (m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (ApSym1 d) #
(SMonad m, SingI d) => SingI (LiftMSym1 d :: TyFun (m a1) (m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftMSym1 d) #
(SFoldable t, SApplicative f) => SingI (For_Sym0 :: TyFun (t a) ((a ~> f b) ~> f ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing For_Sym0 #
(STraversable t, SApplicative f) => SingI (ForSym0 :: TyFun (t a) ((a ~> f b) ~> f (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing ForSym0 #
(SFoldable t, SMonad m) => SingI (ForM_Sym0 :: TyFun (t a) ((a ~> m b) ~> m ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ForM_Sym0 #
(STraversable t, SMonad m) => SingI (ForMSym0 :: TyFun (t a) ((a ~> m b) ~> m (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing ForMSym0 #
(SFoldable t, SingI d) => SingI (ConcatMapSym1 d :: TyFun (t a) [b] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (ConcatMapSym1 d) #
(SFoldable t, SMonoid m, SingI d) => SingI (FoldMapSym1 d :: TyFun (t a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldMapSym1 d) #
(STraversable t, SMonoid m, SingI d) => SingI (FoldMapDefaultSym1 d :: TyFun (t a) m -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (FoldMapDefaultSym1 d) #
(STraversable t, SingI d) => SingI (FmapDefaultSym1 d :: TyFun (t a) (t b) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (FmapDefaultSym1 d) #
(SFoldable t, SAlternative f) => SingI (AsumSym0 :: TyFun (t (f a)) (f a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AsumSym0 #
(SFoldable t, SMonadPlus m) => SingI (MsumSym0 :: TyFun (t (m a)) (m a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MsumSym0 #
(SingI d1, SingI d2) => SingI (Either_Sym2 d1 d2 :: TyFun (Either a b) c -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing (Either_Sym2 d1 d2) #
SApplicative f => SingI (LiftA3Sym0 :: TyFun (a ~> (b ~> (c ~> d))) (f a ~> (f b ~> (f c ~> f d))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftA3Sym0 #
(SFoldable t, SApplicative f, SingI d) => SingI (For_Sym1 d :: TyFun (a ~> f b) (f ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (For_Sym1 d) #
(STraversable t, SApplicative f, SingI d) => SingI (ForSym1 d :: TyFun (a ~> f b) (f (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (ForSym1 d) #
(SMonad m, SingI d) => SingI ((<=<@#@$$) d :: TyFun (a ~> m b) (a ~> m c) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ((<=<@#@$$) d) #
(SFoldable t, SMonad m, SingI d) => SingI (ForM_Sym1 d :: TyFun (a ~> m b) (m ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (ForM_Sym1 d) #
(STraversable t, SMonad m, SingI d) => SingI (ForMSym1 d :: TyFun (a ~> m b) (m (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (ForMSym1 d) #
SMonad m => SingI (LiftM3Sym0 :: TyFun (a1 ~> (a2 ~> (a3 ~> r))) (m a1 ~> (m a2 ~> (m a3 ~> m r))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftM3Sym0 #
(SMonad m, SingI d) => SingI ((>=>@#@$$) d :: TyFun (b ~> m c) (a ~> m c) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing ((>=>@#@$$) d) #
SingI (Unzip5Sym0 :: TyFun [(a, b, c, d, e)] ([a], [b], [c], [d], [e]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Unzip5Sym0 #
SingI d2 => SingI (ZipWith3Sym1 d2 :: TyFun [a] ([b] ~> ([c] ~> [d1])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ZipWith3Sym1 d2) #
(SApplicative m, SingI d) => SingI (ZipWithM_Sym1 d :: TyFun [a] ([b] ~> m ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (ZipWithM_Sym1 d) #
(SApplicative m, SingI d) => SingI (ZipWithMSym1 d :: TyFun [a] ([b] ~> m [c]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (ZipWithMSym1 d) #
(SApplicative m, SingI d) => SingI (MapAndUnzipMSym1 d :: TyFun [a] (m ([b], [c])) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (MapAndUnzipMSym1 d) #
(SingI d1, SingI d2) => SingI (ZipWithSym2 d1 d2 :: TyFun [b] [c] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ZipWithSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (ListzipWithSym2 d1 d2 :: TyFun [b] [c] -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListzipWithSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (Zip3Sym2 d1 d2 :: TyFun [c] [(a, b, c)] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Zip3Sym2 d1 d2) #
(SingI d1, SingI d2) => SingI (MapAccumLSym2 d1 d2 :: TyFun [x] (acc, [y]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (MapAccumLSym2 d1 d2) #
(SingI d1, SingI d2) => SingI (MapAccumRSym2 d1 d2 :: TyFun [x] (acc, [y]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (MapAccumRSym2 d1 d2) #
SingI (Tuple5Sym0 :: TyFun a (b ~> (c ~> (d ~> (e ~> (a, b, c, d, e))))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing Tuple5Sym0 #
(STraversable t, SingI d) => SingI (MapAccumLSym1 d :: TyFun a (t b ~> (a, t c)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (MapAccumLSym1 d) #
(STraversable t, SingI d) => SingI (MapAccumRSym1 d :: TyFun a (t b ~> (a, t c)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (MapAccumRSym1 d) #
(SingI d1, SingI d2) => SingI (d1 .@#@$$$ d2 :: TyFun a c -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (d1 .@#@$$$ d2) #
(SingI d1, SingI d2) => SingI (FlipSym2 d1 d2 :: TyFun a c -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing (FlipSym2 d1 d2) #
SingI d1 => SingI (Tuple4Sym1 d1 :: TyFun b (c ~> (d2 ~> (a, b, c, d2))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple4Sym1 d1) #
(SFoldable t, SMonad m, SingI d) => SingI (FoldM_Sym1 d :: TyFun b (t a ~> m ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (FoldM_Sym1 d) #
(SFoldable t, SMonad m, SingI d) => SingI (FoldMSym1 d :: TyFun b (t a ~> m b) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (FoldMSym1 d) #
(SFoldable t, SMonad m, SingI d) => SingI (FoldlMSym1 d :: TyFun b (t a ~> m b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldlMSym1 d) #
(SFoldable t, SMonad m, SingI d) => SingI (FoldrMSym1 d :: TyFun b (t a ~> m b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldrMSym1 d) #
(SingI d1, SingI d2) => SingI (CurrySym2 d1 d2 :: TyFun b c -> Type)
Instance details Defined in Data.Tuple.Singletons Methods sing :: Sing (CurrySym2 d1 d2) #
(SingI d1, SingI d2) => SingI (Tuple3Sym2 d1 d2 :: TyFun c (a, b, c) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple3Sym2 d1 d2) #
(SApplicative f, SingI d) => SingI (LiftA2Sym1 d :: TyFun (f a) (f b ~> f c) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftA2Sym1 d) #
(SApplicative f, SingI d) => SingI ((<*@#@$$) d :: TyFun (f b) (f a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((<*@#@$$) d) #
(SApplicative f, SingI d) => SingI ((*>@#@$$) d :: TyFun (f b) (f b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((*>@#@$$) d) #
(forall (a :: k1) (b :: k2) (c :: k3). (SingI a, SingI b, SingI c) => SingI (f a b c), (ApplyTyCon :: (k3 -> kr) -> k3 ~> kr) ~ (ApplyTyConAux1 :: (k3 -> kr) -> TyFun k3 kr -> Type)) => SingI (TyCon3 f :: k1 ~> (k2 ~> (k3 ~> kr)))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon3 f) #
(SMonad m, SingI d) => SingI (LiftM2Sym1 d :: TyFun (m a1) (m a2 ~> m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM2Sym1 d) #
(SMonad m, SingI d) => SingI ((>>@#@$$) d :: TyFun (m b) (m b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing ((>>@#@$$) d) #
(SFoldable t, SingI d1, SingI d2) => SingI (Foldl'Sym2 d1 d2 :: TyFun (t a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Foldl'Sym2 d1 d2) #
(SFoldable t, SingI d1, SingI d2) => SingI (FoldlSym2 d1 d2 :: TyFun (t a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldlSym2 d1 d2) #
(SFoldable t, SingI d1, SingI d2) => SingI (Foldr'Sym2 d1 d2 :: TyFun (t a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Foldr'Sym2 d1 d2) #
(SFoldable t, SingI d1, SingI d2) => SingI (FoldrSym2 d1 d2 :: TyFun (t a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldrSym2 d1 d2) #
(SFoldable t, SApplicative f, SingI d) => SingI (Traverse_Sym1 d :: TyFun (t a) (f ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (Traverse_Sym1 d) #
(STraversable t, SApplicative f, SingI d) => SingI (TraverseSym1 d :: TyFun (t a) (f (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (TraverseSym1 d) #
(SFoldable t, SMonad m, SingI d) => SingI (MapM_Sym1 d :: TyFun (t a) (m ()) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (MapM_Sym1 d) #
(STraversable t, SMonad m, SingI d) => SingI (MapMSym1 d :: TyFun (t a) (m (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (MapMSym1 d) #
SMonad m => SingI (LiftM4Sym0 :: TyFun (a1 ~> (a2 ~> (a3 ~> (a4 ~> r)))) (m a1 ~> (m a2 ~> (m a3 ~> (m a4 ~> m r)))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftM4Sym0 #
SingI (Unzip6Sym0 :: TyFun [(a, b, c, d, e, f)] ([a], [b], [c], [d], [e], [f]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Unzip6Sym0 #
(SingI d2, SingI d3) => SingI (ZipWith3Sym2 d2 d3 :: TyFun [b] ([c] ~> [d1]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ZipWith3Sym2 d2 d3) #
(SApplicative m, SingI d1, SingI d2) => SingI (ZipWithM_Sym2 d1 d2 :: TyFun [b] (m ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (ZipWithM_Sym2 d1 d2) #
(SApplicative m, SingI d1, SingI d2) => SingI (ZipWithMSym2 d1 d2 :: TyFun [b] (m [c]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (ZipWithMSym2 d1 d2) #
SingI (Tuple6Sym0 :: TyFun a (b ~> (c ~> (d ~> (e ~> (f ~> (a, b, c, d, e, f)))))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing Tuple6Sym0 #
(SMonad m, SingI d1, SingI d2) => SingI (d1 <=<@#@$$$ d2 :: TyFun a (m c) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (d1 <=<@#@$$$ d2) #
(SMonad m, SingI d1, SingI d2) => SingI (d1 >=>@#@$$$ d2 :: TyFun a (m c) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (d1 >=>@#@$$$ d2) #
SingI d1 => SingI (Tuple5Sym1 d1 :: TyFun b (c ~> (d2 ~> (e ~> (a, b, c, d2, e)))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple5Sym1 d1) #
(SingI d1, SingI d2) => SingI (Tuple4Sym2 d1 d2 :: TyFun c (d3 ~> (a, b, c, d3)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple4Sym2 d1 d2) #
(SApplicative f, SingI d2) => SingI (LiftA3Sym1 d2 :: TyFun (f a) (f b ~> (f c ~> f d1)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftA3Sym1 d2) #
(SApplicative f, SingI d1, SingI d2) => SingI (LiftA2Sym2 d1 d2 :: TyFun (f b) (f c) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftA2Sym2 d1 d2) #
(forall (a :: k1) (b :: k2) (c :: k3) (d :: k4). (SingI a, SingI b, SingI c, SingI d) => SingI (f a b c d), (ApplyTyCon :: (k4 -> kr) -> k4 ~> kr) ~ (ApplyTyConAux1 :: (k4 -> kr) -> TyFun k4 kr -> Type)) => SingI (TyCon4 f :: k1 ~> (k2 ~> (k3 ~> (k4 ~> kr))))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon4 f) #
(SMonad m, SingI d) => SingI (LiftM3Sym1 d :: TyFun (m a1) (m a2 ~> (m a3 ~> m r)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM3Sym1 d) #
(SMonad m, SingI d1, SingI d2) => SingI (LiftM2Sym2 d1 d2 :: TyFun (m a2) (m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM2Sym2 d1 d2) #
(SFoldable t, SMonad m, SingI d1, SingI d2) => SingI (FoldM_Sym2 d1 d2 :: TyFun (t a) (m ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (FoldM_Sym2 d1 d2) #
(SFoldable t, SMonad m, SingI d1, SingI d2) => SingI (FoldMSym2 d1 d2 :: TyFun (t a) (m b) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing (FoldMSym2 d1 d2) #
(SFoldable t, SMonad m, SingI d1, SingI d2) => SingI (FoldlMSym2 d1 d2 :: TyFun (t a) (m b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldlMSym2 d1 d2) #
(SFoldable t, SMonad m, SingI d1, SingI d2) => SingI (FoldrMSym2 d1 d2 :: TyFun (t a) (m b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FoldrMSym2 d1 d2) #
(STraversable t, SingI d1, SingI d2) => SingI (MapAccumLSym2 d1 d2 :: TyFun (t b) (a, t c) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (MapAccumLSym2 d1 d2) #
(STraversable t, SingI d1, SingI d2) => SingI (MapAccumRSym2 d1 d2 :: TyFun (t b) (a, t c) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sing :: Sing (MapAccumRSym2 d1 d2) #
SMonad m => SingI (LiftM5Sym0 :: TyFun (a1 ~> (a2 ~> (a3 ~> (a4 ~> (a5 ~> r))))) (m a1 ~> (m a2 ~> (m a3 ~> (m a4 ~> (m a5 ~> m r))))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing LiftM5Sym0 #
SingI (Unzip7Sym0 :: TyFun [(a, b, c, d, e, f, g)] ([a], [b], [c], [d], [e], [f], [g]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Unzip7Sym0 #
(SingI d2, SingI d3, SingI d4) => SingI (ZipWith3Sym3 d2 d3 d4 :: TyFun [c] [d1] -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ZipWith3Sym3 d2 d3 d4) #
SingI (Tuple7Sym0 :: TyFun a (b ~> (c ~> (d ~> (e ~> (f ~> (g ~> (a, b, c, d, e, f, g))))))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing Tuple7Sym0 #
SingI d1 => SingI (Tuple6Sym1 d1 :: TyFun b (c ~> (d2 ~> (e ~> (f ~> (a, b, c, d2, e, f))))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple6Sym1 d1) #
(SingI d1, SingI d2) => SingI (Tuple5Sym2 d1 d2 :: TyFun c (d3 ~> (e ~> (a, b, c, d3, e))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple5Sym2 d1 d2) #
(SingI d1, SingI d2, SingI d3) => SingI (Tuple4Sym3 d1 d2 d3 :: TyFun d4 (a, b, c, d4) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple4Sym3 d1 d2 d3) #
(SApplicative f, SingI d2, SingI d3) => SingI (LiftA3Sym2 d2 d3 :: TyFun (f b) (f c ~> f d1) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftA3Sym2 d2 d3) #
(forall (a :: k1) (b :: k2) (c :: k3) (d :: k4) (e :: k5). (SingI a, SingI b, SingI c, SingI d, SingI e) => SingI (f a b c d e), (ApplyTyCon :: (k5 -> kr) -> k5 ~> kr) ~ (ApplyTyConAux1 :: (k5 -> kr) -> TyFun k5 kr -> Type)) => SingI (TyCon5 f :: k1 ~> (k2 ~> (k3 ~> (k4 ~> (k5 ~> kr)))))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon5 f) #
(SMonad m, SingI d) => SingI (LiftM4Sym1 d :: TyFun (m a1) (m a2 ~> (m a3 ~> (m a4 ~> m r))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM4Sym1 d) #
(SMonad m, SingI d1, SingI d2) => SingI (LiftM3Sym2 d1 d2 :: TyFun (m a2) (m a3 ~> m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM3Sym2 d1 d2) #
SingI d1 => SingI (Tuple7Sym1 d1 :: TyFun b (c ~> (d2 ~> (e ~> (f ~> (g ~> (a, b, c, d2, e, f, g)))))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple7Sym1 d1) #
(SingI d1, SingI d2) => SingI (Tuple6Sym2 d1 d2 :: TyFun c (d3 ~> (e ~> (f ~> (a, b, c, d3, e, f)))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple6Sym2 d1 d2) #
(SingI d1, SingI d2, SingI d3) => SingI (Tuple5Sym3 d1 d2 d3 :: TyFun d4 (e ~> (a, b, c, d4, e)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple5Sym3 d1 d2 d3) #
(SApplicative f, SingI d2, SingI d3, SingI d4) => SingI (LiftA3Sym3 d2 d3 d4 :: TyFun (f c) (f d1) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftA3Sym3 d2 d3 d4) #
(forall (a :: k1) (b :: k2) (c :: k3) (d :: k4) (e :: k5) (f' :: k6). (SingI a, SingI b, SingI c, SingI d, SingI e, SingI f') => SingI (f a b c d e f'), (ApplyTyCon :: (k6 -> kr) -> k6 ~> kr) ~ (ApplyTyConAux1 :: (k6 -> kr) -> TyFun k6 kr -> Type)) => SingI (TyCon6 f :: k1 ~> (k2 ~> (k3 ~> (k4 ~> (k5 ~> (k6 ~> kr))))))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon6 f) #
(SMonad m, SingI d) => SingI (LiftM5Sym1 d :: TyFun (m a1) (m a2 ~> (m a3 ~> (m a4 ~> (m a5 ~> m r)))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM5Sym1 d) #
(SMonad m, SingI d1, SingI d2) => SingI (LiftM4Sym2 d1 d2 :: TyFun (m a2) (m a3 ~> (m a4 ~> m r)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM4Sym2 d1 d2) #
(SMonad m, SingI d1, SingI d2, SingI d3) => SingI (LiftM3Sym3 d1 d2 d3 :: TyFun (m a3) (m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM3Sym3 d1 d2 d3) #
(SingI d1, SingI d2) => SingI (Tuple7Sym2 d1 d2 :: TyFun c (d3 ~> (e ~> (f ~> (g ~> (a, b, c, d3, e, f, g))))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple7Sym2 d1 d2) #
(SingI d1, SingI d2, SingI d3) => SingI (Tuple6Sym3 d1 d2 d3 :: TyFun d4 (e ~> (f ~> (a, b, c, d4, e, f))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple6Sym3 d1 d2 d3) #
(SingI d1, SingI d2, SingI d3, SingI d5) => SingI (Tuple5Sym4 d1 d2 d3 d5 :: TyFun e (a, b, c, d4, e) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple5Sym4 d1 d2 d3 d5) #
(forall (a :: k1) (b :: k2) (c :: k3) (d :: k4) (e :: k5) (f' :: k6) (g :: k7). (SingI a, SingI b, SingI c, SingI d, SingI e, SingI f', SingI g) => SingI (f a b c d e f' g), (ApplyTyCon :: (k7 -> kr) -> k7 ~> kr) ~ (ApplyTyConAux1 :: (k7 -> kr) -> TyFun k7 kr -> Type)) => SingI (TyCon7 f :: k1 ~> (k2 ~> (k3 ~> (k4 ~> (k5 ~> (k6 ~> (k7 ~> kr)))))))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon7 f) #
(SMonad m, SingI d1, SingI d2) => SingI (LiftM5Sym2 d1 d2 :: TyFun (m a2) (m a3 ~> (m a4 ~> (m a5 ~> m r))) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM5Sym2 d1 d2) #
(SMonad m, SingI d1, SingI d2, SingI d3) => SingI (LiftM4Sym3 d1 d2 d3 :: TyFun (m a3) (m a4 ~> m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM4Sym3 d1 d2 d3) #
(SingI d1, SingI d2, SingI d3) => SingI (Tuple7Sym3 d1 d2 d3 :: TyFun d4 (e ~> (f ~> (g ~> (a, b, c, d4, e, f, g)))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple7Sym3 d1 d2 d3) #
(SingI d1, SingI d2, SingI d3, SingI d5) => SingI (Tuple6Sym4 d1 d2 d3 d5 :: TyFun e (f ~> (a, b, c, d4, e, f)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple6Sym4 d1 d2 d3 d5) #
(forall (a :: k1) (b :: k2) (c :: k3) (d :: k4) (e :: k5) (f' :: k6) (g :: k7) (h :: k8). (SingI a, SingI b, SingI c, SingI d, SingI e, SingI f', SingI g, SingI h) => SingI (f a b c d e f' g h), (ApplyTyCon :: (k8 -> kr) -> k8 ~> kr) ~ (ApplyTyConAux1 :: (k8 -> kr) -> TyFun k8 kr -> Type)) => SingI (TyCon8 f :: k1 ~> (k2 ~> (k3 ~> (k4 ~> (k5 ~> (k6 ~> (k7 ~> (k8 ~> kr))))))))
Instance details Defined in Data.Singletons Methods sing :: Sing (TyCon8 f) #
(SMonad m, SingI d1, SingI d2, SingI d3) => SingI (LiftM5Sym3 d1 d2 d3 :: TyFun (m a3) (m a4 ~> (m a5 ~> m r)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM5Sym3 d1 d2 d3) #
(SMonad m, SingI d1, SingI d2, SingI d3, SingI d4) => SingI (LiftM4Sym4 d1 d2 d3 d4 :: TyFun (m a4) (m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM4Sym4 d1 d2 d3 d4) #
(SingI d1, SingI d2, SingI d3, SingI d5) => SingI (Tuple7Sym4 d1 d2 d3 d5 :: TyFun e (f ~> (g ~> (a, b, c, d4, e, f, g))) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple7Sym4 d1 d2 d3 d5) #
(SingI d1, SingI d2, SingI d3, SingI d5, SingI d6) => SingI (Tuple6Sym5 d1 d2 d3 d5 d6 :: TyFun f (a, b, c, d4, e, f) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple6Sym5 d1 d2 d3 d5 d6) #
(SMonad m, SingI d1, SingI d2, SingI d3, SingI d4) => SingI (LiftM5Sym4 d1 d2 d3 d4 :: TyFun (m a4) (m a5 ~> m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM5Sym4 d1 d2 d3 d4) #
(SingI d1, SingI d2, SingI d3, SingI d5, SingI d6) => SingI (Tuple7Sym5 d1 d2 d3 d5 d6 :: TyFun f (g ~> (a, b, c, d4, e, f, g)) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple7Sym5 d1 d2 d3 d5 d6) #
(SMonad m, SingI d1, SingI d2, SingI d3, SingI d4, SingI d5) => SingI (LiftM5Sym5 d1 d2 d3 d4 d5 :: TyFun (m a5) (m r) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing (LiftM5Sym5 d1 d2 d3 d4 d5) #
(SingI d1, SingI d2, SingI d3, SingI d5, SingI d6, SingI d7) => SingI (Tuple7Sym6 d1 d2 d3 d5 d6 d7 :: TyFun g (a, b, c, d4, e, f, g) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (Tuple7Sym6 d1 d2 d3 d5 d6 d7) #

type Path = [Branch] Source #

Path to a leaf (some field or constructor) in generic tree representation.

data Branch Source #

Which branch to choose in generic tree representation: left, straight or right. S is used when there is one constructor with one field (something newtype-like).

The reason why we need S can be explained by this example: data A = A1 B | A2 Integer data B = B Bool Now we may search for A1 constructor or B constructor. Without S in both cases path will be the same ([L]).

Constructors

L
S
R

data Constrained c f where Source #

Bundled Patterns

pattern SomePackedVal :: () => PackedValScope t => Value t -> SomePackedVal
pattern SomeConstant :: () => ConstantScope t => Value t -> SomeConstant
pattern SomeConstrainedValue :: forall c. () => forall a. c a => Value a -> SomeConstrainedValue c
pattern SomeStorage :: () => StorageScope t => Value t -> SomeStorage
pattern SomeValue :: () => SingI t => Value t -> SomeValue

Instances

Instances details

FromJSON Address Source #
Instance details Defined in Morley.Tezos.Address Methods parseJSON :: Value -> Parser Address # parseJSONList :: Value -> Parser [Address] #
FromJSONKey Address Source #
Instance details Defined in Morley.Tezos.Address Methods fromJSONKey :: FromJSONKeyFunction Address # fromJSONKeyList :: FromJSONKeyFunction [Address] #
HasRPCRepr Address Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Address Source #
TypeHasDoc Address Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Address :: FieldDescriptions Source # Methods typeDocName :: Proxy Address -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Address -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Address -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Address Source # typeDocMichelsonRep :: TypeDocMichelsonRep Address Source #
IsoValue Address Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Address :: T Source # Methods toVal :: Address -> Value (ToT Address) Source # fromVal :: Value (ToT Address) -> Address Source #
HasCLReader Address Source #
Instance details Defined in Morley.Tezos.Address Methods getReader :: ReadM Address Source # getMetavar :: String Source #
(forall (a :: k). c a => Lift (f a)) => Lift (Constrained c f :: Type) Source #
Instance details Defined in Morley.Util.Constrained Methods lift :: Quote m => Constrained c f -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Constrained c f -> Code m (Constrained c f) #
SingI kinds => FromJSON (ConstrainedAddress kinds) Source #
Instance details Defined in Morley.Tezos.Address Methods parseJSON :: Value -> Parser (ConstrainedAddress kinds) # parseJSONList :: Value -> Parser [ConstrainedAddress kinds] #
(forall (t :: T). cs t => HasNoOp t) => RenderDoc (SomeConstrainedValue cs) Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods renderDoc :: RenderContext -> SomeConstrainedValue cs -> Doc Source # isRenderable :: SomeConstrainedValue cs -> Bool Source #
SingI ks => HasCLReader (ConstrainedAddress ks) Source #
Instance details Defined in Morley.Tezos.Address Methods getReader :: ReadM (ConstrainedAddress ks) Source # getMetavar :: String Source #
ToJSON (Constrained c KindedAddress) Source #
Instance details Defined in Morley.Tezos.Address Methods toJSON :: Constrained c KindedAddress -> Value # toEncoding :: Constrained c KindedAddress -> Encoding # toJSONList :: [Constrained c KindedAddress] -> Value # toEncodingList :: [Constrained c KindedAddress] -> Encoding #
ToJSONKey (Constrained c KindedAddress) Source #
Instance details Defined in Morley.Tezos.Address Methods toJSONKey :: ToJSONKeyFunction (Constrained c KindedAddress) # toJSONKeyList :: ToJSONKeyFunction [Constrained c KindedAddress] #
(forall (a :: k). c a => Show (f a)) => Show (Constrained c f) Source #
Instance details Defined in Morley.Util.Constrained Methods showsPrec :: Int -> Constrained c f -> ShowS # show :: Constrained c f -> String # showList :: [Constrained c f] -> ShowS #
(forall (a :: k). c a => NFData (f a)) => NFData (Constrained c f) Source #
Instance details Defined in Morley.Util.Constrained Methods rnf :: Constrained c f -> () #
(forall (a :: k). c a => Buildable (f a)) => Buildable (Constrained c f) Source #
Instance details Defined in Morley.Util.Constrained Methods build :: Constrained c f -> Builder #
GEq f => Eq (Constrained c f) Source #
Instance details Defined in Morley.Util.Constrained Methods (==) :: Constrained c f -> Constrained c f -> Bool # (/=) :: Constrained c f -> Constrained c f -> Bool #
GCompare f => Ord (Constrained c f) Source #
Instance details Defined in Morley.Util.Constrained Methods compare :: Constrained c f -> Constrained c f -> Ordering # (<) :: Constrained c f -> Constrained c f -> Bool # (<=) :: Constrained c f -> Constrained c f -> Bool # (>) :: Constrained c f -> Constrained c f -> Bool # (>=) :: Constrained c f -> Constrained c f -> Bool # max :: Constrained c f -> Constrained c f -> Constrained c f # min :: Constrained c f -> Constrained c f -> Constrained c f #
type AsRPC Address Source #
Instance details Defined in Morley.AsRPC type AsRPC Address = Address
type TypeDocFieldDescriptions Address Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Address = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Address Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Address = 'TAddress

ligoLayout :: GenericStrategy Source #

Default layout in LIGO.

To be used with customGeneric, see this method for more info.

This is similar to leftBalanced, but

fields are sorted alphabetically;
always puts as large complete binary subtrees as possible at left.

ligoCombLayout :: GenericStrategy Source #

Comb layout in LIGO ( [@layout:comb] ).

To be used with customGeneric.

Note: to make comb layout work for sum types, make sure that in LIGO all the constructors are preceded by the bar symbol in your type declaration:

type my_type =
  [@layout:comb]
  | Ctor1 of nat  ← bar symbol _must_ be here
  | Ctor2 of int
  ...

Though the situation may change: https://gitlab.com/ligolang/ligo/-/issues/1104.

data T Source #

Michelson language type with annotations stripped off.

Instances

Instances details

Data T Source #
Instance details Defined in Morley.Michelson.Typed.T Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> T -> c T # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c T # toConstr :: T -> Constr # dataTypeOf :: T -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c T) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c T) # gmapT :: (forall b. Data b => b -> b) -> T -> T # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> T -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> T -> r # gmapQ :: (forall d. Data d => d -> u) -> T -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> T -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> T -> m T # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> T -> m T # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> T -> m T #
Generic T Source #
Instance details Defined in Morley.Michelson.Typed.T Associated Types type Rep T :: Type -> Type # Methods from :: T -> Rep T x # to :: Rep T x -> T #
Show T Source #
Instance details Defined in Morley.Michelson.Typed.T Methods showsPrec :: Int -> T -> ShowS # show :: T -> String # showList :: [T] -> ShowS #
NFData T Source #
Instance details Defined in Morley.Michelson.Typed.T Methods rnf :: T -> () #
Buildable T Source #
Instance details Defined in Morley.Michelson.Typed.T Methods build :: T -> Builder #
Eq T Source #
Instance details Defined in Morley.Michelson.Typed.T Methods (==) :: T -> T -> Bool # (/=) :: T -> T -> Bool #
ToExpression T Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: T -> Expression Source #
RenderDoc T Source #
Instance details Defined in Morley.Michelson.Typed.T Methods renderDoc :: RenderContext -> T -> Doc Source # isRenderable :: T -> Bool Source #
SingKind T Source #
Instance details Defined in Morley.Michelson.Typed.Sing Associated Types type Demote T = (r :: Type) # Methods fromSing :: forall (a :: T). Sing a -> Demote T # toSing :: Demote T -> SomeSing T #
(SDecide T, SDecide Peano) => SDecide T Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods (%~) :: forall (a :: T) (b :: T). Sing a -> Sing b -> Decision (a :~: b) #
(SDecide T, SDecide Peano) => TestCoercion SingT Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods testCoercion :: forall (a :: k) (b :: k). SingT a -> SingT b -> Maybe (Coercion a b) #
(SDecide T, SDecide Peano) => TestEquality SingT Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods testEquality :: forall (a :: k) (b :: k). SingT a -> SingT b -> Maybe (a :~: b) #
FromExp x T Source #
Instance details Defined in Morley.Micheline.Class Methods fromExp :: Exp x -> Either (FromExpError x) T Source #
SingI 'TAddress Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TAddress #
SingI 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBls12381Fr #
SingI 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBls12381G1 #
SingI 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBls12381G2 #
SingI 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBool #
SingI 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TBytes #
SingI 'TChainId Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TChainId #
SingI 'TChest Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TChest #
SingI 'TChestKey Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TChestKey #
SingI 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TInt #
SingI 'TKey Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TKey #
SingI 'TKeyHash Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TKeyHash #
SingI 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TMutez #
SingI 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TNat #
SingI 'TNever Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TNever #
SingI 'TOperation Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TOperation #
SingI 'TSignature Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TSignature #
SingI 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TString #
SingI 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TTimestamp #
SingI 'TUnit Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing 'TUnit #
SingI n => SingI ('TContract n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TContract n) #
SingI n => SingI ('TList n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TList n) #
SingI n => SingI ('TOption n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TOption n) #
SingI n => SingI ('TSaplingState n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TSaplingState n) #
SingI n => SingI ('TSaplingTransaction n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TSaplingTransaction n) #
SingI n => SingI ('TSet n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TSet n) #
SingI n => SingI ('TTicket n :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TTicket n) #
GEq (Value' instr :: T -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods geq :: forall (a :: k) (b :: k). Value' instr a -> Value' instr b -> Maybe (a :~: b) #
(SingI inp, SingI out) => FromExp RegularExp (Instr '[inp] '[out]) Source #
Instance details Defined in Morley.Micheline.Class Methods fromExp :: Exp RegularExp -> Either (FromExpError RegularExp) (Instr '[inp] '[out]) Source #
(SingI n1, SingI n2) => SingI ('TBigMap n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TBigMap n1 n2) #
(SingI n1, SingI n2) => SingI ('TLambda n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TLambda n1 n2) #
(SingI n1, SingI n2) => SingI ('TMap n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TMap n1 n2) #
(SingI n1, SingI n2) => SingI ('TOr n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TOr n1 n2) #
(SingI n1, SingI n2) => SingI ('TPair n1 n2 :: T) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods sing :: Sing ('TPair n1 n2) #
Buildable (MismatchError T) Source #
Instance details Defined in Morley.Michelson.Typed.T Methods build :: MismatchError T -> Builder #
Buildable (MismatchError [T]) Source #
Instance details Defined in Morley.Michelson.Typed.T Methods build :: MismatchError [T] -> Builder #
RenderDoc (Prettier T) Source #
Instance details Defined in Morley.Michelson.Typed.T Methods renderDoc :: RenderContext -> Prettier T -> Doc Source # isRenderable :: Prettier T -> Bool Source #
(forall (t :: T). cs t => HasNoOp t) => RenderDoc (SomeConstrainedValue cs) Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods renderDoc :: RenderContext -> SomeConstrainedValue cs -> Doc Source # isRenderable :: SomeConstrainedValue cs -> Bool Source #
RenderDoc (MismatchError T) Source #
Instance details Defined in Morley.Michelson.Typed.T Methods renderDoc :: RenderContext -> MismatchError T -> Doc Source # isRenderable :: MismatchError T -> Bool Source #
RenderDoc (MismatchError [T]) Source #
Instance details Defined in Morley.Michelson.Typed.T Methods renderDoc :: RenderContext -> MismatchError [T] -> Doc Source # isRenderable :: MismatchError [T] -> Bool Source #
type Rep T Source #
Instance details Defined in Morley.Michelson.Typed.T type Rep T = D1 ('MetaData "T" "Morley.Michelson.Typed.T" "morley-1.19.1-inplace" 'False) (((((C1 ('MetaCons "TKey" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TUnit" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TSignature" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TChainId" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TOption" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)) :+: C1 ('MetaCons "TList" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T))) :+: (C1 ('MetaCons "TSet" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)) :+: C1 ('MetaCons "TOperation" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "TContract" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)) :+: C1 ('MetaCons "TTicket" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T))) :+: (C1 ('MetaCons "TPair" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)) :+: C1 ('MetaCons "TOr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)))) :+: ((C1 ('MetaCons "TLambda" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)) :+: C1 ('MetaCons "TMap" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T))) :+: (C1 ('MetaCons "TBigMap" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 T)) :+: C1 ('MetaCons "TInt" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "TNat" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TString" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TBytes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TMutez" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TBool" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TKeyHash" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TBls12381Fr" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TBls12381G1" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "TBls12381G2" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TTimestamp" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TAddress" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TChest" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TChestKey" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TSaplingState" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Peano))) :+: (C1 ('MetaCons "TSaplingTransaction" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Peano)) :+: C1 ('MetaCons "TNever" 'PrefixI 'False) (U1 :: Type -> Type))))))
type Demote T Source #
Instance details Defined in Morley.Michelson.Typed.Sing type Demote T = T
type Sing Source #
Instance details Defined in Morley.Michelson.Typed.Sing type Sing = SingT

toUType :: T -> Ty Source #

Converts from T to Ty.

buildStack :: [T] -> Builder Source #

Format type stack in a pretty way.

data SingT :: T -> Type where Source #

Constructors

STKey :: SingT ('TKey :: T)
STUnit :: SingT ('TUnit :: T)
STSignature :: SingT ('TSignature :: T)
STChainId :: SingT ('TChainId :: T)
STOption :: forall (n :: T). (Sing n) -> SingT ('TOption n :: T)
STList :: forall (n :: T). (Sing n) -> SingT ('TList n :: T)
STSet :: forall (n :: T). (Sing n) -> SingT ('TSet n :: T)
STOperation :: SingT ('TOperation :: T)
STContract :: forall (n :: T). (Sing n) -> SingT ('TContract n :: T)
STTicket :: forall (n :: T). (Sing n) -> SingT ('TTicket n :: T)
STPair :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TPair n n :: T)
STOr :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TOr n n :: T)
STLambda :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TLambda n n :: T)
STMap :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TMap n n :: T)
STBigMap :: forall (n :: T) (n :: T). (Sing n) -> (Sing n) -> SingT ('TBigMap n n :: T)
STInt :: SingT ('TInt :: T)
STNat :: SingT ('TNat :: T)
STString :: SingT ('TString :: T)
STBytes :: SingT ('TBytes :: T)
STMutez :: SingT ('TMutez :: T)
STBool :: SingT ('TBool :: T)
STKeyHash :: SingT ('TKeyHash :: T)
STBls12381Fr :: SingT ('TBls12381Fr :: T)
STBls12381G1 :: SingT ('TBls12381G1 :: T)
STBls12381G2 :: SingT ('TBls12381G2 :: T)
STTimestamp :: SingT ('TTimestamp :: T)
STAddress :: SingT ('TAddress :: T)
STChest :: SingT ('TChest :: T)
STChestKey :: SingT ('TChestKey :: T)
STSaplingState :: forall (n :: Nat). (Sing n) -> SingT ('TSaplingState n :: T)
STSaplingTransaction :: forall (n :: Nat). (Sing n) -> SingT ('TSaplingTransaction n :: T)
STNever :: SingT ('TNever :: T)

Instances

Instances details

(SDecide T, SDecide Peano) => TestCoercion SingT Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods testCoercion :: forall (a :: k) (b :: k). SingT a -> SingT b -> Maybe (Coercion a b) #
(SDecide T, SDecide Peano) => TestEquality SingT Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods testEquality :: forall (a :: k) (b :: k). SingT a -> SingT b -> Maybe (a :~: b) #
Show (SingT x) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods showsPrec :: Int -> SingT x -> ShowS # show :: SingT x -> String # showList :: [SingT x] -> ShowS #
NFData (SingT a) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods rnf :: SingT a -> () #
Eq (SingT x) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods (==) :: SingT x -> SingT x -> Bool # (/=) :: SingT x -> SingT x -> Bool #
RenderDoc (SingT t) Source #
Instance details Defined in Morley.Michelson.Typed.Sing Methods renderDoc :: RenderContext -> SingT t -> Doc Source # isRenderable :: SingT t -> Bool Source #

castSingE :: forall (a :: T) (b :: T) t. (SingI a, SingI b) => t a -> Either Text (t b) Source #

Previously, we were using SingI constraints in SingT constructors. That was not so optimal because we have been spending too much space at runtime. Instead of that, we process values of SingT using the function withSingI in those places where the SingI constraint is required. withSingI allows one to create the SingI context for a given Sing.

castM :: forall (a :: T) (b :: T) t m. (SingI a, SingI b, Monad m) => t a -> (forall x. MismatchError T -> m x) -> m (t b) Source #

Monadic version of castSing. Throws an error using the given function if the cast fails.

requireEq :: forall (a :: T) (b :: T) m. (SingI a, SingI b, Monad m) => (forall x. MismatchError T -> m x) -> m (a :~: b) Source #

Monadic version of eqI. Throws an error using the given function if the two types are not equal.

eqP :: forall (a :: T) (b :: T). (SingI a, SingI b) => Proxy a -> Proxy b -> Maybe (a :~: b) Source #

Version of eqI that uses Proxy

data Comparability t where Source #

Constructors

CanBeCompared :: Comparable t => Comparability t
CannotBeCompared :: IsComparable t ~ 'False => Comparability t

data NotWellTyped Source #

Error type for when a value is not well-typed.

Constructors

NotWellTyped
Fields nwtBadType :: T nwtCause :: BadTypeForScope

Instances

Instances details

Buildable NotWellTyped Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods build :: NotWellTyped -> Builder #

class (SingI t, WellTypedSuperC t) => WellTyped (t :: T) Source #

This class encodes Michelson rules w.r.t where it requires comparable types. Earlier we had a dedicated type for representing comparable types CT. But then we integreated those types into T. This meant that some of the types that could be formed with various combinations of T would be illegal as per Michelson typing rule. Using this class, we inductively enforce that a type and all types it contains are well typed as per Michelson's rules.

Associated Types

type WellTypedSuperC t :: Constraint Source #

Constraints required for instance of a given type.

type WellTypedSuperC _ = ()

Instances

Instances details

WellTyped 'TAddress Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TAddress Source #
WellTyped 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TBls12381Fr Source #
WellTyped 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TBls12381G1 Source #
WellTyped 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TBls12381G2 Source #
WellTyped 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TBool Source #
WellTyped 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TBytes Source #
WellTyped 'TChainId Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TChainId Source #
WellTyped 'TChest Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TChest Source #
WellTyped 'TChestKey Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TChestKey Source #
WellTyped 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TInt Source #
WellTyped 'TKey Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TKey Source #
WellTyped 'TKeyHash Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TKeyHash Source #
WellTyped 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TMutez Source #
WellTyped 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TNat Source #
WellTyped 'TNever Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TNever Source #
WellTyped 'TOperation Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TOperation Source #
WellTyped 'TSignature Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TSignature Source #
WellTyped 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TString Source #
WellTyped 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TTimestamp Source #
WellTyped 'TUnit Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC 'TUnit Source #
SingI t => CheckScope (WellTyped t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (WellTyped t)) Source #
WellTypedSuperC ('TContract t) => WellTyped ('TContract t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TContract t) Source #
WellTypedSuperC ('TList t) => WellTyped ('TList t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TList t) Source #
WellTypedSuperC ('TOption t) => WellTyped ('TOption t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TOption t) Source #
SingI n => WellTyped ('TSaplingState n) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TSaplingState n) Source #
SingI n => WellTyped ('TSaplingTransaction n) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TSaplingTransaction n) Source #
WellTypedSuperC ('TSet t) => WellTyped ('TSet t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TSet t) Source #
WellTypedSuperC ('TTicket t) => WellTyped ('TTicket t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TTicket t) Source #
WellTypedSuperC ('TBigMap k v) => WellTyped ('TBigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TBigMap k v) Source #
WellTypedSuperC ('TLambda t1 t2) => WellTyped ('TLambda t1 t2) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TLambda t1 t2) Source #
WellTypedSuperC ('TMap k v) => WellTyped ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TMap k v) Source #
WellTypedSuperC ('TOr t1 t2) => WellTyped ('TOr t1 t2) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TOr t1 t2) Source #
WellTypedSuperC ('TPair t1 t2) => WellTyped ('TPair t1 t2) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type WellTypedSuperC ('TPair t1 t2) Source #

class (IsComparable t ~ 'True, SingI t, ComparableSuperC t) => Comparable t Source #

Associated Types

type ComparableSuperC t :: Constraint Source #

Constraints required for instance of a given type.

type ComparableSuperC _ = ()

Instances

Instances details

Comparable 'TAddress Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TAddress Source #
Comparable 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TBool Source #
Comparable 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TBytes Source #
Comparable 'TChainId Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TChainId Source #
Comparable 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TInt Source #
Comparable 'TKey Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TKey Source #
Comparable 'TKeyHash Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TKeyHash Source #
Comparable 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TMutez Source #
Comparable 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TNat Source #
Comparable 'TNever Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TNever Source #
Comparable 'TSignature Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TSignature Source #
Comparable 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TString Source #
Comparable 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TTimestamp Source #
Comparable 'TUnit Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC 'TUnit Source #
SingI t => CheckScope (Comparable t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (Comparable t)) Source #
ComparableSuperC ('TOption t) => Comparable ('TOption t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC ('TOption t) Source #
ComparableSuperC ('TOr t1 t2) => Comparable ('TOr t1 t2) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC ('TOr t1 t2) Source #
ComparableSuperC ('TPair t1 t2) => Comparable ('TPair t1 t2) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type ComparableSuperC ('TPair t1 t2) Source #

type ProperNonComparableValBetterErrors t = (SingI t, ForbidNonComparable t) Source #

type ProperUntypedValBetterErrors t = (SingI t, ForbidOp t) Source #

type ProperViewableBetterErrors t = (SingI t, ForbidOp t, ForbidBigMap t, ForbidTicket t) Source #

type ProperUnpackedValBetterErrors t = (ProperPackedValBetterErrors t, ProperConstantBetterErrors t) Source #

type ProperPackedValBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidBigMap t, ForbidTicket t, ForbidSaplingState t) Source #

type ProperDupableBetterErrors t = (SingI t, ForbidTicket t) Source #

type ProperConstantBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidBigMap t, ForbidContract t, ForbidTicket t, ForbidSaplingState t) Source #

type ProperStorageBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidNestedBigMaps t, ForbidContract t) Source #

type ProperParameterBetterErrors t = (SingI t, WellTyped t, ForbidOp t, ForbidNestedBigMaps t) Source #

class WithDeMorganScope (c :: T -> Constraint) t a b where Source #

Allows using a scope that can be proven true with a De Morgan law.

Many scopes are defined as not a (or rather a ~ 'False) where a is a negative property we want to avoid as a Constraint. The negative constraints are implemented with a type family that for some combination types resolves to itself applied to the type arguments in an or, e.g. A pair l r has x if l or r contain x.

Because of the De Morgan laws not (a or b) implies (not a) and (not b) or in our case: pair does not contain x -> a and b don't contain x.

Methods

withDeMorganScope :: c (t a b) => ((c a, c b) => ret) -> ret Source #

Instances

Instances details

(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoBigMap t a b, WithDeMorganScope HasNoContract t a b, WithDeMorganScope HasNoTicket t a b, WithDeMorganScope HasNoSaplingState t a b, WellTyped a, WellTyped b) => WithDeMorganScope ConstantScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: ConstantScope (t a b) => ((ConstantScope a, ConstantScope b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoBigMap 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoBigMap ('TOr a b) => ((HasNoBigMap a, HasNoBigMap b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoBigMap 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoBigMap ('TPair a b) => ((HasNoBigMap a, HasNoBigMap b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoContract 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoContract ('TOr a b) => ((HasNoContract a, HasNoContract b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoContract 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoContract ('TPair a b) => ((HasNoContract a, HasNoContract b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoNestedBigMaps 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoNestedBigMaps ('TOr a b) => ((HasNoNestedBigMaps a, HasNoNestedBigMaps b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoNestedBigMaps 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoNestedBigMaps ('TPair a b) => ((HasNoNestedBigMaps a, HasNoNestedBigMaps b) => ret) -> ret Source #
SingI k => WithDeMorganScope HasNoOp 'TBigMap k v Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TBigMap k v) => ((HasNoOp k, HasNoOp v) => ret) -> ret Source #
SingI k => WithDeMorganScope HasNoOp 'TMap k v Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TMap k v) => ((HasNoOp k, HasNoOp v) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoOp 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TOr a b) => ((HasNoOp a, HasNoOp b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoOp 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TPair a b) => ((HasNoOp a, HasNoOp b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoTicket 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoTicket ('TOr a b) => ((HasNoTicket a, HasNoTicket b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoTicket 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoTicket ('TPair a b) => ((HasNoTicket a, HasNoTicket b) => ret) -> ret Source #
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoBigMap t a b, WithDeMorganScope HasNoTicket t a b, WithDeMorganScope HasNoSaplingState t a b, WellTyped a, WellTyped b) => WithDeMorganScope PackedValScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: PackedValScope (t a b) => ((PackedValScope a, PackedValScope b) => ret) -> ret Source #
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoNestedBigMaps t a b, WellTyped a, WellTyped b) => WithDeMorganScope ParameterScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: ParameterScope (t a b) => ((ParameterScope a, ParameterScope b) => ret) -> ret Source #
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoNestedBigMaps t a b, WithDeMorganScope HasNoContract t a b, WellTyped a, WellTyped b) => WithDeMorganScope StorageScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: StorageScope (t a b) => ((StorageScope a, StorageScope b) => ret) -> ret Source #
(WithDeMorganScope PackedValScope t a b, WithDeMorganScope ConstantScope t a b, WellTyped a, WellTyped b) => WithDeMorganScope UnpackedValScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: UnpackedValScope (t a b) => ((UnpackedValScope a, UnpackedValScope b) => ret) -> ret Source #

class (SingI t, Comparable t) => ComparabilityScope t Source #

Alias for comparable types.

Instances

Instances details

(SingI t, Comparable t) => ComparabilityScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI t => CheckScope (ComparabilityScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ComparabilityScope t)) Source #

class CheckScope (c :: Constraint) where Source #

Should be present for common scopes.

Methods

checkScope :: Either BadTypeForScope (Dict c) Source #

Check that constraint hold for a given type.

Instances

Instances details

SingI t => CheckScope (ComparabilityScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ComparabilityScope t)) Source #
SingI t => CheckScope (Comparable t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (Comparable t)) Source #
SingI t => CheckScope (ConstantScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ConstantScope t)) Source #
SingI t => CheckScope (DupableScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (DupableScope t)) Source #
SingI t => CheckScope (HasNoBigMap t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoBigMap t)) Source #
SingI t => CheckScope (HasNoContract t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoContract t)) Source #
SingI t => CheckScope (HasNoNestedBigMaps t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoNestedBigMaps t)) Source #
SingI t => CheckScope (HasNoOp t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoOp t)) Source #
SingI t => CheckScope (HasNoTicket t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoTicket t)) Source #
SingI t => CheckScope (PackedValScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (PackedValScope t)) Source #
SingI t => CheckScope (ParameterScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ParameterScope t)) Source #
SingI t => CheckScope (StorageScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (StorageScope t)) Source #
SingI t => CheckScope (UnpackedValScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (UnpackedValScope t)) Source #
SingI t => CheckScope (ViewableScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ViewableScope t)) Source #
SingI t => CheckScope (WellTyped t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (WellTyped t)) Source #
(CheckScope a, CheckScope b) => CheckScope (a, b) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (a, b)) Source #

type UntypedValScope t = (SingI t, HasNoOp t) Source #

Alias for constraints which are required for untyped representation.

class (SingI t, HasNoOp t, HasNoBigMap t, HasNoTicket t) => ViewableScope t Source #

Set of constraints that Michelson applies to argument type and return type of views. All info related to views can be found in TZIP.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(SingI t, HasNoOp t, HasNoBigMap t, HasNoTicket t) => ViewableScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI t => CheckScope (ViewableScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ViewableScope t)) Source #

class (WellTyped t, PackedValScope t, ConstantScope t) => UnpackedValScope t Source #

Set of constraints that Michelson applies to unpacked values.

It is different from PackedValScope, e.g. contract type cannot appear in a value we unpack to.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(WellTyped t, PackedValScope t, ConstantScope t) => UnpackedValScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
(WithDeMorganScope PackedValScope t a b, WithDeMorganScope ConstantScope t a b, WellTyped a, WellTyped b) => WithDeMorganScope UnpackedValScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: UnpackedValScope (t a b) => ((UnpackedValScope a, UnpackedValScope b) => ret) -> ret Source #
SingI t => CheckScope (UnpackedValScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (UnpackedValScope t)) Source #

class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoTicket t, HasNoSaplingState t) => PackedValScope t Source #

Set of constraints that Michelson applies to packed values.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoTicket t, HasNoSaplingState t) => PackedValScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoBigMap t a b, WithDeMorganScope HasNoTicket t a b, WithDeMorganScope HasNoSaplingState t a b, WellTyped a, WellTyped b) => WithDeMorganScope PackedValScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: PackedValScope (t a b) => ((PackedValScope a, PackedValScope b) => ret) -> ret Source #
SingI t => CheckScope (PackedValScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (PackedValScope t)) Source #

type family IsDupableScope (t :: T) :: Bool where ... Source #

Returns whether the type is dupable.

Equations

IsDupableScope t = Not (ContainsTicket t)

class (SingI t, HasNoTicket t) => DupableScope t Source #

Alias for constraints which Michelson requires in DUP instruction.

Instances

Instances details

(SingI t, HasNoTicket t) => DupableScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI t => CheckScope (DupableScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (DupableScope t)) Source #

class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope t Source #

Set of constraints that Michelson applies to pushed constants.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoBigMap t a b, WithDeMorganScope HasNoContract t a b, WithDeMorganScope HasNoTicket t a b, WithDeMorganScope HasNoSaplingState t a b, WellTyped a, WellTyped b) => WithDeMorganScope ConstantScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: ConstantScope (t a b) => ((ConstantScope a, ConstantScope b) => ret) -> ret Source #
SingI t => CheckScope (ConstantScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ConstantScope t)) Source #

class (SingI t, WellTyped t, HasNoOp t, HasNoNestedBigMaps t, HasNoContract t) => StorageScope t Source #

Set of constraints that Michelson applies to contract storage.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(SingI t, WellTyped t, HasNoOp t, HasNoNestedBigMaps t, HasNoContract t) => StorageScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoNestedBigMaps t a b, WithDeMorganScope HasNoContract t a b, WellTyped a, WellTyped b) => WithDeMorganScope StorageScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: StorageScope (t a b) => ((StorageScope a, StorageScope b) => ret) -> ret Source #
SingI t => CheckScope (StorageScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (StorageScope t)) Source #

class (SingI t, WellTyped t, HasNoOp t, HasNoNestedBigMaps t) => ParameterScope t Source #

Set of constraints that Michelson applies to parameters.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(SingI t, WellTyped t, HasNoOp t, HasNoNestedBigMaps t) => ParameterScope t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoNestedBigMaps t a b, WellTyped a, WellTyped b) => WithDeMorganScope ParameterScope t a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: ParameterScope (t a b) => ((ParameterScope a, ParameterScope b) => ret) -> ret Source #
SingI t => CheckScope (ParameterScope t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ParameterScope t)) Source #

data BadTypeForScope Source #

Constructors

BtNotComparable
BtIsOperation
BtHasBigMap
BtHasNestedBigMap
BtHasContract
BtHasTicket
BtHasSaplingState

Instances

Instances details

Generic BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type Rep BadTypeForScope :: Type -> Type # Methods from :: BadTypeForScope -> Rep BadTypeForScope x # to :: Rep BadTypeForScope x -> BadTypeForScope #
Show BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods showsPrec :: Int -> BadTypeForScope -> ShowS # show :: BadTypeForScope -> String # showList :: [BadTypeForScope] -> ShowS #
NFData BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods rnf :: BadTypeForScope -> () #
Buildable BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods build :: BadTypeForScope -> Builder #
Eq BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods (==) :: BadTypeForScope -> BadTypeForScope -> Bool # (/=) :: BadTypeForScope -> BadTypeForScope -> Bool #
RenderDoc BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods renderDoc :: RenderContext -> BadTypeForScope -> Doc Source # isRenderable :: BadTypeForScope -> Bool Source #
type Rep BadTypeForScope Source #
Instance details Defined in Morley.Michelson.Typed.Scope type Rep BadTypeForScope = D1 ('MetaData "BadTypeForScope" "Morley.Michelson.Typed.Scope" "morley-1.19.1-inplace" 'False) ((C1 ('MetaCons "BtNotComparable" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "BtIsOperation" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BtHasBigMap" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "BtHasNestedBigMap" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BtHasContract" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "BtHasTicket" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BtHasSaplingState" 'PrefixI 'False) (U1 :: Type -> Type))))

data NestedBigMapsPresence (t :: T) Source #

Whether a value of this type _may_ contain nested big_maps.

Constructors

ContainsNestedBigMaps t ~ 'True => NestedBigMapsPresent	A value of type `t` may or may not contain nested `big_map`s.
ContainsNestedBigMaps t ~ 'False => NestedBigMapsAbsent	A value of type `t` cannot contain nested `big_map`s.

data BigMapPresence (t :: T) Source #

Whether a value of this type _may_ contain a big_map value.

Constructors

ContainsBigMap t ~ 'True => BigMapPresent	A value of type `t` may or may not contain a `big_map` value.
ContainsBigMap t ~ 'False => BigMapAbsent	A value of type `t` cannot contain `big_map` values.

data TicketPresence (t :: T) Source #

Whether a value of this type _may_ contain a ticket value.

Constructors

ContainsTicket t ~ 'True => TicketPresent	A value of type `t` may or may not contain a `ticket` value.
ContainsTicket t ~ 'False => TicketAbsent	A value of type `t` cannot contain `ticket` values.

data ContractPresence (t :: T) Source #

Whether a value of this type _may_ contain a contract value.

Constructors

ContainsContract t ~ 'True => ContractPresent	A value of type `t` may or may not contain a `contract` value.
ContainsContract t ~ 'False => ContractAbsent	A value of type `t` cannot contain `contract` values.

data OpPresence (t :: T) Source #

Whether a value of this type _may_ contain an operation.

Constructors

ContainsOp t ~ 'True => OpPresent	A value of type `t` may or may not contain an operation.
ContainsOp t ~ 'False => OpAbsent	A value of type `t` cannot contain `big_map` values.

type ForbidNonComparable t = FailUnless (IsComparable t) ('Text "Only comparable types are allowed here") Source #

Constraint that rises human-readable error message, in case given value can't be compared

type ForbidNestedBigMaps t = FailWhen (ContainsNestedBigMaps t) ('Text "Nested BigMaps are not allowed") Source #

type ForbidBigMap t = FailWhen (ContainsBigMap t) ('Text "BigMaps are not allowed in this scope") Source #

type ForbidTicket t = FailWhen (ContainsTicket t) ('Text "Type `ticket` is not allowed in this scope") Source #

type ForbidContract t = FailWhen (ContainsContract t) ('Text "Type `contract` is not allowed in this scope") Source #

type ForbidOp t = FailWhen (ContainsOp t) ('Text "Operations are not allowed in this scope") Source #

This is like HasNoOp, it raises a more human-readable error when t type is concrete, and also imposes an equality constraint.

Use this constraint in our eDSL.

class ContainsNestedBigMaps t ~ 'False => HasNoNestedBigMaps t Source #

Constraint which ensures that there are no nested bigmaps.

Instances

Instances details

ContainsNestedBigMaps t ~ 'False => HasNoNestedBigMaps t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI a => WithDeMorganScope HasNoNestedBigMaps 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoNestedBigMaps ('TOr a b) => ((HasNoNestedBigMaps a, HasNoNestedBigMaps b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoNestedBigMaps 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoNestedBigMaps ('TPair a b) => ((HasNoNestedBigMaps a, HasNoNestedBigMaps b) => ret) -> ret Source #
SingI t => CheckScope (HasNoNestedBigMaps t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoNestedBigMaps t)) Source #

class ContainsBigMap t ~ 'False => HasNoBigMap t Source #

Constraint which ensures that a value of type t does not contain big_map values.

Instances

Instances details

ContainsBigMap t ~ 'False => HasNoBigMap t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI a => WithDeMorganScope HasNoBigMap 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoBigMap ('TOr a b) => ((HasNoBigMap a, HasNoBigMap b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoBigMap 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoBigMap ('TPair a b) => ((HasNoBigMap a, HasNoBigMap b) => ret) -> ret Source #
SingI t => CheckScope (HasNoBigMap t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoBigMap t)) Source #

class ContainsTicket t ~ 'False => HasNoTicket t Source #

Constraint which ensures that a value of type t does not contain ticket values.

Instances

Instances details

ContainsTicket t ~ 'False => HasNoTicket t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI a => WithDeMorganScope HasNoTicket 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoTicket ('TOr a b) => ((HasNoTicket a, HasNoTicket b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoTicket 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoTicket ('TPair a b) => ((HasNoTicket a, HasNoTicket b) => ret) -> ret Source #
SingI t => CheckScope (HasNoTicket t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoTicket t)) Source #

class ContainsContract t ~ 'False => HasNoContract t Source #

Constraint which ensures that a value of type t does not contain contract values.

Instances

Instances details

ContainsContract t ~ 'False => HasNoContract t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI a => WithDeMorganScope HasNoContract 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoContract ('TOr a b) => ((HasNoContract a, HasNoContract b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoContract 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoContract ('TPair a b) => ((HasNoContract a, HasNoContract b) => ret) -> ret Source #
SingI t => CheckScope (HasNoContract t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoContract t)) Source #

class ContainsOp t ~ 'False => HasNoOp t Source #

Constraint which ensures that a value of type t does not contain operations.

Not just a type alias in order to be able to partially apply it (e.g. in Each).

Instances

Instances details

ContainsOp t ~ 'False => HasNoOp t Source #
Instance details Defined in Morley.Michelson.Typed.Scope
SingI k => WithDeMorganScope HasNoOp 'TBigMap k v Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TBigMap k v) => ((HasNoOp k, HasNoOp v) => ret) -> ret Source #
SingI k => WithDeMorganScope HasNoOp 'TMap k v Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TMap k v) => ((HasNoOp k, HasNoOp v) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoOp 'TOr a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TOr a b) => ((HasNoOp a, HasNoOp b) => ret) -> ret Source #
SingI a => WithDeMorganScope HasNoOp 'TPair a b Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: HasNoOp ('TPair a b) => ((HasNoOp a, HasNoOp b) => ret) -> ret Source #
SingI t => CheckScope (HasNoOp t) Source #
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (HasNoOp t)) Source #

type family IsComparable (t :: T) :: Bool where ... Source #

Constraint which ensures that type is comparable.

Equations

IsComparable ('TPair a b) = IsComparable a && IsComparable b
IsComparable ('TOption t) = IsComparable t
IsComparable 'TBls12381Fr = 'False
IsComparable 'TBls12381G1 = 'False
IsComparable 'TBls12381G2 = 'False
IsComparable ('TList _) = 'False
IsComparable ('TSet _) = 'False
IsComparable 'TOperation = 'False
IsComparable ('TContract _) = 'False
IsComparable ('TTicket _) = 'False
IsComparable ('TOr a b) = IsComparable a && IsComparable b
IsComparable ('TLambda _ _) = 'False
IsComparable ('TMap _ _) = 'False
IsComparable ('TBigMap _ _) = 'False
IsComparable 'TChest = 'False
IsComparable 'TChestKey = 'False
IsComparable ('TSaplingState _) = 'False
IsComparable ('TSaplingTransaction _) = 'False
IsComparable _ = 'True

type family ContainsNestedBigMaps (t :: T) :: Bool where ... Source #

Whether a value of this type _may_ contain nested big_maps.

Nested big_maps (i.e. big_map which contains another big_map inside of it's value type) are prohibited in all contexts. Some context such as PUSH, APPLY, PACK/UNPACK instructions are more strict because they don't work with big_map at all.

Equations

ContainsNestedBigMaps 'TKey = 'False
ContainsNestedBigMaps 'TUnit = 'False
ContainsNestedBigMaps 'TSignature = 'False
ContainsNestedBigMaps 'TChainId = 'False
ContainsNestedBigMaps ('TOption t) = ContainsNestedBigMaps t
ContainsNestedBigMaps ('TList t) = ContainsNestedBigMaps t
ContainsNestedBigMaps ('TSet _) = 'False
ContainsNestedBigMaps 'TOperation = 'False
ContainsNestedBigMaps ('TContract _) = 'False
ContainsNestedBigMaps ('TPair a b) = ContainsNestedBigMaps a \|\| ContainsNestedBigMaps b
ContainsNestedBigMaps ('TOr a b) = ContainsNestedBigMaps a \|\| ContainsNestedBigMaps b
ContainsNestedBigMaps ('TLambda _ _) = 'False
ContainsNestedBigMaps ('TMap _ v) = ContainsNestedBigMaps v
ContainsNestedBigMaps ('TBigMap _ v) = ContainsBigMap v
ContainsNestedBigMaps _ = 'False

type family ContainsBigMap (t :: T) :: Bool where ... Source #

Whether a value of this type _may_ contain a big_map value.

Equations

ContainsBigMap 'TKey = 'False
ContainsBigMap 'TUnit = 'False
ContainsBigMap 'TSignature = 'False
ContainsBigMap 'TChainId = 'False
ContainsBigMap ('TOption t) = ContainsBigMap t
ContainsBigMap ('TList t) = ContainsBigMap t
ContainsBigMap ('TSet _) = 'False
ContainsBigMap 'TOperation = 'False
ContainsBigMap ('TContract _) = 'False
ContainsBigMap ('TPair a b) = ContainsBigMap a \|\| ContainsBigMap b
ContainsBigMap ('TOr a b) = ContainsBigMap a \|\| ContainsBigMap b
ContainsBigMap ('TLambda _ _) = 'False
ContainsBigMap ('TMap _ v) = ContainsBigMap v
ContainsBigMap ('TBigMap _ _) = 'True
ContainsBigMap _ = 'False

type family ContainsTicket (t :: T) :: Bool where ... Source #

Whether a value of this type _may_ contain a ticket value.

Equations

ContainsTicket ('TOption t) = ContainsTicket t
ContainsTicket ('TList t) = ContainsTicket t
ContainsTicket ('TSet _) = 'False
ContainsTicket ('TTicket _) = 'True
ContainsTicket ('TPair a b) = ContainsTicket a \|\| ContainsTicket b
ContainsTicket ('TOr a b) = ContainsTicket a \|\| ContainsTicket b
ContainsTicket ('TLambda _ _) = 'False
ContainsTicket ('TMap _ v) = ContainsTicket v
ContainsTicket ('TBigMap _ v) = ContainsTicket v
ContainsTicket _ = 'False

type family ContainsContract (t :: T) :: Bool where ... Source #

Whether a value of this type _may_ contain a contract value.

In some scopes (constants, storage) appearing for contract type is prohibited. Contracts in input/output of lambdas are allowed without limits though.

Equations

ContainsContract 'TKey = 'False
ContainsContract 'TUnit = 'False
ContainsContract 'TSignature = 'False
ContainsContract 'TChainId = 'False
ContainsContract ('TOption t) = ContainsContract t
ContainsContract ('TList t) = ContainsContract t
ContainsContract ('TSet _) = 'False
ContainsContract 'TOperation = 'False
ContainsContract ('TContract _) = 'True
ContainsContract ('TPair a b) = ContainsContract a \|\| ContainsContract b
ContainsContract ('TOr a b) = ContainsContract a \|\| ContainsContract b
ContainsContract ('TLambda _ _) = 'False
ContainsContract ('TMap _ v) = ContainsContract v
ContainsContract ('TBigMap _ v) = ContainsContract v
ContainsContract _ = 'False

type family ContainsOp (t :: T) :: Bool where ... Source #

Whether a value of this type _may_ contain an operation.

In some scopes (constants, parameters, storage) appearing for operation type is prohibited. Operations in input/output of lambdas are allowed without limits though.

Equations

ContainsOp 'TKey = 'False
ContainsOp 'TUnit = 'False
ContainsOp 'TSignature = 'False
ContainsOp 'TChainId = 'False
ContainsOp ('TOption t) = ContainsOp t
ContainsOp ('TList t) = ContainsOp t
ContainsOp ('TSet t) = ContainsOp t
ContainsOp 'TOperation = 'True
ContainsOp ('TContract _) = 'False
ContainsOp ('TTicket t) = ContainsOp t
ContainsOp ('TPair a b) = ContainsOp a \|\| ContainsOp b
ContainsOp ('TOr a b) = ContainsOp a \|\| ContainsOp b
ContainsOp ('TLambda _ _) = 'False
ContainsOp ('TMap k v) = ContainsOp k \|\| ContainsOp v
ContainsOp ('TBigMap k v) = ContainsOp k \|\| ContainsOp v
ContainsOp _ = 'False

checkOpPresence :: Sing (ty :: T) -> OpPresence ty Source #

Check at runtime whether a value of the given type _may_ contain an operation.

checkContractTypePresence :: Sing (ty :: T) -> ContractPresence ty Source #

Check at runtime whether a value of the given type _may_ contain a contract value.

checkTicketPresence :: Sing (ty :: T) -> TicketPresence ty Source #

Check at runtime whether a value of the given type _may_ contain a ticket value.

checkBigMapPresence :: Sing (ty :: T) -> BigMapPresence ty Source #

Check at runtime whether a value of the given type _may_ contain a big_map value.

checkNestedBigMapsPresence :: Sing (ty :: T) -> NestedBigMapsPresence ty Source #

Check at runtime whether a value of the given type _may_ contain nested big_maps.

opAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoOp t) Source #

Check at runtime that a value of the given type cannot contain operations.

contractTypeAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoContract t) Source #

Check at runtime that a value of the given type cannot contain contract values.

bigMapAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoBigMap t) Source #

Check at runtime that a value of the given type cannot containt big_map values

nestedBigMapsAbsense :: Sing (t :: T) -> Maybe (Dict $ HasNoNestedBigMaps t) Source #

Check at runtime that a value of the given type cannot contain nested big_maps.

comparabilityPresence :: Sing t -> Maybe (Dict (Comparable t)) Source #

getWTP :: forall t. SingI t => Either NotWellTyped (Dict (WellTyped t)) Source #

Given a type, provide evidence that it is well typed w.r.t to the Michelson rules regarding where comparable types are required.

getWTP' :: Sing t -> Either NotWellTyped (Dict (WellTyped t)) Source #

Version of getWTP that accepts Sing at term-level.

getComparableProofS :: Sing (a :: T) -> Maybe (Dict (Comparable a)) Source #

checkComparability :: Sing t -> Comparability t Source #

comparabilityImpliesNoNestedBigMaps :: forall t. (SingI t, IsComparable t ~ 'True) => ContainsNestedBigMaps t :~: 'False Source #

Inductive proof that Comparable implies HasNoNestedBigMaps. This is stubbed with an unsafeCoerce Refl at runtime to avoid runtime traversals.

comparabilityImpliesNoOp :: forall t. (SingI t, IsComparable t ~ 'True) => ContainsOp t :~: 'False Source #

Inductive proof that Comparable implies HasNoOp. This is stubbed with an unsafeCoerce Refl at runtime to avoid runtime traversals.

type FieldDescriptions = [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))] Source #

Description of constructors and fields of some datatype.

This type is just two nested maps represented as associative lists. It is supposed to be interpreted like this:

[(Constructor name, (Maybe constructor description, [(Field name, Field description)]))]

Example with a concrete data type:

data Foo
  = Foo
      { fFoo :: Int
      }
  | Bar
      { fBar :: Text
      }
  deriving (Generic)

type FooDescriptions =
  '[ '( "Foo", '( 'Just "foo constructor",
      , '[ '("fFoo", "some number")
         ])
      )
   , '( "Bar", '( 'Nothing,
      , '[ '("fBar", "some string")
         ])
      )
   ]

newtype EpName Source #

Entrypoint name.

There are two properties we care about:

Special treatment of the default entrypoint name. default is prohibited in the CONTRACT instruction and in values of address and contract types. However, it is not prohibited in the SELF instruction. Hence, the value inside EpName can be "default", so that we can distinguish SELF and SELF %default. It is important to distinguish them because their binary representation that is inserted into blockchain is different. For example, typechecking SELF %default consumes more gas than SELF. In this module, we provide several smart constructors with different handling of default, please use the appropriate one for your use case.
The set of permitted characters. Intuitively, an entrypoint name should be valid only if it is a valid annotation (because entrypoints are defined using field annotations). However, it is not enforced in Tezos. It is not clear whether this behavior is intended. There is an upstream issue which received bug label, so probably it is considered a bug. Currently we treat it as a bug and deviate from upstream implementation by probiting entrypoint names that are not valid annotations. If Tezos developers fix it soon, we will be happy. If they don't, we should (maybe temporarily) remove this limitation from our code. There is an issue in our repo as well.

Constructors

UnsafeEpName
Fields unEpName :: Text

Instances

Instances details

FromJSON EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods parseJSON :: Value -> Parser EpName # parseJSONList :: Value -> Parser [EpName] #
ToJSON EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods toJSON :: EpName -> Value # toEncoding :: EpName -> Encoding # toJSONList :: [EpName] -> Value # toEncodingList :: [EpName] -> Encoding #
Generic EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Associated Types type Rep EpName :: Type -> Type # Methods from :: EpName -> Rep EpName x # to :: Rep EpName x -> EpName #
Show EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> EpName -> ShowS # show :: EpName -> String # showList :: [EpName] -> ShowS #
NFData EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods rnf :: EpName -> () #
Buildable EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods build :: EpName -> Builder #
Eq EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: EpName -> EpName -> Bool # (/=) :: EpName -> EpName -> Bool #
Ord EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods compare :: EpName -> EpName -> Ordering # (<) :: EpName -> EpName -> Bool # (<=) :: EpName -> EpName -> Bool # (>) :: EpName -> EpName -> Bool # (>=) :: EpName -> EpName -> Bool # max :: EpName -> EpName -> EpName # min :: EpName -> EpName -> EpName #
HasCLReader EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods getReader :: ReadM EpName Source # getMetavar :: String Source #
type Rep EpName Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints type Rep EpName = D1 ('MetaData "EpName" "Morley.Michelson.Untyped.Entrypoints" "morley-1.19.1-inplace" 'True) (C1 ('MetaCons "UnsafeEpName" 'PrefixI 'True) (S1 ('MetaSel ('Just "unEpName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data HandleImplicitDefaultEp Source #

A simple enum flag to choose how to handle implicit default entrypoint in mkEntrypointsMap.

Constructors

WithoutImplicitDefaultEp	Omit the default entrypoint unless it's specified explicitly.
WithImplicitDefaultEp	Include the default entrypoint even if it's not specified explicitly. This produces exactly the full set of entrypoints as per Michelson spec.

Instances

Instances details

Enum HandleImplicitDefaultEp Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods succ :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp # pred :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp # toEnum :: Int -> HandleImplicitDefaultEp # fromEnum :: HandleImplicitDefaultEp -> Int # enumFrom :: HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] # enumFromThen :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] # enumFromTo :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] # enumFromThenTo :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] #
Show HandleImplicitDefaultEp Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> HandleImplicitDefaultEp -> ShowS # show :: HandleImplicitDefaultEp -> String # showList :: [HandleImplicitDefaultEp] -> ShowS #
Eq HandleImplicitDefaultEp Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (/=) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool #
Ord HandleImplicitDefaultEp Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods compare :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Ordering # (<) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (<=) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (>) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (>=) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # max :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> HandleImplicitDefaultEp # min :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> HandleImplicitDefaultEp #

data EpNameFromRefAnnError Source #

Constructors

InEpNameBadAnnotation FieldAnn

Instances

Instances details

Generic EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Associated Types type Rep EpNameFromRefAnnError :: Type -> Type # Methods from :: EpNameFromRefAnnError -> Rep EpNameFromRefAnnError x # to :: Rep EpNameFromRefAnnError x -> EpNameFromRefAnnError #
Show EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> EpNameFromRefAnnError -> ShowS # show :: EpNameFromRefAnnError -> String # showList :: [EpNameFromRefAnnError] -> ShowS #
NFData EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods rnf :: EpNameFromRefAnnError -> () #
Buildable EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods build :: EpNameFromRefAnnError -> Builder #
Eq EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: EpNameFromRefAnnError -> EpNameFromRefAnnError -> Bool # (/=) :: EpNameFromRefAnnError -> EpNameFromRefAnnError -> Bool #
RenderDoc EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods renderDoc :: RenderContext -> EpNameFromRefAnnError -> Doc Source # isRenderable :: EpNameFromRefAnnError -> Bool Source #
type Rep EpNameFromRefAnnError Source #
Instance details Defined in Morley.Michelson.Untyped.Entrypoints type Rep EpNameFromRefAnnError = D1 ('MetaData "EpNameFromRefAnnError" "Morley.Michelson.Untyped.Entrypoints" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "InEpNameBadAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FieldAnn)))

pattern DefEpName :: EpName Source #

This is a bidirectional pattern that can be used for two purposes:

Construct an EpName referring to the default entrypoint.
Use it in pattern-matching or in equality comparison to check whether EpName refers to the default entrypoint. This is trickier because there are two possible EpName values referring to the default entrypoints. DefEpName will match only the most common one (no entrypoint). However, there is a special case: SELF instruction can have explicit %default reference. For this reason, it is recommended to use isDefEpName instead. Pattern-matching on DefEpName is still permitted for backwards compatibility and for the cases when you are sure that EpName does not come from the SELF instruction.

epNameFromParamAnn :: FieldAnn -> Maybe EpName Source #

Make up EpName from annotation in parameter type declaration.

Returns Nothing if no entrypoint is assigned here.

epNameToParamAnn :: EpName -> FieldAnn Source #

Turn entrypoint name into annotation for contract parameter declaration.

epNameFromRefAnn :: FieldAnn -> Either EpNameFromRefAnnError EpName Source #

Make up EpName from annotation which is reference to an entrypoint. Note that it's more common for Michelson to prohibit explicit default entrypoint reference.

Specifically, %default annotation is probitited in values of address and contract types. It's also prohibited in the CONTRACT instruction. However, there is an exception: SELF %default is a perfectly valid instruction. Hence, when you construct an EpName from an annotation that's part of SELF, you should use epNameFromSelfAnn instead.

epNameToRefAnn :: EpName -> FieldAnn Source #

Turn entrypoint name into annotation used as reference to entrypoint.

newtype ViewName Source #

Name of the view.

It must not exceed 31 chars length;
Must use [a-zA-Z0-9_.%@] charset.

Constructors

UnsafeViewName
Fields unViewName :: Text

Bundled Patterns

pattern ViewName :: Text -> ViewName

Instances

Instances details

FromJSON ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods parseJSON :: Value -> Parser ViewName # parseJSONList :: Value -> Parser [ViewName] #
FromJSONKey ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods fromJSONKey :: FromJSONKeyFunction ViewName # fromJSONKeyList :: FromJSONKeyFunction [ViewName] #
ToJSON ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods toJSON :: ViewName -> Value # toEncoding :: ViewName -> Encoding # toJSONList :: [ViewName] -> Value # toEncodingList :: [ViewName] -> Encoding #
ToJSONKey ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods toJSONKey :: ToJSONKeyFunction ViewName # toJSONKeyList :: ToJSONKeyFunction [ViewName] #
Data ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ViewName -> c ViewName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ViewName # toConstr :: ViewName -> Constr # dataTypeOf :: ViewName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ViewName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ViewName) # gmapT :: (forall b. Data b => b -> b) -> ViewName -> ViewName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewName -> r # gmapQ :: (forall d. Data d => d -> u) -> ViewName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewName -> m ViewName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewName -> m ViewName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewName -> m ViewName #
Generic ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Associated Types type Rep ViewName :: Type -> Type # Methods from :: ViewName -> Rep ViewName x # to :: Rep ViewName x -> ViewName #
Show ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods showsPrec :: Int -> ViewName -> ShowS # show :: ViewName -> String # showList :: [ViewName] -> ShowS #
NFData ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods rnf :: ViewName -> () #
Buildable ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods build :: ViewName -> Builder #
Eq ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods (==) :: ViewName -> ViewName -> Bool # (/=) :: ViewName -> ViewName -> Bool #
Ord ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods compare :: ViewName -> ViewName -> Ordering # (<) :: ViewName -> ViewName -> Bool # (<=) :: ViewName -> ViewName -> Bool # (>) :: ViewName -> ViewName -> Bool # (>=) :: ViewName -> ViewName -> Bool # max :: ViewName -> ViewName -> ViewName # min :: ViewName -> ViewName -> ViewName #
ToExpression ViewName Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: ViewName -> Expression Source #
RenderDoc ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods renderDoc :: RenderContext -> ViewName -> Doc Source # isRenderable :: ViewName -> Bool Source #
HasCLReader ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods getReader :: ReadM ViewName Source # getMetavar :: String Source #
FromExp x ViewName Source #
Instance details Defined in Morley.Micheline.Class Methods fromExp :: Exp x -> Either (FromExpError x) ViewName Source #
type Rep ViewName Source #
Instance details Defined in Morley.Michelson.Internal.ViewName type Rep ViewName = D1 ('MetaData "ViewName" "Morley.Michelson.Internal.ViewName" "morley-1.19.1-inplace" 'True) (C1 ('MetaCons "UnsafeViewName" 'PrefixI 'True) (S1 ('MetaSel ('Just "unViewName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data BadViewNameError Source #

Constructors

BadViewTooLong Int
BadViewIllegalChars Text

Instances

Instances details

Data BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BadViewNameError -> c BadViewNameError # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BadViewNameError # toConstr :: BadViewNameError -> Constr # dataTypeOf :: BadViewNameError -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BadViewNameError) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BadViewNameError) # gmapT :: (forall b. Data b => b -> b) -> BadViewNameError -> BadViewNameError # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BadViewNameError -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BadViewNameError -> r # gmapQ :: (forall d. Data d => d -> u) -> BadViewNameError -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BadViewNameError -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BadViewNameError -> m BadViewNameError # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BadViewNameError -> m BadViewNameError # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BadViewNameError -> m BadViewNameError #
Generic BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Associated Types type Rep BadViewNameError :: Type -> Type # Methods from :: BadViewNameError -> Rep BadViewNameError x # to :: Rep BadViewNameError x -> BadViewNameError #
Show BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods showsPrec :: Int -> BadViewNameError -> ShowS # show :: BadViewNameError -> String # showList :: [BadViewNameError] -> ShowS #
NFData BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods rnf :: BadViewNameError -> () #
Buildable BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods build :: BadViewNameError -> Builder #
Eq BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods (==) :: BadViewNameError -> BadViewNameError -> Bool # (/=) :: BadViewNameError -> BadViewNameError -> Bool #
Ord BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName Methods compare :: BadViewNameError -> BadViewNameError -> Ordering # (<) :: BadViewNameError -> BadViewNameError -> Bool # (<=) :: BadViewNameError -> BadViewNameError -> Bool # (>) :: BadViewNameError -> BadViewNameError -> Bool # (>=) :: BadViewNameError -> BadViewNameError -> Bool # max :: BadViewNameError -> BadViewNameError -> BadViewNameError # min :: BadViewNameError -> BadViewNameError -> BadViewNameError #
type Rep BadViewNameError Source #
Instance details Defined in Morley.Michelson.Internal.ViewName type Rep BadViewNameError = D1 ('MetaData "BadViewNameError" "Morley.Michelson.Internal.ViewName" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "BadViewTooLong" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)) :+: C1 ('MetaCons "BadViewIllegalChars" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)))

mkViewName :: Text -> Either BadViewNameError ViewName Source #

Construct ViewName performing all the checks.

viewNameToMText :: ViewName -> MText Source #

Valid view names form a subset of valid Michelson texts.

data ViewsSetError Source #

Errors possible when constructing ViewsSet.

Constructors

DuplicatedViewName ViewName

Instances

Instances details

Show ViewsSetError Source #
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods showsPrec :: Int -> ViewsSetError -> ShowS # show :: ViewsSetError -> String # showList :: [ViewsSetError] -> ShowS #
Buildable ViewsSetError Source #
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods build :: ViewsSetError -> Builder #
Eq ViewsSetError Source #
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods (==) :: ViewsSetError -> ViewsSetError -> Bool # (/=) :: ViewsSetError -> ViewsSetError -> Bool #

data Notes t where Source #

Data type, holding annotation data for a given Michelson type t.

Each constructor corresponds to exactly one constructor of T and holds all type and field annotations that can be attributed to a Michelson type corresponding to t.

Constructors

NTKey :: TypeAnn -> Notes 'TKey
NTUnit :: TypeAnn -> Notes 'TUnit
NTSignature :: TypeAnn -> Notes 'TSignature
NTChainId :: TypeAnn -> Notes 'TChainId
NTOption :: TypeAnn -> Notes t -> Notes ('TOption t)
NTList :: TypeAnn -> Notes t -> Notes ('TList t)
NTSet :: TypeAnn -> Notes t -> Notes ('TSet t)
NTOperation :: TypeAnn -> Notes 'TOperation
NTContract :: TypeAnn -> Notes t -> Notes ('TContract t)
NTTicket :: TypeAnn -> Notes t -> Notes ('TTicket t)
NTPair :: TypeAnn -> FieldAnn -> FieldAnn -> VarAnn -> VarAnn -> Notes p -> Notes q -> Notes ('TPair p q)
NTOr :: TypeAnn -> FieldAnn -> FieldAnn -> Notes p -> Notes q -> Notes ('TOr p q)
NTLambda :: TypeAnn -> Notes p -> Notes q -> Notes ('TLambda p q)
NTMap :: TypeAnn -> Notes k -> Notes v -> Notes ('TMap k v)
NTBigMap :: TypeAnn -> Notes k -> Notes v -> Notes ('TBigMap k v)
NTInt :: TypeAnn -> Notes 'TInt
NTNat :: TypeAnn -> Notes 'TNat
NTString :: TypeAnn -> Notes 'TString
NTBytes :: TypeAnn -> Notes 'TBytes
NTMutez :: TypeAnn -> Notes 'TMutez
NTBool :: TypeAnn -> Notes 'TBool
NTKeyHash :: TypeAnn -> Notes 'TKeyHash
NTBls12381Fr :: TypeAnn -> Notes 'TBls12381Fr
NTBls12381G1 :: TypeAnn -> Notes 'TBls12381G1
NTBls12381G2 :: TypeAnn -> Notes 'TBls12381G2
NTTimestamp :: TypeAnn -> Notes 'TTimestamp
NTAddress :: TypeAnn -> Notes 'TAddress
NTChest :: TypeAnn -> Notes 'TChest
NTChestKey :: TypeAnn -> Notes 'TChestKey
NTNever :: TypeAnn -> Notes 'TNever
NTSaplingState :: forall (n :: Peano). TypeAnn -> Sing n -> Notes ('TSaplingState n)
NTSaplingTransaction :: forall (n :: Peano). TypeAnn -> Sing n -> Notes ('TSaplingTransaction n)

Instances

Instances details

Lift (Notes t :: Type) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods lift :: Quote m => Notes t -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Notes t -> Code m (Notes t) #
Show (Notes t) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods showsPrec :: Int -> Notes t -> ShowS # show :: Notes t -> String # showList :: [Notes t] -> ShowS #
(SingI t, Default (Anns xs)) => Default (Anns (Notes t ': xs)) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns (Notes t ': xs) #
NFData (Notes t) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods rnf :: Notes t -> () #
Buildable (Notes t) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods build :: Notes t -> Builder #
Eq (Notes t) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods (==) :: Notes t -> Notes t -> Bool # (/=) :: Notes t -> Notes t -> Bool #
ToExpression (Notes t) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Notes t -> Expression Source #
RenderDoc (Notes t) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods renderDoc :: RenderContext -> Notes t -> Doc Source # isRenderable :: Notes t -> Bool Source #
AnnotateInstr xs r => AnnotateInstr (Notes t ': xs) r Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods annotateInstr :: Anns (Notes t ': xs) -> AnnotateInstrArg (Notes t ': xs) r -> r Source #

data Anns xs where Source #

A typed heterogenous list of annotations. Simplified pattern synonyms for common use cases are provided.

Constructors

AnnsCons :: Typeable tag => !(Annotation tag) -> Anns xs -> Anns (Annotation tag ': xs) infixr 5
AnnsTyCons :: SingI t => !(Notes t) -> Anns xs -> Anns (Notes t ': xs) infixr 5
AnnsNil :: Anns '[]

Bundled Patterns

pattern Anns5' :: (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]	Convenience pattern synonym matching five annotations, first four being simple, the last one being `Notes`, corresponding to an annotated type.
pattern Anns4'' :: (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]	Convenience pattern synonym matching four annotations, first two being simple, the last two being `Notes`, corresponding to annotated types.
pattern Anns4 :: Each '[Typeable] '[a, b, c, d] => Annotation a -> Annotation b -> Annotation c -> Annotation d -> Anns '[Annotation a, Annotation b, Annotation c, Annotation d]	Convenience pattern synonym matching four simple annotations.
pattern Anns3'' :: (Typeable a, SingI t, SingI u) => Annotation a -> Notes t -> Notes u -> Anns '[Annotation a, Notes t, Notes u]	Convenience pattern synonym matching three annotations, first being a simple one, the last two being `Notes`, corresponding to annotated types.
pattern Anns3' :: (Each '[Typeable] '[a, b], SingI t) => Annotation a -> Annotation b -> Notes t -> Anns '[Annotation a, Annotation b, Notes t]	Convenience pattern synonym matching three annotations, first two being simple, the last one being `Notes`, corresponding to an annotated type.
pattern Anns3 :: Each '[Typeable] '[a, b, c] => Annotation a -> Annotation b -> Annotation c -> Anns '[Annotation a, Annotation b, Annotation c]	Convenience pattern synonym matching three simple annotations.
pattern Anns2' :: (Typeable a, SingI t) => Annotation a -> Notes t -> Anns '[Annotation a, Notes t]	Convenience pattern synonym matching two annotations, first being a simple one, the second being `Notes`, corresponding to an annotated type.
pattern Anns1 :: Typeable a => Annotation a -> Anns '[Annotation a]	Convenience pattern synonym matching a single simple annotation.
pattern Anns2 :: Each '[Typeable] '[a, b] => Annotation a -> Annotation b -> Anns '[Annotation a, Annotation b]	Convenience pattern synonym matching two simple annotations.

Instances

Instances details

Each '[Show] rs => Show (Anns rs) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods showsPrec :: Int -> Anns rs -> ShowS # show :: Anns rs -> String # showList :: [Anns rs] -> ShowS #
(SingI t, Default (Anns xs)) => Default (Anns (Notes t ': xs)) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns (Notes t ': xs) #
(Typeable tag, Default (Anns xs)) => Default (Anns (Annotation tag ': xs)) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns (Annotation tag ': xs) #
Default (Anns ('[] :: [Type])) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns '[] #
NFData (Anns xs) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods rnf :: Anns xs -> () #
(Eq r, Eq (Anns rs)) => Eq (Anns (r ': rs)) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods (==) :: Anns (r ': rs) -> Anns (r ': rs) -> Bool # (/=) :: Anns (r ': rs) -> Anns (r ': rs) -> Bool #
Eq (Anns ('[] :: [Type])) Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods (==) :: Anns '[] -> Anns '[] -> Bool # (/=) :: Anns '[] -> Anns '[] -> Bool #

notesSing :: Notes t -> Sing t Source #

Forget information about annotations, pick singleton with the same type.

notesT :: Notes t -> T Source #

Get term-level type of notes.

mkUType :: Notes x -> Ty Source #

Get the term-level type of notes, preserving annotations.

starNotes :: forall t. SingI t => Notes t Source #

In memory of NStar constructor. Generates notes with no annotations.

isStar :: SingI t => Notes t -> Bool Source #

Checks if no annotations are present.

insertTypeAnn :: forall (b :: T). TypeAnn -> Notes b -> Notes b Source #

Insert the provided type annotation into the provided notes.

class AnnotateInstr (xs :: [Type]) r where Source #

Utility typeclass to simplify extracting annotations from Anns and passing those as arguments to an untyped instruction data constructor.

Methods

annotateInstr :: Anns xs -> AnnotateInstrArg xs r -> r Source #

Instances

Instances details

AnnotateInstr ('[] :: [Type]) r Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods annotateInstr :: Anns '[] -> AnnotateInstrArg '[] r -> r Source #
AnnotateInstr xs r => AnnotateInstr (Notes t ': xs) r Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods annotateInstr :: Anns (Notes t ': xs) -> AnnotateInstrArg (Notes t ': xs) r -> r Source #
AnnotateInstr xs r => AnnotateInstr (Annotation tag ': xs) r Source #
Instance details Defined in Morley.Michelson.Typed.Annotation Methods annotateInstr :: Anns (Annotation tag ': xs) -> AnnotateInstrArg (Annotation tag ': xs) r -> r Source #

type AnnVar = Anns '[VarAnn] Source #

Anns only containing a single VarAnn.

pattern AsUTypeExt :: () => SingI t => Sing t -> Notes t -> Ty Source #

Similar to AsUType, but also gives Sing for given type.

pattern AsUType :: () => SingI t => Notes t -> Ty Source #

Transparently represent untyped Ty as wrapper over Notes t from typed world with SingI t constraint.

As expression this carries logic of mkUType, and as pattern it performs withUType but may make code a bit cleaner.

Note about constraints: pattern signatures usually require two constraints - one they require and another one which they provide. In our case we require nothing (thus first constraint is ()) and provide some knowledge about t.

fromUType :: Ty -> T Source #

withUType :: Ty -> (forall t. SingI t => Notes t -> r) -> r Source #

Convert Ty to the isomorphic set of information from typed world.

data SomeViewsSet' instr where Source #

Constructors

SomeViewsSet :: SingI st => ViewsSet' instr st -> SomeViewsSet' instr

Instances

Instances details

(forall (i :: [T]) (o :: [T]). Show (instr i o)) => Show (SomeViewsSet' instr) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> SomeViewsSet' instr -> ShowS # show :: SomeViewsSet' instr -> String # showList :: [SomeViewsSet' instr] -> ShowS #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (SomeViewsSet' instr) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: SomeViewsSet' instr -> () #
(forall (i :: [T]) (o :: [T]). Eq (instr i o)) => Eq (SomeViewsSet' instr) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: SomeViewsSet' instr -> SomeViewsSet' instr -> Bool # (/=) :: SomeViewsSet' instr -> SomeViewsSet' instr -> Bool #

newtype ViewsSet' instr st Source #

Views that belong to one contract.

Constructors

UnsafeViewsSet
Fields unViewsSet :: Map ViewName (SomeView' instr st)

Bundled Patterns

pattern ViewsList :: [SomeView' instr st] -> ViewsSet' instr st

Instances

Instances details

(forall (i :: [T]) (o :: [T]). Show (instr i o)) => Show (ViewsSet' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> ViewsSet' instr st -> ShowS # show :: ViewsSet' instr st -> String # showList :: [ViewsSet' instr st] -> ShowS #
Default (ViewsSet' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods def :: ViewsSet' instr st #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (ViewsSet' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: ViewsSet' instr st -> () #
(forall (i :: [T]) (o :: [T]). Eq (instr i o)) => Eq (ViewsSet' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: ViewsSet' instr st -> ViewsSet' instr st -> Bool # (/=) :: ViewsSet' instr st -> ViewsSet' instr st -> Bool #
Container (ViewsSet' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Associated Types type Element (ViewsSet' instr st) # Methods toList :: ViewsSet' instr st -> [Element (ViewsSet' instr st)] # null :: ViewsSet' instr st -> Bool # foldr :: (Element (ViewsSet' instr st) -> b -> b) -> b -> ViewsSet' instr st -> b # foldl :: (b -> Element (ViewsSet' instr st) -> b) -> b -> ViewsSet' instr st -> b # foldl' :: (b -> Element (ViewsSet' instr st) -> b) -> b -> ViewsSet' instr st -> b # length :: ViewsSet' instr st -> Int # elem :: Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool # foldMap :: Monoid m => (Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m # fold :: ViewsSet' instr st -> Element (ViewsSet' instr st) # foldr' :: (Element (ViewsSet' instr st) -> b -> b) -> b -> ViewsSet' instr st -> b # notElem :: Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool # all :: (Element (ViewsSet' instr st) -> Bool) -> ViewsSet' instr st -> Bool # any :: (Element (ViewsSet' instr st) -> Bool) -> ViewsSet' instr st -> Bool # and :: ViewsSet' instr st -> Bool # or :: ViewsSet' instr st -> Bool # find :: (Element (ViewsSet' instr st) -> Bool) -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeHead :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeMaximum :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeMinimum :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeFoldr1 :: (Element (ViewsSet' instr st) -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st)) -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeFoldl1 :: (Element (ViewsSet' instr st) -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st)) -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) #
type Element (ViewsSet' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View type Element (ViewsSet' instr st) = Element (Map ViewName (SomeView' instr st))

data SomeView' instr st where Source #

Constructors

SomeView :: View' instr arg st ret -> SomeView' instr st

Instances

Instances details

(forall (arg :: T) (ret :: T). Show (ViewCode' instr arg st ret)) => Show (SomeView' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> SomeView' instr st -> ShowS # show :: SomeView' instr st -> String # showList :: [SomeView' instr st] -> ShowS #
(forall (arg :: T) (ret :: T). NFData (ViewCode' instr arg st ret)) => NFData (SomeView' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: SomeView' instr st -> () #
(forall (arg :: T) (ret :: T). Eq (ViewCode' instr arg st ret)) => Eq (SomeView' instr st) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: SomeView' instr st -> SomeView' instr st -> Bool # (/=) :: SomeView' instr st -> SomeView' instr st -> Bool #

data View' instr arg st ret Source #

Contract view.

Constructors

(ViewableScope arg, SingI st, ViewableScope ret) => View
Fields vName :: ViewName Name of the view. vArgument :: Notes arg Argument type annotations. vReturn :: Notes ret Return type annotations. vCode :: ViewCode' instr arg st ret View code.

Instances

Instances details

Show (ViewCode' instr arg st ret) => Show (View' instr arg st ret) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> View' instr arg st ret -> ShowS # show :: View' instr arg st ret -> String # showList :: [View' instr arg st ret] -> ShowS #
NFData (ViewCode' instr arg st ret) => NFData (View' instr arg st ret) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: View' instr arg st ret -> () #
Eq (ViewCode' instr arg st ret) => Eq (View' instr arg st ret) Source #
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: View' instr arg st ret -> View' instr arg st ret -> Bool # (/=) :: View' instr arg st ret -> View' instr arg st ret -> Bool #

type ViewCode' instr arg st ret = instr '['TPair arg st] '[ret] Source #

someViewName :: SomeView' instr st -> ViewName Source #

Obtain the name of the view.

mkViewsSet :: [SomeView' instr st] -> Either ViewsSetError (ViewsSet' instr st) Source #

Construct views set.

emptyViewsSet :: forall instr st. ViewsSet' instr st Source #

No views.

addViewToSet :: View' instr arg st ret -> ViewsSet' instr st -> Either ViewsSetError (ViewsSet' instr st) Source #

Add a view to set.

lookupView :: forall instr st. ViewName -> ViewsSet' instr st -> Maybe (SomeView' instr st) Source #

Find a view in the set.

viewsSetNames :: forall instr st. ViewsSet' instr st -> Set ViewName Source #

Get all taken names in views set.

data EpLiftSequence (arg :: T) (param :: T) where Source #

Describes how to construct full contract parameter from given entrypoint argument.

This could be just wrapper over Value arg -> Value param, but we cannot use Value type in this module easily.

Constructors

EplArgHere :: EpLiftSequence arg arg
EplWrapLeft :: (SingI subparam, SingI r) => EpLiftSequence arg subparam -> EpLiftSequence arg ('TOr subparam r)
EplWrapRight :: (SingI l, SingI subparam) => EpLiftSequence arg subparam -> EpLiftSequence arg ('TOr l subparam)

Instances

Instances details

Show (EpLiftSequence arg param) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EpLiftSequence arg param -> ShowS # show :: EpLiftSequence arg param -> String # showList :: [EpLiftSequence arg param] -> ShowS #
NFData (EpLiftSequence arg param) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EpLiftSequence arg param -> () #
Buildable (EpLiftSequence arg param) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: EpLiftSequence arg param -> Builder #
Eq (EpLiftSequence arg param) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EpLiftSequence arg param -> EpLiftSequence arg param -> Bool # (/=) :: EpLiftSequence arg param -> EpLiftSequence arg param -> Bool #

data ParamEpError Source #

Errors specific to parameter type declaration (entrypoints).

Constructors

ParamEpDuplicatedNames (NonEmpty EpName)
ParamEpUncallableArm ArmCoords

Instances

Instances details

Generic ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep ParamEpError :: Type -> Type # Methods from :: ParamEpError -> Rep ParamEpError x # to :: Rep ParamEpError x -> ParamEpError #
Show ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ParamEpError -> ShowS # show :: ParamEpError -> String # showList :: [ParamEpError] -> ShowS #
NFData ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ParamEpError -> () #
Buildable ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: ParamEpError -> Builder #
Eq ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ParamEpError -> ParamEpError -> Bool # (/=) :: ParamEpError -> ParamEpError -> Bool #
RenderDoc ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods renderDoc :: RenderContext -> ParamEpError -> Doc Source # isRenderable :: ParamEpError -> Bool Source #
type Rep ParamEpError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints type Rep ParamEpError = D1 ('MetaData "ParamEpError" "Morley.Michelson.Typed.Entrypoints" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "ParamEpDuplicatedNames" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (NonEmpty EpName))) :+: C1 ('MetaCons "ParamEpUncallableArm" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ArmCoords)))

data ArmCoord Source #

Constructors

AcLeft
AcRight

Instances

Instances details

Generic ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep ArmCoord :: Type -> Type # Methods from :: ArmCoord -> Rep ArmCoord x # to :: Rep ArmCoord x -> ArmCoord #
Show ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ArmCoord -> ShowS # show :: ArmCoord -> String # showList :: [ArmCoord] -> ShowS #
NFData ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ArmCoord -> () #
Buildable ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: ArmCoord -> Builder #
Eq ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ArmCoord -> ArmCoord -> Bool # (/=) :: ArmCoord -> ArmCoord -> Bool #
RenderDoc ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods renderDoc :: RenderContext -> ArmCoord -> Doc Source # isRenderable :: ArmCoord -> Bool Source #
type Rep ArmCoord Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints type Rep ArmCoord = D1 ('MetaData "ArmCoord" "Morley.Michelson.Typed.Entrypoints" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "AcLeft" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AcRight" 'PrefixI 'False) (U1 :: Type -> Type))

type ArmCoords = [ArmCoord] Source #

Coordinates of "arm" in Or tree, used solely in error messages.

data ParamNotes (t :: T) Source #

Annotations for contract parameter declaration.

Following the Michelson specification, this type has the following invariants: 1. No entrypoint name is duplicated. 2. If default entrypoint is explicitly assigned, no "arm" remains uncallable.

Constructors

UnsafeParamNotes
Fields pnNotes :: Notes t pnRootAnn :: RootAnn

Instances

Instances details

Generic (ParamNotes t) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep (ParamNotes t) :: Type -> Type # Methods from :: ParamNotes t -> Rep (ParamNotes t) x # to :: Rep (ParamNotes t) x -> ParamNotes t #
Show (ParamNotes t) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ParamNotes t -> ShowS # show :: ParamNotes t -> String # showList :: [ParamNotes t] -> ShowS #
NFData (ParamNotes t) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ParamNotes t -> () #
Eq (ParamNotes t) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ParamNotes t -> ParamNotes t -> Bool # (/=) :: ParamNotes t -> ParamNotes t -> Bool #
type Rep (ParamNotes t) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints type Rep (ParamNotes t) = D1 ('MetaData "ParamNotes" "Morley.Michelson.Typed.Entrypoints" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "UnsafeParamNotes" 'PrefixI 'True) (S1 ('MetaSel ('Just "pnNotes") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Notes t)) :*: S1 ('MetaSel ('Just "pnRootAnn") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 RootAnn)))

data ParseEpAddressError Source #

Constructors

ParseEpAddressBadAddress ParseAddressError
ParseEpAddressRawBadAddress ParseAddressRawError
ParseEpAddressBadEntryopint ByteString UnicodeException
ParseEpAddressBadRefAnn Text
ParseEpAddressRefAnnError EpNameFromRefAnnError
ParseEpAddressInvalidLength Int

Instances

Instances details

Generic ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep ParseEpAddressError :: Type -> Type # Methods from :: ParseEpAddressError -> Rep ParseEpAddressError x # to :: Rep ParseEpAddressError x -> ParseEpAddressError #
Show ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ParseEpAddressError -> ShowS # show :: ParseEpAddressError -> String # showList :: [ParseEpAddressError] -> ShowS #
NFData ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ParseEpAddressError -> () #
Buildable ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: ParseEpAddressError -> Builder #
Eq ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ParseEpAddressError -> ParseEpAddressError -> Bool # (/=) :: ParseEpAddressError -> ParseEpAddressError -> Bool #
RenderDoc ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods renderDoc :: RenderContext -> ParseEpAddressError -> Doc Source # isRenderable :: ParseEpAddressError -> Bool Source #
type Rep ParseEpAddressError Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints type Rep ParseEpAddressError = D1 ('MetaData "ParseEpAddressError" "Morley.Michelson.Typed.Entrypoints" "morley-1.19.1-inplace" 'False) ((C1 ('MetaCons "ParseEpAddressBadAddress" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ParseAddressError)) :+: (C1 ('MetaCons "ParseEpAddressRawBadAddress" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ParseAddressRawError)) :+: C1 ('MetaCons "ParseEpAddressBadEntryopint" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ByteString) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 UnicodeException)))) :+: (C1 ('MetaCons "ParseEpAddressBadRefAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "ParseEpAddressRefAnnError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 EpNameFromRefAnnError)) :+: C1 ('MetaCons "ParseEpAddressInvalidLength" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)))))

data EpAddress Source #

Address with optional entrypoint name attached to it.

Constructors

EpAddress'
Fields eaAddress :: Address Address itself eaEntrypoint :: EpName Entrypoint name (might be empty)

Bundled Patterns

pattern EpAddress :: KindedAddress kind -> EpName -> EpAddress

Instances

Instances details

Generic EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep EpAddress :: Type -> Type # Methods from :: EpAddress -> Rep EpAddress x # to :: Rep EpAddress x -> EpAddress #
Show EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EpAddress -> ShowS # show :: EpAddress -> String # showList :: [EpAddress] -> ShowS #
NFData EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EpAddress -> () #
Buildable EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: EpAddress -> Builder #
Eq EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EpAddress -> EpAddress -> Bool # (/=) :: EpAddress -> EpAddress -> Bool #
Ord EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods compare :: EpAddress -> EpAddress -> Ordering # (<) :: EpAddress -> EpAddress -> Bool # (<=) :: EpAddress -> EpAddress -> Bool # (>) :: EpAddress -> EpAddress -> Bool # (>=) :: EpAddress -> EpAddress -> Bool # max :: EpAddress -> EpAddress -> EpAddress # min :: EpAddress -> EpAddress -> EpAddress #
HasRPCRepr EpAddress Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC EpAddress Source #
TypeHasDoc EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions EpAddress :: FieldDescriptions Source # Methods typeDocName :: Proxy EpAddress -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy EpAddress -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep EpAddress Source # typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress Source #
IsoValue EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT EpAddress :: T Source # Methods toVal :: EpAddress -> Value (ToT EpAddress) Source # fromVal :: Value (ToT EpAddress) -> EpAddress Source #
type Rep EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints type Rep EpAddress = D1 ('MetaData "EpAddress" "Morley.Michelson.Typed.Entrypoints" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "EpAddress'" 'PrefixI 'True) (S1 ('MetaSel ('Just "eaAddress") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Address) :*: S1 ('MetaSel ('Just "eaEntrypoint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 EpName)))
type AsRPC EpAddress Source #
Instance details Defined in Morley.AsRPC type AsRPC EpAddress = EpAddress
type TypeDocFieldDescriptions EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions EpAddress = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT EpAddress = 'TAddress

pattern ParamNotes :: Notes t -> RootAnn -> ParamNotes t Source #

formatEpAddress :: EpAddress -> Text Source #

mformatEpAddress :: EpAddress -> MText Source #

parseEpAddress :: Text -> Either ParseEpAddressError EpAddress Source #

Parse an address which can be suffixed with entrypoint name (e.g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU%entrypoint").

parseEpAddressRaw :: ByteString -> Either ParseEpAddressError EpAddress Source #

Parses byte representation of entrypoint address.

For every address

KT1QbdJ7M7uAQZwLpvzerUyk7LYkJWDL7eDh%foo%bar

we get the following byte representation

01afab866e7f1e74f9bba388d66b246276ce50bf4700666f6f25626172
______________________________________//__/____
              address                     %   ep1  % ep2

starParamNotes :: SingI t => ParamNotes t Source #

Parameter without annotations.

mkParamNotes :: Notes t -> RootAnn -> Either ParamEpError (ParamNotes t) Source #

Construct ParamNotes performing all necessary checks.

data MkEntrypointCallRes param where Source #

Constructors

MkEntrypointCallRes :: ParameterScope arg => Notes arg -> EntrypointCallT param arg -> MkEntrypointCallRes param

data SomeEntrypointCallT (arg :: T) Source #

EntrypointCallT with hidden parameter type.

This requires argument to satisfy ParameterScope constraint. Strictly speaking, entrypoint argument may one day start having different set of constraints comparing to ones applied to parameter, but this seems unlikely.

Constructors

forall param.ParameterScope param => SomeEpc (EntrypointCallT param arg)

Instances

Instances details

Show (SomeEntrypointCallT arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> SomeEntrypointCallT arg -> ShowS # show :: SomeEntrypointCallT arg -> String # showList :: [SomeEntrypointCallT arg] -> ShowS #
NFData (SomeEntrypointCallT arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: SomeEntrypointCallT arg -> () #
Buildable (SomeEntrypointCallT arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: SomeEntrypointCallT arg -> Builder #
Eq (SomeEntrypointCallT arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: SomeEntrypointCallT arg -> SomeEntrypointCallT arg -> Bool # (/=) :: SomeEntrypointCallT arg -> SomeEntrypointCallT arg -> Bool #

type family ForbidOr (t :: T) :: Constraint where ... Source #

Equations

ForbidOr ('TOr l r) = TypeError ('Text "Cannot apply to sum type parameter " :<>: 'ShowType ('TOr l r))
ForbidOr _ = ()

data EntrypointCallT (param :: T) (arg :: T) Source #

Reference for calling a specific entrypoint of type arg.

Constructors

ParameterScope arg => EntrypointCall
Fields epcName :: EpName Name of entrypoint. epcParamProxy :: Proxy param Proxy of parameter, to make parameter type more easily fetchable. epcLiftSequence :: EpLiftSequence arg param How to call this entrypoint in the corresponding contract.

Instances

Instances details

Show (EntrypointCallT param arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EntrypointCallT param arg -> ShowS # show :: EntrypointCallT param arg -> String # showList :: [EntrypointCallT param arg] -> ShowS #
NFData (EntrypointCallT param arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EntrypointCallT param arg -> () #
Buildable (EntrypointCallT param arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: EntrypointCallT param arg -> Builder #
Eq (EntrypointCallT param arg) Source #
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EntrypointCallT param arg -> EntrypointCallT param arg -> Bool # (/=) :: EntrypointCallT param arg -> EntrypointCallT param arg -> Bool #

unsafeEpcCallRoot :: ParameterScope param => EntrypointCallT param param Source #

Construct EntrypointCallT which calls no entrypoint and assumes that there is no explicit "default" one.

Validity of such operation is not ensured.

epcPrimitive :: forall p. (ParameterScope p, ForbidOr p) => EntrypointCallT p p Source #

Call parameter which has no entrypoints, always safe.

unsafeSepcCallRoot :: ParameterScope param => SomeEntrypointCallT param Source #

Construct SomeEntrypointCallT which calls no entrypoint and assumes that there is no explicit "default" one.

Validity of such operation is not ensured.

sepcPrimitive :: forall t. (ParameterScope t, ForbidOr t) => SomeEntrypointCallT t Source #

Call parameter which has no entrypoints, always safe.

sepcName :: SomeEntrypointCallT arg -> EpName Source #

mkEntrypointCall :: ParameterScope param => EpName -> ParamNotes param -> Maybe (MkEntrypointCallRes param) Source #

Build EntrypointCallT.

Here we accept entrypoint name and type information for the parameter of target contract.

Returns Nothing if entrypoint is not found.

Prefer using mkDefEntrypointCall for the default entrypoint.

mkDefEntrypointCall :: ParameterScope param => ParamNotes param -> MkEntrypointCallRes param Source #

Build EntrypointCallT calling the default entrypoint. Unlike mkEntrypointCall, always succeeds.

tyImplicitAccountParam :: ParamNotes 'TUnit Source #

parameter type of implicit account.

data Contract' instr cp st Source #

Typed contract and information about annotations which is not present in the contract code.

Constructors

(ParameterScope cp, StorageScope st) => Contract
Fields cCode :: ContractCode' instr cp st cParamNotes :: ParamNotes cp cStoreNotes :: Notes st cViews :: ViewsSet' instr st cEntriesOrder :: EntriesOrder

Instances

Instances details

ToExpression (Contract cp st) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Contract cp st -> Expression Source #
ContainsDoc (Contract cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods buildDocUnfinalized :: Contract cp st -> ContractDoc Source #
ContainsUpdateableDoc (Contract cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> Contract cp st -> Contract cp st Source #
(forall (i :: [T]) (o :: [T]). Show (instr i o)) => Show (Contract' instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Contract Methods showsPrec :: Int -> Contract' instr cp st -> ShowS # show :: Contract' instr cp st -> String # showList :: [Contract' instr cp st] -> ShowS #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (Contract' instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Contract Methods rnf :: Contract' instr cp st -> () #
(forall (i :: [T]) (o :: [T]). Eq (instr i o)) => Eq (Contract' instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Contract Methods (==) :: Contract' instr cp st -> Contract' instr cp st -> Bool # (/=) :: Contract' instr cp st -> Contract' instr cp st -> Bool #

class IsNotInView Source #

Constraint ensuring the given code does not appear on the top level of a view. Some Michelson instructions are forbidden on the top level of views, but allowed in main contract code, and also inside lambdas in views. Hence, this constraint can be provided by mkContractCode or by mkVLam.

Instances

Instances details

(TypeError ('Text "Not allowed on the top level of a view") :: Constraint) => IsNotInView Source #
Instance details Defined in Morley.Michelson.Typed.Contract

newtype ContractCode' instr cp st Source #

A wrapper for contract code. The newtype is mostly there to avoid accidentally passing code from inside ContractCode into a view for example, as semantics are slightly different.

Constructors

ContractCode
Fields unContractCode :: instr (ContractInp cp st) (ContractOut st)

Instances

Instances details

ContainsDoc (ContractCode inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods buildDocUnfinalized :: ContractCode inp out -> ContractDoc Source #
ContainsUpdateableDoc (ContractCode inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> ContractCode inp out -> ContractCode inp out Source #
Show (instr (ContractInp cp st) (ContractOut st)) => Show (ContractCode' instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Contract Methods showsPrec :: Int -> ContractCode' instr cp st -> ShowS # show :: ContractCode' instr cp st -> String # showList :: [ContractCode' instr cp st] -> ShowS #
NFData (instr (ContractInp cp st) (ContractOut st)) => NFData (ContractCode' instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Contract Methods rnf :: ContractCode' instr cp st -> () #
Eq (instr (ContractInp cp st) (ContractOut st)) => Eq (ContractCode' instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Contract Methods (==) :: ContractCode' instr cp st -> ContractCode' instr cp st -> Bool # (/=) :: ContractCode' instr cp st -> ContractCode' instr cp st -> Bool #

type ContractOut st = '[ContractOut1 st] Source #

type ContractOut1 st = 'TPair ('TList 'TOperation) st Source #

type ContractInp param st = '[ContractInp1 param st] Source #

type ContractInp1 param st = 'TPair param st Source #

mkContractCode :: (IsNotInView => instr (ContractInp cp st) (ContractOut st)) -> ContractCode' instr cp st Source #

A helper to construct ContractCode'. This helper provides the constraint that the contract code is not in a view.

defaultContract :: (ParameterScope cp, StorageScope st) => (IsNotInView => instr (ContractInp cp st) (ContractOut st)) -> Contract' instr cp st Source #

mapContractCodeBlock :: (instr (ContractInp cp st) (ContractOut st) -> instr (ContractInp cp st) (ContractOut st)) -> Contract' instr cp st -> Contract' instr cp st Source #

Transform contract code block.

To map e.g. views too, see mapContractCode.

mapContractCodeBlockM :: Monad m => (instr (ContractInp cp st) (ContractOut st) -> m (instr (ContractInp cp st) (ContractOut st))) -> Contract' instr cp st -> m (Contract' instr cp st) Source #

Transform contract code block, monadic version.

To map e.g. views too, see mapContractCodeM.

mapContractViewBlocks :: (forall arg ret. ViewCode' instr arg st ret -> ViewCode' instr arg st ret) -> Contract' instr cp st -> Contract' instr cp st Source #

mapContractViewBlocksM :: Monad m => (forall arg ret. ViewCode' instr arg st ret -> m (ViewCode' instr arg st ret)) -> Contract' instr cp st -> m (Contract' instr cp st) Source #

mapContractCode :: (forall i o. instr i o -> instr i o) -> Contract' instr cp st -> Contract' instr cp st Source #

Map all the blocks with some code in the contract.

mapContractCodeM :: Monad m => (forall i o. instr i o -> m (instr i o)) -> Contract' instr cp st -> m (Contract' instr cp st) Source #

Map all the blocks with some code in the contract, monadic version.

mapEntriesOrdered :: Contract' instr cp st -> (ParamNotes cp -> a) -> (Notes st -> a) -> (ContractCode' instr cp st -> a) -> (forall arg ret. View' instr arg st ret -> a) -> [a] Source #

Deprecated: Unused and untested, essentially dead code; open an issue on the morley repository if you use this.

Map each typed contract fields by the given function and sort the output based on the EntriesOrder.

data LambdaCode' instr inp out where Source #

Constructors

LambdaCode :: (forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => RemFail instr (inp ': '[]) (out ': '[]) -> LambdaCode' instr inp out
LambdaCodeRec :: (forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => RemFail instr (inp ': ('TLambda inp out ': '[])) (out ': '[]) -> LambdaCode' instr inp out

Instances

Instances details

Show (LambdaCode' instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> LambdaCode' instr inp out -> ShowS # show :: LambdaCode' instr inp out -> String # showList :: [LambdaCode' instr inp out] -> ShowS #
NFData (LambdaCode' instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: LambdaCode' instr inp out -> () #
Eq (LambdaCode' instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: LambdaCode' instr inp out -> LambdaCode' instr inp out -> Bool # (/=) :: LambdaCode' instr inp out -> LambdaCode' instr inp out -> Bool #

data Value' instr t where Source #

Representation of Michelson value.

Type parameter instr stands for Michelson instruction type, i.e. data type to represent an instruction of language.

Constructors

VKey :: PublicKey -> Value' instr 'TKey
VUnit :: Value' instr 'TUnit
VSignature :: Signature -> Value' instr 'TSignature
VChainId :: ChainId -> Value' instr 'TChainId
VOption :: forall t instr. SingI t => Maybe (Value' instr t) -> Value' instr ('TOption t)
VList :: forall t instr. SingI t => [Value' instr t] -> Value' instr ('TList t)
VSet :: forall t instr. (SingI t, Comparable t) => Set (Value' instr t) -> Value' instr ('TSet t)
VOp :: Operation' instr -> Value' instr 'TOperation
VContract :: forall arg instr. (SingI arg, HasNoOp arg) => Address -> SomeEntrypointCallT arg -> Value' instr ('TContract arg)
VTicket :: forall arg instr. Comparable arg => Address -> Value' instr arg -> Natural -> Value' instr ('TTicket arg)
VPair :: forall l r instr. (Value' instr l, Value' instr r) -> Value' instr ('TPair l r)
VOr :: forall l r instr. (SingI l, SingI r) => Either (Value' instr l) (Value' instr r) -> Value' instr ('TOr l r)
VLam :: forall inp out instr. (SingI inp, SingI out, forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => LambdaCode' instr inp out -> Value' instr ('TLambda inp out)
VMap :: forall k v instr. (SingI k, SingI v, Comparable k) => Map (Value' instr k) (Value' instr v) -> Value' instr ('TMap k v)
VBigMap
Fields :: forall k v instr. (SingI k, SingI v, Comparable k, HasNoBigMap v) => Maybe Natural The big_map's ID. This is only used in the interpreter. -> Map (Value' instr k) (Value' instr v) -> Value' instr ('TBigMap k v)
VInt :: Integer -> Value' instr 'TInt
VNat :: Natural -> Value' instr 'TNat
VString :: MText -> Value' instr 'TString
VBytes :: ByteString -> Value' instr 'TBytes
VMutez :: Mutez -> Value' instr 'TMutez
VBool :: Bool -> Value' instr 'TBool
VKeyHash :: KeyHash -> Value' instr 'TKeyHash
VTimestamp :: Timestamp -> Value' instr 'TTimestamp
VAddress :: EpAddress -> Value' instr 'TAddress
VBls12381Fr :: Bls12381Fr -> Value' instr 'TBls12381Fr
VBls12381G1 :: Bls12381G1 -> Value' instr 'TBls12381G1
VBls12381G2 :: Bls12381G2 -> Value' instr 'TBls12381G2
VChest :: Chest -> Value' instr 'TChest
VChestKey :: ChestKey -> Value' instr 'TChestKey

Instances

Instances details

(FromExp x Value, SingI t) => FromExp x (Value t) Source #
Instance details Defined in Morley.Micheline.Class Methods fromExp :: Exp x -> Either (FromExpError x) (Value t) Source #
GEq (Value' instr :: T -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods geq :: forall (a :: k) (b :: k). Value' instr a -> Value' instr b -> Maybe (a :~: b) #
HasRPCRepr (Value t) Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Value t) Source #
HasNoOp t => ToExpression (Value t) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Value t -> Expression Source #
(forall (t :: T). cs t => HasNoOp t) => RenderDoc (SomeConstrainedValue cs) Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods renderDoc :: RenderContext -> SomeConstrainedValue cs -> Doc Source # isRenderable :: SomeConstrainedValue cs -> Bool Source #
WellTyped t => IsoValue (Value t) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Value t) :: T Source # Methods toVal :: Value t -> Value (ToT (Value t)) Source # fromVal :: Value (ToT (Value t)) -> Value t Source #
Show (Value' instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> Value' instr t -> ShowS # show :: Value' instr t -> String # showList :: [Value' instr t] -> ShowS #
NFData (Value' instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: Value' instr t -> () #
Buildable (Value' Instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods build :: Value' Instr t -> Builder #
Eq (Value' instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: Value' instr t -> Value' instr t -> Bool # (/=) :: Value' instr t -> Value' instr t -> Bool #
Comparable t => Ord (Value' instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods compare :: Value' instr t -> Value' instr t -> Ordering # (<) :: Value' instr t -> Value' instr t -> Bool # (<=) :: Value' instr t -> Value' instr t -> Bool # (>) :: Value' instr t -> Value' instr t -> Bool # (>=) :: Value' instr t -> Value' instr t -> Bool # max :: Value' instr t -> Value' instr t -> Value' instr t # min :: Value' instr t -> Value' instr t -> Value' instr t #
At (Value' instr ('TBigMap k v)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods at :: Index (Value' instr ('TBigMap k v)) -> Lens' (Value' instr ('TBigMap k v)) (Maybe (IxValue (Value' instr ('TBigMap k v)))) #
At (Value' instr ('TMap k v)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods at :: Index (Value' instr ('TMap k v)) -> Lens' (Value' instr ('TMap k v)) (Maybe (IxValue (Value' instr ('TMap k v)))) #
At (Value' instr ('TSet a)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods at :: Index (Value' instr ('TSet a)) -> Lens' (Value' instr ('TSet a)) (Maybe (IxValue (Value' instr ('TSet a)))) #
Ixed (Value' instr ('TBigMap k v)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods ix :: Index (Value' instr ('TBigMap k v)) -> Traversal' (Value' instr ('TBigMap k v)) (IxValue (Value' instr ('TBigMap k v))) #
Ixed (Value' instr ('TList elem)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods ix :: Index (Value' instr ('TList elem)) -> Traversal' (Value' instr ('TList elem)) (IxValue (Value' instr ('TList elem))) #
Ixed (Value' instr ('TMap k v)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods ix :: Index (Value' instr ('TMap k v)) -> Traversal' (Value' instr ('TMap k v)) (IxValue (Value' instr ('TMap k v))) #
Ixed (Value' instr ('TSet a)) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods ix :: Index (Value' instr ('TSet a)) -> Traversal' (Value' instr ('TSet a)) (IxValue (Value' instr ('TSet a))) #
HasNoOp t => RenderDoc (Value' Instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods renderDoc :: RenderContext -> Value' Instr t -> Doc Source # isRenderable :: Value' Instr t -> Bool Source #
type AsRPC (Value t) Source #
Instance details Defined in Morley.AsRPC type AsRPC (Value t) = Value (TAsRPC t)
type ToT (Value t) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Value t) = t
type Index (Value' _1 ('TList _2)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type Index (Value' _1 ('TList _2)) = Int
type Index (Value' instr ('TBigMap k _1)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type Index (Value' instr ('TBigMap k _1)) = Value' instr k
type Index (Value' instr ('TMap k _1)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type Index (Value' instr ('TMap k _1)) = Value' instr k
type Index (Value' instr ('TSet a)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type Index (Value' instr ('TSet a)) = Value' instr a
type IxValue (Value' _1 ('TSet _2)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type IxValue (Value' _1 ('TSet _2)) = ()
type IxValue (Value' instr ('TBigMap _1 v)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type IxValue (Value' instr ('TBigMap _1 v)) = Value' instr v
type IxValue (Value' instr ('TList elem)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type IxValue (Value' instr ('TList elem)) = Value' instr elem
type IxValue (Value' instr ('TMap _1 v)) Source #
Instance details Defined in Morley.Michelson.Typed.Value type IxValue (Value' instr ('TMap _1 v)) = Value' instr v

data RemFail (instr :: k -> k -> Type) (i :: k) (o :: k) where Source #

Wrapper over instruction which remembers whether this instruction always fails or not.

Constructors

RfNormal :: instr i o -> RemFail instr i o
RfAlwaysFails :: (forall o'. instr i o') -> RemFail instr i o

Instances

Instances details

(forall (o' :: k). Show (instr i o')) => Show (RemFail instr i o) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> RemFail instr i o -> ShowS # show :: RemFail instr i o -> String # showList :: [RemFail instr i o] -> ShowS #
(forall (o' :: k). NFData (instr i o')) => NFData (RemFail instr i o) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: RemFail instr i o -> () #
Eq (instr i o) => Eq (RemFail instr i o) Source #	Ignoring distinction between constructors here, comparing only semantics.
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: RemFail instr i o -> RemFail instr i o -> Bool # (/=) :: RemFail instr i o -> RemFail instr i o -> Bool #

data Emit instr t Source #

Constructors

PackedValScope t => Emit
Fields emTag :: Text emNotes :: Notes t emValue :: Value' instr t emCounter :: GlobalCounter

Instances

Instances details

Show (Emit instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> Emit instr t -> ShowS # show :: Emit instr t -> String # showList :: [Emit instr t] -> ShowS #
NFData (Emit instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: Emit instr t -> () #
Buildable (Value' instr t) => Buildable (Emit instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods build :: Emit instr t -> Builder #
Eq (Emit instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: Emit instr t -> Emit instr t -> Bool # (/=) :: Emit instr t -> Emit instr t -> Bool #

data CreateContract instr cp st Source #

Constructors

(forall i o. Show (instr i o), forall i o. Eq (instr i o)) => CreateContract
Fields ccOriginator :: L1Address ccDelegate :: Maybe KeyHash ccBalance :: Mutez ccStorageVal :: Value' instr st ccContract :: Contract' instr cp st ccCounter :: GlobalCounter

Instances

Instances details

Show (CreateContract instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> CreateContract instr cp st -> ShowS # show :: CreateContract instr cp st -> String # showList :: [CreateContract instr cp st] -> ShowS #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (CreateContract instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: CreateContract instr cp st -> () #
Buildable (Value' instr st) => Buildable (CreateContract instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods build :: CreateContract instr cp st -> Builder #
Eq (CreateContract instr cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: CreateContract instr cp st -> CreateContract instr cp st -> Bool # (/=) :: CreateContract instr cp st -> CreateContract instr cp st -> Bool #

data SetDelegate Source #

Constructors

SetDelegate
Fields sdMbKeyHash :: Maybe KeyHash sdCounter :: GlobalCounter

Instances

Instances details

Generic SetDelegate Source #
Instance details Defined in Morley.Michelson.Typed.Value Associated Types type Rep SetDelegate :: Type -> Type # Methods from :: SetDelegate -> Rep SetDelegate x # to :: Rep SetDelegate x -> SetDelegate #
Show SetDelegate Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> SetDelegate -> ShowS # show :: SetDelegate -> String # showList :: [SetDelegate] -> ShowS #
NFData SetDelegate Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: SetDelegate -> () #
Buildable SetDelegate Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods build :: SetDelegate -> Builder #
Eq SetDelegate Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: SetDelegate -> SetDelegate -> Bool # (/=) :: SetDelegate -> SetDelegate -> Bool #
type Rep SetDelegate Source #
Instance details Defined in Morley.Michelson.Typed.Value type Rep SetDelegate = D1 ('MetaData "SetDelegate" "Morley.Michelson.Typed.Value" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "SetDelegate" 'PrefixI 'True) (S1 ('MetaSel ('Just "sdMbKeyHash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe KeyHash)) :*: S1 ('MetaSel ('Just "sdCounter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 GlobalCounter)))

data TransferTokens instr p Source #

Constructors

TransferTokens
Fields ttTransferArgument :: Value' instr p ttAmount :: Mutez ttContract :: Value' instr ('TContract p) ttCounter :: GlobalCounter

Instances

Instances details

Generic (TransferTokens instr p) Source #
Instance details Defined in Morley.Michelson.Typed.Value Associated Types type Rep (TransferTokens instr p) :: Type -> Type # Methods from :: TransferTokens instr p -> Rep (TransferTokens instr p) x # to :: Rep (TransferTokens instr p) x -> TransferTokens instr p #
Show (TransferTokens instr p) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> TransferTokens instr p -> ShowS # show :: TransferTokens instr p -> String # showList :: [TransferTokens instr p] -> ShowS #
NFData (TransferTokens instr p) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: TransferTokens instr p -> () #
Buildable (Value' instr p) => Buildable (TransferTokens instr p) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods build :: TransferTokens instr p -> Builder #
Eq (TransferTokens instr p) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: TransferTokens instr p -> TransferTokens instr p -> Bool # (/=) :: TransferTokens instr p -> TransferTokens instr p -> Bool #
type Rep (TransferTokens instr p) Source #
Instance details Defined in Morley.Michelson.Typed.Value type Rep (TransferTokens instr p) = D1 ('MetaData "TransferTokens" "Morley.Michelson.Typed.Value" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "TransferTokens" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ttTransferArgument") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Value' instr p)) :: S1 ('MetaSel ('Just "ttAmount") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Mutez)) :: (S1 ('MetaSel ('Just "ttContract") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Value' instr ('TContract p))) :*: S1 ('MetaSel ('Just "ttCounter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 GlobalCounter))))

data Operation' instr where Source #

Data type, representing operation, list of which is returned by Michelson contract (according to calling convention).

These operations are to be further executed against system state after the contract execution.

Constructors

OpTransferTokens :: ParameterScope p => TransferTokens instr p -> Operation' instr
OpSetDelegate :: SetDelegate -> Operation' instr
OpCreateContract :: (forall i o. Show (instr i o), forall i o. NFData (instr i o), Typeable instr, ParameterScope cp, StorageScope st) => CreateContract instr cp st -> Operation' instr
OpEmit :: PackedValScope t => Emit instr t -> Operation' instr

Instances

Instances details

HasRPCRepr Operation Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Operation Source #
TypeHasDoc Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Operation :: FieldDescriptions Source # Methods typeDocName :: Proxy Operation -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Operation -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Operation Source # typeDocMichelsonRep :: TypeDocMichelsonRep Operation Source #
IsoValue Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Operation :: T Source # Methods toVal :: Operation -> Value (ToT Operation) Source # fromVal :: Value (ToT Operation) -> Operation Source #
Show (Operation' instr) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> Operation' instr -> ShowS # show :: Operation' instr -> String # showList :: [Operation' instr] -> ShowS #
NFData (Operation' instr) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: Operation' instr -> () #
(forall (t :: T). Buildable (Value' instr t)) => Buildable (Operation' instr) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods build :: Operation' instr -> Builder #
Eq (Operation' instr) Source #
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: Operation' instr -> Operation' instr -> Bool # (/=) :: Operation' instr -> Operation' instr -> Bool #
type AsRPC Operation Source #
Instance details Defined in Morley.AsRPC type AsRPC Operation = Operation
type TypeDocFieldDescriptions Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Operation = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Operation = 'TOperation

rfMerge :: (forall o'. instr i1 o' -> instr i2 o' -> instr i3 o') -> RemFail instr i1 o -> RemFail instr i2 o -> RemFail instr i3 o Source #

Merge two execution branches.

rfAnyInstr :: RemFail instr i o -> instr i o Source #

Get code disregard whether it always fails or not.

rfMapAnyInstr :: (forall o'. instr i1 o' -> instr i2 o') -> RemFail instr i1 o -> RemFail instr i2 o Source #

Modify inner code.

addressToVContract :: forall t instr kind. (ParameterScope t, ForbidOr t) => KindedAddress kind -> Value' instr ('TContract t) Source #

Make value of contract type which refers to the given address and does not call any entrypoint.

buildVContract :: Value' instr ('TContract arg) -> Builder Source #

compileEpLiftSequence :: EpLiftSequence arg param -> Value' instr arg -> Value' instr param Source #

Turn EpLiftSequence into actual function on Values.

liftCallArg :: EntrypointCallT param arg -> Value' instr arg -> Value' instr param Source #

Lift entrypoint argument to full parameter.

valueTypeSanity :: Value' instr t -> Dict (SingI t) Source #

Get a witness of that value's type is known.

Note that we cannot pick such witness out of nowhere as not all types of kind T have Typeable and SingI instances; example:

type family Any :: T where
  -- nothing here

mkVLam :: (SingI inp, SingI out, forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => (IsNotInView => RemFail instr '[inp] '[out]) -> Value' instr ('TLambda inp out) Source #

mkVLamRec :: (SingI inp, SingI out, forall i o. Show (instr i o), forall i o. Eq (instr i o), forall i o. NFData (instr i o)) => (IsNotInView => RemFail instr '[inp, 'TLambda inp out] '[out]) -> Value' instr ('TLambda inp out) Source #

withValueTypeSanity :: Value' instr t -> (SingI t => a) -> a Source #

Provide a witness of that value's type is known.

eqValueExt :: Value' instr t1 -> Value' instr t2 -> Bool Source #

Extended values comparison - it does not require Values to be of the same type, only their content to match.

class EDivOp (n :: T) (m :: T) where Source #

Associated Types

type EDivOpRes n m :: T Source #

type EModOpRes n m :: T Source #

Methods

evalEDivOp :: Value' instr n -> Value' instr m -> Value' instr ('TOption ('TPair (EDivOpRes n m) (EModOpRes n m))) Source #

Instances

Instances details

EDivOp 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type EDivOpRes 'TInt 'TInt :: T Source # type EModOpRes 'TInt 'TInt :: T Source # Methods evalEDivOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TInt -> Value' instr 'TInt -> Value' instr ('TOption ('TPair (EDivOpRes 'TInt 'TInt) (EModOpRes 'TInt 'TInt))) Source #
EDivOp 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type EDivOpRes 'TInt 'TNat :: T Source # type EModOpRes 'TInt 'TNat :: T Source # Methods evalEDivOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TInt -> Value' instr 'TNat -> Value' instr ('TOption ('TPair (EDivOpRes 'TInt 'TNat) (EModOpRes 'TInt 'TNat))) Source #
EDivOp 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type EDivOpRes 'TMutez 'TMutez :: T Source # type EModOpRes 'TMutez 'TMutez :: T Source # Methods evalEDivOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TMutez -> Value' instr 'TMutez -> Value' instr ('TOption ('TPair (EDivOpRes 'TMutez 'TMutez) (EModOpRes 'TMutez 'TMutez))) Source #
EDivOp 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type EDivOpRes 'TMutez 'TNat :: T Source # type EModOpRes 'TMutez 'TNat :: T Source # Methods evalEDivOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TMutez -> Value' instr 'TNat -> Value' instr ('TOption ('TPair (EDivOpRes 'TMutez 'TNat) (EModOpRes 'TMutez 'TNat))) Source #
EDivOp 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type EDivOpRes 'TNat 'TInt :: T Source # type EModOpRes 'TNat 'TInt :: T Source # Methods evalEDivOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TNat -> Value' instr 'TInt -> Value' instr ('TOption ('TPair (EDivOpRes 'TNat 'TInt) (EModOpRes 'TNat 'TInt))) Source #
EDivOp 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type EDivOpRes 'TNat 'TNat :: T Source # type EModOpRes 'TNat 'TNat :: T Source # Methods evalEDivOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TNat -> Value' instr 'TNat -> Value' instr ('TOption ('TPair (EDivOpRes 'TNat 'TNat) (EModOpRes 'TNat 'TNat))) Source #

class SliceOp (c :: T) where Source #

Methods

evalSlice :: Natural -> Natural -> Value' instr c -> Maybe (Value' instr c) Source #

Instances

Instances details

SliceOp 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSlice :: forall (instr :: [T] -> [T] -> Type). Natural -> Natural -> Value' instr 'TBytes -> Maybe (Value' instr 'TBytes) Source #
SliceOp 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSlice :: forall (instr :: [T] -> [T] -> Type). Natural -> Natural -> Value' instr 'TString -> Maybe (Value' instr 'TString) Source #

class ConcatOp (c :: T) where Source #

Methods

evalConcat :: Value' instr c -> Value' instr c -> Value' instr c Source #

evalConcat' :: [Value' instr c] -> Value' instr c Source #

Instances

Instances details

ConcatOp 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalConcat :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TBytes -> Value' instr 'TBytes -> Value' instr 'TBytes Source # evalConcat' :: forall (instr :: [T] -> [T] -> Type). [Value' instr 'TBytes] -> Value' instr 'TBytes Source #
ConcatOp 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalConcat :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TString -> Value' instr 'TString -> Value' instr 'TString Source # evalConcat' :: forall (instr :: [T] -> [T] -> Type). [Value' instr 'TString] -> Value' instr 'TString Source #

class GetOp (c :: T) where Source #

Associated Types

type GetOpKey c :: T Source #

type GetOpVal c :: T Source #

Methods

evalGet :: Value' instr (GetOpKey c) -> Value' instr c -> Maybe (Value' instr (GetOpVal c)) Source #

Instances

Instances details

GetOp ('TBigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type GetOpKey ('TBigMap k v) :: T Source # type GetOpVal ('TBigMap k v) :: T Source # Methods evalGet :: forall (instr :: [T] -> [T] -> Type). Value' instr (GetOpKey ('TBigMap k v)) -> Value' instr ('TBigMap k v) -> Maybe (Value' instr (GetOpVal ('TBigMap k v))) Source #
GetOp ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type GetOpKey ('TMap k v) :: T Source # type GetOpVal ('TMap k v) :: T Source # Methods evalGet :: forall (instr :: [T] -> [T] -> Type). Value' instr (GetOpKey ('TMap k v)) -> Value' instr ('TMap k v) -> Maybe (Value' instr (GetOpVal ('TMap k v))) Source #

class UpdOp (c :: T) where Source #

Associated Types

type UpdOpKey c :: T Source #

type UpdOpParams c :: T Source #

Methods

evalUpd :: Value' instr (UpdOpKey c) -> Value' instr (UpdOpParams c) -> Value' instr c -> Value' instr c Source #

Instances

Instances details

UpdOp ('TSet a) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type UpdOpKey ('TSet a) :: T Source # type UpdOpParams ('TSet a) :: T Source # Methods evalUpd :: forall (instr :: [T] -> [T] -> Type). Value' instr (UpdOpKey ('TSet a)) -> Value' instr (UpdOpParams ('TSet a)) -> Value' instr ('TSet a) -> Value' instr ('TSet a) Source #
UpdOp ('TBigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type UpdOpKey ('TBigMap k v) :: T Source # type UpdOpParams ('TBigMap k v) :: T Source # Methods evalUpd :: forall (instr :: [T] -> [T] -> Type). Value' instr (UpdOpKey ('TBigMap k v)) -> Value' instr (UpdOpParams ('TBigMap k v)) -> Value' instr ('TBigMap k v) -> Value' instr ('TBigMap k v) Source #
UpdOp ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type UpdOpKey ('TMap k v) :: T Source # type UpdOpParams ('TMap k v) :: T Source # Methods evalUpd :: forall (instr :: [T] -> [T] -> Type). Value' instr (UpdOpKey ('TMap k v)) -> Value' instr (UpdOpParams ('TMap k v)) -> Value' instr ('TMap k v) -> Value' instr ('TMap k v) Source #

class SizeOp (c :: T) where Source #

Methods

evalSize :: Value' instr c -> Int Source #

Instances

Instances details

SizeOp 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSize :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TBytes -> Int Source #
SizeOp 'TString Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSize :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TString -> Int Source #
SizeOp ('TList a) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSize :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TList a) -> Int Source #
SizeOp ('TSet a) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSize :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TSet a) -> Int Source #
SizeOp ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Methods evalSize :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TMap k v) -> Int Source #

class IterOp (c :: T) where Source #

Associated Types

type IterOpEl c :: T Source #

Methods

iterOpDetachOne :: Value' instr c -> (Maybe (Value' instr (IterOpEl c)), Value' instr c) Source #

iterOpNotes :: Notes c -> Notes (IterOpEl c) Source #

Instances

Instances details

IterOp ('TList e) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type IterOpEl ('TList e) :: T Source # Methods iterOpDetachOne :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TList e) -> (Maybe (Value' instr (IterOpEl ('TList e))), Value' instr ('TList e)) Source # iterOpNotes :: Notes ('TList e) -> Notes (IterOpEl ('TList e)) Source #
IterOp ('TSet e) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type IterOpEl ('TSet e) :: T Source # Methods iterOpDetachOne :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TSet e) -> (Maybe (Value' instr (IterOpEl ('TSet e))), Value' instr ('TSet e)) Source # iterOpNotes :: Notes ('TSet e) -> Notes (IterOpEl ('TSet e)) Source #
IterOp ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type IterOpEl ('TMap k v) :: T Source # Methods iterOpDetachOne :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TMap k v) -> (Maybe (Value' instr (IterOpEl ('TMap k v))), Value' instr ('TMap k v)) Source # iterOpNotes :: Notes ('TMap k v) -> Notes (IterOpEl ('TMap k v)) Source #

class MapOp (c :: T) where Source #

Associated Types

type MapOpInp c :: T Source #

type MapOpRes c :: T -> T Source #

Methods

mapOpToList :: Value' instr c -> [Value' instr (MapOpInp c)] Source #

mapOpFromList :: SingI b => Value' instr c -> [Value' instr b] -> Value' instr (MapOpRes c b) Source #

mapOpNotes :: Notes c -> Notes (MapOpInp c) Source #

Instances

Instances details

MapOp ('TList e) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type MapOpInp ('TList e) :: T Source # type MapOpRes ('TList e) :: T -> T Source # Methods mapOpToList :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TList e) -> [Value' instr (MapOpInp ('TList e))] Source # mapOpFromList :: forall (b :: T) (instr :: [T] -> [T] -> Type). SingI b => Value' instr ('TList e) -> [Value' instr b] -> Value' instr (MapOpRes ('TList e) b) Source # mapOpNotes :: Notes ('TList e) -> Notes (MapOpInp ('TList e)) Source #
MapOp ('TOption e) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type MapOpInp ('TOption e) :: T Source # type MapOpRes ('TOption e) :: T -> T Source # Methods mapOpToList :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TOption e) -> [Value' instr (MapOpInp ('TOption e))] Source # mapOpFromList :: forall (b :: T) (instr :: [T] -> [T] -> Type). SingI b => Value' instr ('TOption e) -> [Value' instr b] -> Value' instr (MapOpRes ('TOption e) b) Source # mapOpNotes :: Notes ('TOption e) -> Notes (MapOpInp ('TOption e)) Source #
MapOp ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type MapOpInp ('TMap k v) :: T Source # type MapOpRes ('TMap k v) :: T -> T Source # Methods mapOpToList :: forall (instr :: [T] -> [T] -> Type). Value' instr ('TMap k v) -> [Value' instr (MapOpInp ('TMap k v))] Source # mapOpFromList :: forall (b :: T) (instr :: [T] -> [T] -> Type). SingI b => Value' instr ('TMap k v) -> [Value' instr b] -> Value' instr (MapOpRes ('TMap k v) b) Source # mapOpNotes :: Notes ('TMap k v) -> Notes (MapOpInp ('TMap k v)) Source #

class MemOp (c :: T) where Source #

Associated Types

type MemOpKey c :: T Source #

Methods

evalMem :: Value' instr (MemOpKey c) -> Value' instr c -> Bool Source #

Instances

Instances details

MemOp ('TSet e) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type MemOpKey ('TSet e) :: T Source # Methods evalMem :: forall (instr :: [T] -> [T] -> Type). Value' instr (MemOpKey ('TSet e)) -> Value' instr ('TSet e) -> Bool Source #
MemOp ('TBigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type MemOpKey ('TBigMap k v) :: T Source # Methods evalMem :: forall (instr :: [T] -> [T] -> Type). Value' instr (MemOpKey ('TBigMap k v)) -> Value' instr ('TBigMap k v) -> Bool Source #
MemOp ('TMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Polymorphic Associated Types type MemOpKey ('TMap k v) :: T Source # Methods evalMem :: forall (instr :: [T] -> [T] -> Type). Value' instr (MemOpKey ('TMap k v)) -> Value' instr ('TMap k v) -> Bool Source #

divMich :: Integral a => a -> a -> a Source #

Computing div function in Michelson style. When divisor is negative, Haskell gives x as integer part, while Michelson gives x+1.

modMich :: Integral a => a -> a -> a Source #

Computing mod function in Michelson style. When divisor is negative, Haskell gives a negative modulo, while there is a positive modulo in Michelson.

type Bls12381MulBadOrder a1 a2 = DelayError (((('Text "Multiplication of " :<>: 'ShowType a2) :<>: 'Text " and ") :<>: 'ShowType a1) :<>: 'Text " works only other way around") Source #

data Ge Source #

Instances

Instances details

UnaryArithOp Ge 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Ge 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Ge -> Value' instr 'TInt -> Value' instr (UnaryArithRes Ge 'TInt) Source #
type UnaryArithRes Ge 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Ge 'TInt = 'TBool

data Le Source #

Instances

Instances details

UnaryArithOp Le 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Le 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Le -> Value' instr 'TInt -> Value' instr (UnaryArithRes Le 'TInt) Source #
type UnaryArithRes Le 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Le 'TInt = 'TBool

data Gt Source #

Instances

Instances details

UnaryArithOp Gt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Gt 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Gt -> Value' instr 'TInt -> Value' instr (UnaryArithRes Gt 'TInt) Source #
type UnaryArithRes Gt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Gt 'TInt = 'TBool

data Lt Source #

Instances

Instances details

UnaryArithOp Lt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Lt 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lt -> Value' instr 'TInt -> Value' instr (UnaryArithRes Lt 'TInt) Source #
type UnaryArithRes Lt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Lt 'TInt = 'TBool

data Neq Source #

Instances

Instances details

UnaryArithOp Neq 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neq 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neq -> Value' instr 'TInt -> Value' instr (UnaryArithRes Neq 'TInt) Source #
type UnaryArithRes Neq 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Neq 'TInt = 'TBool

data Eq' Source #

Instances

Instances details

UnaryArithOp Eq' 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Eq' 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Eq' -> Value' instr 'TInt -> Value' instr (UnaryArithRes Eq' 'TInt) Source #
type UnaryArithRes Eq' 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Eq' 'TInt = 'TBool

data Compare Source #

data Lsr Source #

Instances

Instances details

ArithOp Lsr 'TBytes 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsr 'TBytes 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsr -> Value' instr 'TBytes -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TNat)) (Value' instr (ArithRes Lsr 'TBytes 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsr 'TBytes 'TNat ~ ArithRes Lsr 'TNat 'TBytes, ArithOp Lsr 'TNat 'TBytes) Source #
ArithOp Lsr 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsr 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsr -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Lsr 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsr 'TNat 'TNat ~ ArithRes Lsr 'TNat 'TNat, ArithOp Lsr 'TNat 'TNat) Source #
type ArithRes Lsr 'TBytes 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Lsr 'TBytes 'TNat = 'TBytes
type ArithRes Lsr 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Lsr 'TNat 'TNat = 'TNat

data Lsl Source #

Instances

Instances details

ArithOp Lsl 'TBytes 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsl 'TBytes 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsl -> Value' instr 'TBytes -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TNat)) (Value' instr (ArithRes Lsl 'TBytes 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsl 'TBytes 'TNat ~ ArithRes Lsl 'TNat 'TBytes, ArithOp Lsl 'TNat 'TBytes) Source #
ArithOp Lsl 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsl 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsl -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Lsl 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsl 'TNat 'TNat ~ ArithRes Lsl 'TNat 'TNat, ArithOp Lsl 'TNat 'TNat) Source #
type ArithRes Lsl 'TBytes 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Lsl 'TBytes 'TNat = 'TBytes
type ArithRes Lsl 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Lsl 'TNat 'TNat = 'TNat

data Not Source #

Instances

Instances details

UnaryArithOp Not 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TBool :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TBool -> Value' instr (UnaryArithRes Not 'TBool) Source #
UnaryArithOp Not 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TBytes :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TBytes -> Value' instr (UnaryArithRes Not 'TBytes) Source #
UnaryArithOp Not 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TInt -> Value' instr (UnaryArithRes Not 'TInt) Source #
UnaryArithOp Not 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TNat :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TNat -> Value' instr (UnaryArithRes Not 'TNat) Source #
type UnaryArithRes Not 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Not 'TBool = 'TBool
type UnaryArithRes Not 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Not 'TBytes = 'TBytes
type UnaryArithRes Not 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Not 'TInt = 'TInt
type UnaryArithRes Not 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Not 'TNat = 'TInt

data Xor Source #

Instances

Instances details

ArithOp Xor 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Xor 'TBool 'TBool :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Xor -> Value' instr 'TBool -> Value' instr 'TBool -> Either (ArithError (Value' instr 'TBool) (Value' instr 'TBool)) (Value' instr (ArithRes Xor 'TBool 'TBool)) Source # commutativityProof :: Maybe $ Dict (ArithRes Xor 'TBool 'TBool ~ ArithRes Xor 'TBool 'TBool, ArithOp Xor 'TBool 'TBool) Source #
ArithOp Xor 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Xor 'TBytes 'TBytes :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Xor -> Value' instr 'TBytes -> Value' instr 'TBytes -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TBytes)) (Value' instr (ArithRes Xor 'TBytes 'TBytes)) Source # commutativityProof :: Maybe $ Dict (ArithRes Xor 'TBytes 'TBytes ~ ArithRes Xor 'TBytes 'TBytes, ArithOp Xor 'TBytes 'TBytes) Source #
ArithOp Xor 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Xor 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Xor -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Xor 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Xor 'TNat 'TNat ~ ArithRes Xor 'TNat 'TNat, ArithOp Xor 'TNat 'TNat) Source #
type ArithRes Xor 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Xor 'TBool 'TBool = 'TBool
type ArithRes Xor 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Xor 'TBytes 'TBytes = 'TBytes
type ArithRes Xor 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Xor 'TNat 'TNat = 'TNat

data And Source #

Instances

Instances details

ArithOp And 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TBool 'TBool :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TBool -> Value' instr 'TBool -> Either (ArithError (Value' instr 'TBool) (Value' instr 'TBool)) (Value' instr (ArithRes And 'TBool 'TBool)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TBool 'TBool ~ ArithRes And 'TBool 'TBool, ArithOp And 'TBool 'TBool) Source #
ArithOp And 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TBytes 'TBytes :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TBytes -> Value' instr 'TBytes -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TBytes)) (Value' instr (ArithRes And 'TBytes 'TBytes)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TBytes 'TBytes ~ ArithRes And 'TBytes 'TBytes, ArithOp And 'TBytes 'TBytes) Source #
ArithOp And 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes And 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TInt 'TNat ~ ArithRes And 'TNat 'TInt, ArithOp And 'TNat 'TInt) Source #
ArithOp And 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes And 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TNat 'TNat ~ ArithRes And 'TNat 'TNat, ArithOp And 'TNat 'TNat) Source #
type ArithRes And 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes And 'TBool 'TBool = 'TBool
type ArithRes And 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes And 'TBytes 'TBytes = 'TBytes
type ArithRes And 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes And 'TInt 'TNat = 'TNat
type ArithRes And 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes And 'TNat 'TNat = 'TNat

data Or Source #

Instances

Instances details

ArithOp Or 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Or 'TBool 'TBool :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Or -> Value' instr 'TBool -> Value' instr 'TBool -> Either (ArithError (Value' instr 'TBool) (Value' instr 'TBool)) (Value' instr (ArithRes Or 'TBool 'TBool)) Source # commutativityProof :: Maybe $ Dict (ArithRes Or 'TBool 'TBool ~ ArithRes Or 'TBool 'TBool, ArithOp Or 'TBool 'TBool) Source #
ArithOp Or 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Or 'TBytes 'TBytes :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Or -> Value' instr 'TBytes -> Value' instr 'TBytes -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TBytes)) (Value' instr (ArithRes Or 'TBytes 'TBytes)) Source # commutativityProof :: Maybe $ Dict (ArithRes Or 'TBytes 'TBytes ~ ArithRes Or 'TBytes 'TBytes, ArithOp Or 'TBytes 'TBytes) Source #
ArithOp Or 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Or 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Or -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Or 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Or 'TNat 'TNat ~ ArithRes Or 'TNat 'TNat, ArithOp Or 'TNat 'TNat) Source #
type ArithRes Or 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Or 'TBool 'TBool = 'TBool
type ArithRes Or 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Or 'TBytes 'TBytes = 'TBytes
type ArithRes Or 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Or 'TNat 'TNat = 'TNat

data Neg Source #

Instances

Instances details

UnaryArithOp Neg 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TBls12381Fr :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TBls12381Fr -> Value' instr (UnaryArithRes Neg 'TBls12381Fr) Source #
UnaryArithOp Neg 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TBls12381G1 :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TBls12381G1 -> Value' instr (UnaryArithRes Neg 'TBls12381G1) Source #
UnaryArithOp Neg 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TBls12381G2 :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TBls12381G2 -> Value' instr (UnaryArithRes Neg 'TBls12381G2) Source #
UnaryArithOp Neg 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TInt -> Value' instr (UnaryArithRes Neg 'TInt) Source #
UnaryArithOp Neg 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TNat :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TNat -> Value' instr (UnaryArithRes Neg 'TNat) Source #
type UnaryArithRes Neg 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Neg 'TBls12381Fr = 'TBls12381Fr
type UnaryArithRes Neg 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Neg 'TBls12381G1 = 'TBls12381G1
type UnaryArithRes Neg 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Neg 'TBls12381G2 = 'TBls12381G2
type UnaryArithRes Neg 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Neg 'TInt = 'TInt
type UnaryArithRes Neg 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Neg 'TNat = 'TInt

data Abs Source #

Instances

Instances details

UnaryArithOp Abs 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Abs 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Abs -> Value' instr 'TInt -> Value' instr (UnaryArithRes Abs 'TInt) Source #
type UnaryArithRes Abs 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type UnaryArithRes Abs 'TInt = 'TNat

data EDiv Source #

Instances

Instances details

ArithOp EDiv 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes EDiv 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TInt 'TInt ~ ArithRes EDiv 'TInt 'TInt, ArithOp EDiv 'TInt 'TInt) Source #
ArithOp EDiv 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes EDiv 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TInt 'TNat ~ ArithRes EDiv 'TNat 'TInt, ArithOp EDiv 'TNat 'TInt) Source #
ArithOp EDiv 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TMutez 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TMutez -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TMutez)) (Value' instr (ArithRes EDiv 'TMutez 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TMutez 'TMutez ~ ArithRes EDiv 'TMutez 'TMutez, ArithOp EDiv 'TMutez 'TMutez) Source #
ArithOp EDiv 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TMutez 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TMutez -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TNat)) (Value' instr (ArithRes EDiv 'TMutez 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TMutez 'TNat ~ ArithRes EDiv 'TNat 'TMutez, ArithOp EDiv 'TNat 'TMutez) Source #
ArithOp EDiv 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes EDiv 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TNat 'TInt ~ ArithRes EDiv 'TInt 'TNat, ArithOp EDiv 'TInt 'TNat) Source #
ArithOp EDiv 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes EDiv 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TNat 'TNat ~ ArithRes EDiv 'TNat 'TNat, ArithOp EDiv 'TNat 'TNat) Source #
type ArithRes EDiv 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes EDiv 'TInt 'TInt = 'TOption ('TPair (EDivOpRes 'TInt 'TInt) (EModOpRes 'TInt 'TInt))
type ArithRes EDiv 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes EDiv 'TInt 'TNat = 'TOption ('TPair (EDivOpRes 'TInt 'TNat) (EModOpRes 'TInt 'TNat))
type ArithRes EDiv 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes EDiv 'TMutez 'TMutez = 'TOption ('TPair (EDivOpRes 'TMutez 'TMutez) (EModOpRes 'TMutez 'TMutez))
type ArithRes EDiv 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes EDiv 'TMutez 'TNat = 'TOption ('TPair (EDivOpRes 'TMutez 'TNat) (EModOpRes 'TMutez 'TNat))
type ArithRes EDiv 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes EDiv 'TNat 'TInt = 'TOption ('TPair (EDivOpRes 'TNat 'TInt) (EModOpRes 'TNat 'TInt))
type ArithRes EDiv 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes EDiv 'TNat 'TNat = 'TOption ('TPair (EDivOpRes 'TNat 'TNat) (EModOpRes 'TNat 'TNat))

data Mul Source #

Instances

Instances details

ArithOp Mul 'TBls12381Fr 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TBls12381Fr, ArithOp Mul 'TBls12381Fr 'TBls12381Fr) Source #
(Bottom, Bls12381MulBadOrder Bls12381Fr Bls12381G1 :: Constraint) => ArithOp Mul 'TBls12381Fr 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TBls12381G1 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381G1 -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381G1)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TBls12381G1)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TBls12381G1 ~ ArithRes Mul 'TBls12381G1 'TBls12381Fr, ArithOp Mul 'TBls12381G1 'TBls12381Fr) Source #
(Bottom, Bls12381MulBadOrder Bls12381Fr Bls12381G2 :: Constraint) => ArithOp Mul 'TBls12381Fr 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TBls12381G2 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381G2 -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381G2)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TBls12381G2)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TBls12381G2 ~ ArithRes Mul 'TBls12381G2 'TBls12381Fr, ArithOp Mul 'TBls12381G2 'TBls12381Fr) Source #
ArithOp Mul 'TBls12381Fr 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TInt)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TInt ~ ArithRes Mul 'TInt 'TBls12381Fr, ArithOp Mul 'TInt 'TBls12381Fr) Source #
ArithOp Mul 'TBls12381Fr 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TNat ~ ArithRes Mul 'TNat 'TBls12381Fr, ArithOp Mul 'TNat 'TBls12381Fr) Source #
ArithOp Mul 'TBls12381G1 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381G1 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381G1 -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381G1) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TBls12381G1 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381G1 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TBls12381G1, ArithOp Mul 'TBls12381Fr 'TBls12381G1) Source #
ArithOp Mul 'TBls12381G2 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381G2 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381G2 -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381G2) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TBls12381G2 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381G2 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TBls12381G2, ArithOp Mul 'TBls12381Fr 'TBls12381G2) Source #
ArithOp Mul 'TInt 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TInt 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TInt -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TInt 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TInt 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TInt, ArithOp Mul 'TBls12381Fr 'TInt) Source #
ArithOp Mul 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes Mul 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TInt 'TInt ~ ArithRes Mul 'TInt 'TInt, ArithOp Mul 'TInt 'TInt) Source #
ArithOp Mul 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TInt 'TNat ~ ArithRes Mul 'TNat 'TInt, ArithOp Mul 'TNat 'TInt) Source #
ArithOp Mul 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TMutez 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TMutez -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TMutez 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TMutez 'TNat ~ ArithRes Mul 'TNat 'TMutez, ArithOp Mul 'TNat 'TMutez) Source #
ArithOp Mul 'TNat 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TNat 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TNat, ArithOp Mul 'TBls12381Fr 'TNat) Source #
ArithOp Mul 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes Mul 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TInt ~ ArithRes Mul 'TInt 'TNat, ArithOp Mul 'TInt 'TNat) Source #
ArithOp Mul 'TNat 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TMutez)) (Value' instr (ArithRes Mul 'TNat 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TMutez ~ ArithRes Mul 'TMutez 'TNat, ArithOp Mul 'TMutez 'TNat) Source #
ArithOp Mul 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TNat ~ ArithRes Mul 'TNat 'TNat, ArithOp Mul 'TNat 'TNat) Source #
type ArithRes Mul 'TBls12381Fr 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381Fr 'TBls12381Fr = 'TBls12381Fr
type ArithRes Mul 'TBls12381Fr 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381Fr 'TBls12381G1 = 'TBls12381G1
type ArithRes Mul 'TBls12381Fr 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381Fr 'TBls12381G2 = 'TBls12381G2
type ArithRes Mul 'TBls12381Fr 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381Fr 'TInt = 'TBls12381Fr
type ArithRes Mul 'TBls12381Fr 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381Fr 'TNat = 'TBls12381Fr
type ArithRes Mul 'TBls12381G1 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381G1 'TBls12381Fr = 'TBls12381G1
type ArithRes Mul 'TBls12381G2 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TBls12381G2 'TBls12381Fr = 'TBls12381G2
type ArithRes Mul 'TInt 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TInt 'TBls12381Fr = 'TBls12381Fr
type ArithRes Mul 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TInt 'TInt = 'TInt
type ArithRes Mul 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TInt 'TNat = 'TInt
type ArithRes Mul 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TMutez 'TNat = 'TMutez
type ArithRes Mul 'TNat 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TNat 'TBls12381Fr = 'TBls12381Fr
type ArithRes Mul 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TNat 'TInt = 'TInt
type ArithRes Mul 'TNat 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TNat 'TMutez = 'TMutez
type ArithRes Mul 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Mul 'TNat 'TNat = 'TNat

data SubMutez Source #

Instances

Instances details

ArithOp SubMutez 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes SubMutez 'TMutez 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy SubMutez -> Value' instr 'TMutez -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TMutez)) (Value' instr (ArithRes SubMutez 'TMutez 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes SubMutez 'TMutez 'TMutez ~ ArithRes SubMutez 'TMutez 'TMutez, ArithOp SubMutez 'TMutez 'TMutez) Source #
type ArithRes SubMutez 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes SubMutez 'TMutez 'TMutez = 'TOption 'TMutez

data Sub Source #

Instances

Instances details

ArithOp Sub 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes Sub 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TInt 'TInt ~ ArithRes Sub 'TInt 'TInt, ArithOp Sub 'TInt 'TInt) Source #
ArithOp Sub 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes Sub 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TInt 'TNat ~ ArithRes Sub 'TNat 'TInt, ArithOp Sub 'TNat 'TInt) Source #
ArithOp Sub 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes Sub 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TNat 'TInt ~ ArithRes Sub 'TInt 'TNat, ArithOp Sub 'TInt 'TNat) Source #
ArithOp Sub 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Sub 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TNat 'TNat ~ ArithRes Sub 'TNat 'TNat, ArithOp Sub 'TNat 'TNat) Source #
ArithOp Sub 'TTimestamp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TTimestamp 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TTimestamp -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TTimestamp) (Value' instr 'TInt)) (Value' instr (ArithRes Sub 'TTimestamp 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TTimestamp 'TInt ~ ArithRes Sub 'TInt 'TTimestamp, ArithOp Sub 'TInt 'TTimestamp) Source #
ArithOp Sub 'TTimestamp 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TTimestamp 'TTimestamp :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TTimestamp -> Value' instr 'TTimestamp -> Either (ArithError (Value' instr 'TTimestamp) (Value' instr 'TTimestamp)) (Value' instr (ArithRes Sub 'TTimestamp 'TTimestamp)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TTimestamp 'TTimestamp ~ ArithRes Sub 'TTimestamp 'TTimestamp, ArithOp Sub 'TTimestamp 'TTimestamp) Source #
type ArithRes Sub 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Sub 'TInt 'TInt = 'TInt
type ArithRes Sub 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Sub 'TInt 'TNat = 'TInt
type ArithRes Sub 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Sub 'TNat 'TInt = 'TInt
type ArithRes Sub 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Sub 'TNat 'TNat = 'TInt
type ArithRes Sub 'TTimestamp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Sub 'TTimestamp 'TInt = 'TTimestamp
type ArithRes Sub 'TTimestamp 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Sub 'TTimestamp 'TTimestamp = 'TInt

data Add Source #

Instances

Instances details

ArithOp Add 'TBls12381Fr 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TBls12381Fr 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Add 'TBls12381Fr 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TBls12381Fr 'TBls12381Fr ~ ArithRes Add 'TBls12381Fr 'TBls12381Fr, ArithOp Add 'TBls12381Fr 'TBls12381Fr) Source #
ArithOp Add 'TBls12381G1 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TBls12381G1 'TBls12381G1 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TBls12381G1 -> Value' instr 'TBls12381G1 -> Either (ArithError (Value' instr 'TBls12381G1) (Value' instr 'TBls12381G1)) (Value' instr (ArithRes Add 'TBls12381G1 'TBls12381G1)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TBls12381G1 'TBls12381G1 ~ ArithRes Add 'TBls12381G1 'TBls12381G1, ArithOp Add 'TBls12381G1 'TBls12381G1) Source #
ArithOp Add 'TBls12381G2 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TBls12381G2 'TBls12381G2 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TBls12381G2 -> Value' instr 'TBls12381G2 -> Either (ArithError (Value' instr 'TBls12381G2) (Value' instr 'TBls12381G2)) (Value' instr (ArithRes Add 'TBls12381G2 'TBls12381G2)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TBls12381G2 'TBls12381G2 ~ ArithRes Add 'TBls12381G2 'TBls12381G2, ArithOp Add 'TBls12381G2 'TBls12381G2) Source #
ArithOp Add 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes Add 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TInt 'TInt ~ ArithRes Add 'TInt 'TInt, ArithOp Add 'TInt 'TInt) Source #
ArithOp Add 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes Add 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TInt 'TNat ~ ArithRes Add 'TNat 'TInt, ArithOp Add 'TNat 'TInt) Source #
ArithOp Add 'TInt 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TInt 'TTimestamp :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TInt -> Value' instr 'TTimestamp -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TTimestamp)) (Value' instr (ArithRes Add 'TInt 'TTimestamp)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TInt 'TTimestamp ~ ArithRes Add 'TTimestamp 'TInt, ArithOp Add 'TTimestamp 'TInt) Source #
ArithOp Add 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TMutez 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TMutez -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TMutez)) (Value' instr (ArithRes Add 'TMutez 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TMutez 'TMutez ~ ArithRes Add 'TMutez 'TMutez, ArithOp Add 'TMutez 'TMutez) Source #
ArithOp Add 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes Add 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TNat 'TInt ~ ArithRes Add 'TInt 'TNat, ArithOp Add 'TInt 'TNat) Source #
ArithOp Add 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Add 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TNat 'TNat ~ ArithRes Add 'TNat 'TNat, ArithOp Add 'TNat 'TNat) Source #
ArithOp Add 'TTimestamp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TTimestamp 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TTimestamp -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TTimestamp) (Value' instr 'TInt)) (Value' instr (ArithRes Add 'TTimestamp 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TTimestamp 'TInt ~ ArithRes Add 'TInt 'TTimestamp, ArithOp Add 'TInt 'TTimestamp) Source #
type ArithRes Add 'TBls12381Fr 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TBls12381Fr 'TBls12381Fr = 'TBls12381Fr
type ArithRes Add 'TBls12381G1 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TBls12381G1 'TBls12381G1 = 'TBls12381G1
type ArithRes Add 'TBls12381G2 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TBls12381G2 'TBls12381G2 = 'TBls12381G2
type ArithRes Add 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TInt 'TInt = 'TInt
type ArithRes Add 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TInt 'TNat = 'TInt
type ArithRes Add 'TInt 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TInt 'TTimestamp = 'TTimestamp
type ArithRes Add 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TMutez 'TMutez = 'TMutez
type ArithRes Add 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TNat 'TInt = 'TInt
type ArithRes Add 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TNat 'TNat = 'TNat
type ArithRes Add 'TTimestamp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith type ArithRes Add 'TTimestamp 'TInt = 'TTimestamp

class ToBytesArithOp (n :: T) where Source #

Class for conversions to bytes.

Methods

evalToBytesOp :: Value' instr n -> Value' instr 'TBytes Source #

Instances

Instances details

ToBytesArithOp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods evalToBytesOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TInt -> Value' instr 'TBytes Source #
ToBytesArithOp 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods evalToBytesOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TNat -> Value' instr 'TBytes Source #

class ToIntArithOp (n :: T) where Source #

Class for conversions to an integer value.

Methods

evalToIntOp :: Value' instr n -> Value' instr 'TInt Source #

Instances

Instances details

ToIntArithOp 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods evalToIntOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TBls12381Fr -> Value' instr 'TInt Source #
ToIntArithOp 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods evalToIntOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TBytes -> Value' instr 'TInt Source #
ToIntArithOp 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods evalToIntOp :: forall (instr :: [T] -> [T] -> Type). Value' instr 'TNat -> Value' instr 'TInt Source #

class UnaryArithOp aop (n :: T) where Source #

Class for unary arithmetic operation.

Associated Types

type UnaryArithRes aop n :: T Source #

Methods

evalUnaryArithOp :: proxy aop -> Value' instr n -> Value' instr (UnaryArithRes aop n) Source #

Instances

Instances details

UnaryArithOp Abs 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Abs 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Abs -> Value' instr 'TInt -> Value' instr (UnaryArithRes Abs 'TInt) Source #
UnaryArithOp Eq' 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Eq' 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Eq' -> Value' instr 'TInt -> Value' instr (UnaryArithRes Eq' 'TInt) Source #
UnaryArithOp Ge 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Ge 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Ge -> Value' instr 'TInt -> Value' instr (UnaryArithRes Ge 'TInt) Source #
UnaryArithOp Gt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Gt 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Gt -> Value' instr 'TInt -> Value' instr (UnaryArithRes Gt 'TInt) Source #
UnaryArithOp Le 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Le 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Le -> Value' instr 'TInt -> Value' instr (UnaryArithRes Le 'TInt) Source #
UnaryArithOp Lt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Lt 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lt -> Value' instr 'TInt -> Value' instr (UnaryArithRes Lt 'TInt) Source #
UnaryArithOp Neg 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TBls12381Fr :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TBls12381Fr -> Value' instr (UnaryArithRes Neg 'TBls12381Fr) Source #
UnaryArithOp Neg 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TBls12381G1 :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TBls12381G1 -> Value' instr (UnaryArithRes Neg 'TBls12381G1) Source #
UnaryArithOp Neg 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TBls12381G2 :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TBls12381G2 -> Value' instr (UnaryArithRes Neg 'TBls12381G2) Source #
UnaryArithOp Neg 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TInt -> Value' instr (UnaryArithRes Neg 'TInt) Source #
UnaryArithOp Neg 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neg 'TNat :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neg -> Value' instr 'TNat -> Value' instr (UnaryArithRes Neg 'TNat) Source #
UnaryArithOp Neq 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Neq 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Neq -> Value' instr 'TInt -> Value' instr (UnaryArithRes Neq 'TInt) Source #
UnaryArithOp Not 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TBool :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TBool -> Value' instr (UnaryArithRes Not 'TBool) Source #
UnaryArithOp Not 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TBytes :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TBytes -> Value' instr (UnaryArithRes Not 'TBytes) Source #
UnaryArithOp Not 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TInt :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TInt -> Value' instr (UnaryArithRes Not 'TInt) Source #
UnaryArithOp Not 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type UnaryArithRes Not 'TNat :: T Source # Methods evalUnaryArithOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Not -> Value' instr 'TNat -> Value' instr (UnaryArithRes Not 'TNat) Source #

data ArithError n m Source #

Represents an arithmetic error of the operation.

Constructors

MutezArithError MutezArithErrorType n m
ShiftArithError ShiftArithErrorType n m

Instances

Instances details

Generic (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type Rep (ArithError n m) :: Type -> Type # Methods from :: ArithError n m -> Rep (ArithError n m) x # to :: Rep (ArithError n m) x -> ArithError n m #
(Show n, Show m) => Show (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods showsPrec :: Int -> ArithError n m -> ShowS # show :: ArithError n m -> String # showList :: [ArithError n m] -> ShowS #
(NFData n, NFData m) => NFData (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods rnf :: ArithError n m -> () #
(Buildable n, Buildable m) => Buildable (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods build :: ArithError n m -> Builder #
(Eq n, Eq m) => Eq (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods (==) :: ArithError n m -> ArithError n m -> Bool # (/=) :: ArithError n m -> ArithError n m -> Bool #
(Ord n, Ord m) => Ord (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods compare :: ArithError n m -> ArithError n m -> Ordering # (<) :: ArithError n m -> ArithError n m -> Bool # (<=) :: ArithError n m -> ArithError n m -> Bool # (>) :: ArithError n m -> ArithError n m -> Bool # (>=) :: ArithError n m -> ArithError n m -> Bool # max :: ArithError n m -> ArithError n m -> ArithError n m # min :: ArithError n m -> ArithError n m -> ArithError n m #
type Rep (ArithError n m) Source #
Instance details Defined in Morley.Michelson.Typed.Arith type Rep (ArithError n m) = D1 ('MetaData "ArithError" "Morley.Michelson.Typed.Arith" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "MutezArithError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 MutezArithErrorType) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 n) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 m))) :+: C1 ('MetaCons "ShiftArithError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ShiftArithErrorType) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 n) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 m))))

data MutezArithErrorType Source #

Denotes the error type occurred in the arithmetic operation involving mutez.

Constructors

AddOverflow
MulOverflow

Instances

Instances details

Generic MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type Rep MutezArithErrorType :: Type -> Type # Methods from :: MutezArithErrorType -> Rep MutezArithErrorType x # to :: Rep MutezArithErrorType x -> MutezArithErrorType #
Show MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods showsPrec :: Int -> MutezArithErrorType -> ShowS # show :: MutezArithErrorType -> String # showList :: [MutezArithErrorType] -> ShowS #
NFData MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods rnf :: MutezArithErrorType -> () #
Buildable MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods build :: MutezArithErrorType -> Builder #
Eq MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods (==) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (/=) :: MutezArithErrorType -> MutezArithErrorType -> Bool #
Ord MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods compare :: MutezArithErrorType -> MutezArithErrorType -> Ordering # (<) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (<=) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (>) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (>=) :: MutezArithErrorType -> MutezArithErrorType -> Bool # max :: MutezArithErrorType -> MutezArithErrorType -> MutezArithErrorType # min :: MutezArithErrorType -> MutezArithErrorType -> MutezArithErrorType #
type Rep MutezArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith type Rep MutezArithErrorType = D1 ('MetaData "MutezArithErrorType" "Morley.Michelson.Typed.Arith" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "AddOverflow" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MulOverflow" 'PrefixI 'False) (U1 :: Type -> Type))

data ShiftArithErrorType Source #

Denotes the error type occurred in the arithmetic shift operation.

Constructors

LslOverflow
LsrUnderflow

Instances

Instances details

Generic ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type Rep ShiftArithErrorType :: Type -> Type # Methods from :: ShiftArithErrorType -> Rep ShiftArithErrorType x # to :: Rep ShiftArithErrorType x -> ShiftArithErrorType #
Show ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods showsPrec :: Int -> ShiftArithErrorType -> ShowS # show :: ShiftArithErrorType -> String # showList :: [ShiftArithErrorType] -> ShowS #
NFData ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods rnf :: ShiftArithErrorType -> () #
Buildable ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods build :: ShiftArithErrorType -> Builder #
Eq ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods (==) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (/=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool #
Ord ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith Methods compare :: ShiftArithErrorType -> ShiftArithErrorType -> Ordering # (<) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (<=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (>) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (>=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # max :: ShiftArithErrorType -> ShiftArithErrorType -> ShiftArithErrorType # min :: ShiftArithErrorType -> ShiftArithErrorType -> ShiftArithErrorType #
type Rep ShiftArithErrorType Source #
Instance details Defined in Morley.Michelson.Typed.Arith type Rep ShiftArithErrorType = D1 ('MetaData "ShiftArithErrorType" "Morley.Michelson.Typed.Arith" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "LslOverflow" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LsrUnderflow" 'PrefixI 'False) (U1 :: Type -> Type))

class (Typeable n, Typeable m) => ArithOp aop (n :: T) (m :: T) where Source #

Class for binary arithmetic operation.

Takes binary operation marker as op parameter, types of left operand n and right operand m.

Typeable constraints in superclass are necessary for error messages.

Minimal complete definition

evalOp

Associated Types

type ArithRes aop n m :: T Source #

Type family ArithRes denotes the type resulting from computing operation op from operands of types n and m.

For instance, adding integer to natural produces integer, which is reflected in following instance of type family: ArithRes Add CNat CInt = CInt.

Methods

evalOp :: proxy aop -> Value' instr n -> Value' instr m -> Either (ArithError (Value' instr n) (Value' instr m)) (Value' instr (ArithRes aop n m)) Source #

Evaluate arithmetic operation on given operands.

commutativityProof :: Maybe $ Dict (ArithRes aop n m ~ ArithRes aop m n, ArithOp aop m n) Source #

An operation can marked as commutative, it does not affect its runtime behavior, but enables certain optimization in the optimizer. We conservatively consider operations non-commutative by default.

Note that there is one unusual case: AND works with int : nat but not with nat : int. That's how it's specified in Michelson.

Instances

Instances details

ArithOp Add 'TBls12381Fr 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TBls12381Fr 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Add 'TBls12381Fr 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TBls12381Fr 'TBls12381Fr ~ ArithRes Add 'TBls12381Fr 'TBls12381Fr, ArithOp Add 'TBls12381Fr 'TBls12381Fr) Source #
ArithOp Add 'TBls12381G1 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TBls12381G1 'TBls12381G1 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TBls12381G1 -> Value' instr 'TBls12381G1 -> Either (ArithError (Value' instr 'TBls12381G1) (Value' instr 'TBls12381G1)) (Value' instr (ArithRes Add 'TBls12381G1 'TBls12381G1)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TBls12381G1 'TBls12381G1 ~ ArithRes Add 'TBls12381G1 'TBls12381G1, ArithOp Add 'TBls12381G1 'TBls12381G1) Source #
ArithOp Add 'TBls12381G2 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TBls12381G2 'TBls12381G2 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TBls12381G2 -> Value' instr 'TBls12381G2 -> Either (ArithError (Value' instr 'TBls12381G2) (Value' instr 'TBls12381G2)) (Value' instr (ArithRes Add 'TBls12381G2 'TBls12381G2)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TBls12381G2 'TBls12381G2 ~ ArithRes Add 'TBls12381G2 'TBls12381G2, ArithOp Add 'TBls12381G2 'TBls12381G2) Source #
ArithOp Add 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes Add 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TInt 'TInt ~ ArithRes Add 'TInt 'TInt, ArithOp Add 'TInt 'TInt) Source #
ArithOp Add 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes Add 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TInt 'TNat ~ ArithRes Add 'TNat 'TInt, ArithOp Add 'TNat 'TInt) Source #
ArithOp Add 'TInt 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TInt 'TTimestamp :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TInt -> Value' instr 'TTimestamp -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TTimestamp)) (Value' instr (ArithRes Add 'TInt 'TTimestamp)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TInt 'TTimestamp ~ ArithRes Add 'TTimestamp 'TInt, ArithOp Add 'TTimestamp 'TInt) Source #
ArithOp Add 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TMutez 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TMutez -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TMutez)) (Value' instr (ArithRes Add 'TMutez 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TMutez 'TMutez ~ ArithRes Add 'TMutez 'TMutez, ArithOp Add 'TMutez 'TMutez) Source #
ArithOp Add 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes Add 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TNat 'TInt ~ ArithRes Add 'TInt 'TNat, ArithOp Add 'TInt 'TNat) Source #
ArithOp Add 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Add 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TNat 'TNat ~ ArithRes Add 'TNat 'TNat, ArithOp Add 'TNat 'TNat) Source #
ArithOp Add 'TTimestamp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Add 'TTimestamp 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Add -> Value' instr 'TTimestamp -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TTimestamp) (Value' instr 'TInt)) (Value' instr (ArithRes Add 'TTimestamp 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Add 'TTimestamp 'TInt ~ ArithRes Add 'TInt 'TTimestamp, ArithOp Add 'TInt 'TTimestamp) Source #
ArithOp And 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TBool 'TBool :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TBool -> Value' instr 'TBool -> Either (ArithError (Value' instr 'TBool) (Value' instr 'TBool)) (Value' instr (ArithRes And 'TBool 'TBool)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TBool 'TBool ~ ArithRes And 'TBool 'TBool, ArithOp And 'TBool 'TBool) Source #
ArithOp And 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TBytes 'TBytes :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TBytes -> Value' instr 'TBytes -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TBytes)) (Value' instr (ArithRes And 'TBytes 'TBytes)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TBytes 'TBytes ~ ArithRes And 'TBytes 'TBytes, ArithOp And 'TBytes 'TBytes) Source #
ArithOp And 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes And 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TInt 'TNat ~ ArithRes And 'TNat 'TInt, ArithOp And 'TNat 'TInt) Source #
ArithOp And 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes And 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy And -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes And 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes And 'TNat 'TNat ~ ArithRes And 'TNat 'TNat, ArithOp And 'TNat 'TNat) Source #
ArithOp EDiv 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes EDiv 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TInt 'TInt ~ ArithRes EDiv 'TInt 'TInt, ArithOp EDiv 'TInt 'TInt) Source #
ArithOp EDiv 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes EDiv 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TInt 'TNat ~ ArithRes EDiv 'TNat 'TInt, ArithOp EDiv 'TNat 'TInt) Source #
ArithOp EDiv 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TMutez 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TMutez -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TMutez)) (Value' instr (ArithRes EDiv 'TMutez 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TMutez 'TMutez ~ ArithRes EDiv 'TMutez 'TMutez, ArithOp EDiv 'TMutez 'TMutez) Source #
ArithOp EDiv 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TMutez 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TMutez -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TNat)) (Value' instr (ArithRes EDiv 'TMutez 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TMutez 'TNat ~ ArithRes EDiv 'TNat 'TMutez, ArithOp EDiv 'TNat 'TMutez) Source #
ArithOp EDiv 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes EDiv 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TNat 'TInt ~ ArithRes EDiv 'TInt 'TNat, ArithOp EDiv 'TInt 'TNat) Source #
ArithOp EDiv 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes EDiv 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy EDiv -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes EDiv 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes EDiv 'TNat 'TNat ~ ArithRes EDiv 'TNat 'TNat, ArithOp EDiv 'TNat 'TNat) Source #
ArithOp Lsl 'TBytes 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsl 'TBytes 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsl -> Value' instr 'TBytes -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TNat)) (Value' instr (ArithRes Lsl 'TBytes 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsl 'TBytes 'TNat ~ ArithRes Lsl 'TNat 'TBytes, ArithOp Lsl 'TNat 'TBytes) Source #
ArithOp Lsl 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsl 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsl -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Lsl 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsl 'TNat 'TNat ~ ArithRes Lsl 'TNat 'TNat, ArithOp Lsl 'TNat 'TNat) Source #
ArithOp Lsr 'TBytes 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsr 'TBytes 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsr -> Value' instr 'TBytes -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TNat)) (Value' instr (ArithRes Lsr 'TBytes 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsr 'TBytes 'TNat ~ ArithRes Lsr 'TNat 'TBytes, ArithOp Lsr 'TNat 'TBytes) Source #
ArithOp Lsr 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Lsr 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Lsr -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Lsr 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Lsr 'TNat 'TNat ~ ArithRes Lsr 'TNat 'TNat, ArithOp Lsr 'TNat 'TNat) Source #
ArithOp Mul 'TBls12381Fr 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TBls12381Fr, ArithOp Mul 'TBls12381Fr 'TBls12381Fr) Source #
(Bottom, Bls12381MulBadOrder Bls12381Fr Bls12381G1 :: Constraint) => ArithOp Mul 'TBls12381Fr 'TBls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TBls12381G1 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381G1 -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381G1)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TBls12381G1)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TBls12381G1 ~ ArithRes Mul 'TBls12381G1 'TBls12381Fr, ArithOp Mul 'TBls12381G1 'TBls12381Fr) Source #
(Bottom, Bls12381MulBadOrder Bls12381Fr Bls12381G2 :: Constraint) => ArithOp Mul 'TBls12381Fr 'TBls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TBls12381G2 :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TBls12381G2 -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TBls12381G2)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TBls12381G2)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TBls12381G2 ~ ArithRes Mul 'TBls12381G2 'TBls12381Fr, ArithOp Mul 'TBls12381G2 'TBls12381Fr) Source #
ArithOp Mul 'TBls12381Fr 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TInt)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TInt ~ ArithRes Mul 'TInt 'TBls12381Fr, ArithOp Mul 'TInt 'TBls12381Fr) Source #
ArithOp Mul 'TBls12381Fr 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381Fr 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381Fr -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TBls12381Fr) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TBls12381Fr 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381Fr 'TNat ~ ArithRes Mul 'TNat 'TBls12381Fr, ArithOp Mul 'TNat 'TBls12381Fr) Source #
ArithOp Mul 'TBls12381G1 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381G1 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381G1 -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381G1) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TBls12381G1 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381G1 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TBls12381G1, ArithOp Mul 'TBls12381Fr 'TBls12381G1) Source #
ArithOp Mul 'TBls12381G2 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TBls12381G2 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TBls12381G2 -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TBls12381G2) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TBls12381G2 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TBls12381G2 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TBls12381G2, ArithOp Mul 'TBls12381Fr 'TBls12381G2) Source #
ArithOp Mul 'TInt 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TInt 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TInt -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TInt 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TInt 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TInt, ArithOp Mul 'TBls12381Fr 'TInt) Source #
ArithOp Mul 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes Mul 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TInt 'TInt ~ ArithRes Mul 'TInt 'TInt, ArithOp Mul 'TInt 'TInt) Source #
ArithOp Mul 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TInt 'TNat ~ ArithRes Mul 'TNat 'TInt, ArithOp Mul 'TNat 'TInt) Source #
ArithOp Mul 'TMutez 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TMutez 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TMutez -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TMutez 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TMutez 'TNat ~ ArithRes Mul 'TNat 'TMutez, ArithOp Mul 'TNat 'TMutez) Source #
ArithOp Mul 'TNat 'TBls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TBls12381Fr :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TBls12381Fr -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TBls12381Fr)) (Value' instr (ArithRes Mul 'TNat 'TBls12381Fr)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TBls12381Fr ~ ArithRes Mul 'TBls12381Fr 'TNat, ArithOp Mul 'TBls12381Fr 'TNat) Source #
ArithOp Mul 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes Mul 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TInt ~ ArithRes Mul 'TInt 'TNat, ArithOp Mul 'TInt 'TNat) Source #
ArithOp Mul 'TNat 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TMutez)) (Value' instr (ArithRes Mul 'TNat 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TMutez ~ ArithRes Mul 'TMutez 'TNat, ArithOp Mul 'TMutez 'TNat) Source #
ArithOp Mul 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Mul 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Mul -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Mul 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Mul 'TNat 'TNat ~ ArithRes Mul 'TNat 'TNat, ArithOp Mul 'TNat 'TNat) Source #
ArithOp Or 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Or 'TBool 'TBool :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Or -> Value' instr 'TBool -> Value' instr 'TBool -> Either (ArithError (Value' instr 'TBool) (Value' instr 'TBool)) (Value' instr (ArithRes Or 'TBool 'TBool)) Source # commutativityProof :: Maybe $ Dict (ArithRes Or 'TBool 'TBool ~ ArithRes Or 'TBool 'TBool, ArithOp Or 'TBool 'TBool) Source #
ArithOp Or 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Or 'TBytes 'TBytes :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Or -> Value' instr 'TBytes -> Value' instr 'TBytes -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TBytes)) (Value' instr (ArithRes Or 'TBytes 'TBytes)) Source # commutativityProof :: Maybe $ Dict (ArithRes Or 'TBytes 'TBytes ~ ArithRes Or 'TBytes 'TBytes, ArithOp Or 'TBytes 'TBytes) Source #
ArithOp Or 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Or 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Or -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Or 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Or 'TNat 'TNat ~ ArithRes Or 'TNat 'TNat, ArithOp Or 'TNat 'TNat) Source #
ArithOp Sub 'TInt 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TInt 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TInt -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TInt)) (Value' instr (ArithRes Sub 'TInt 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TInt 'TInt ~ ArithRes Sub 'TInt 'TInt, ArithOp Sub 'TInt 'TInt) Source #
ArithOp Sub 'TInt 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TInt 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TInt -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TInt) (Value' instr 'TNat)) (Value' instr (ArithRes Sub 'TInt 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TInt 'TNat ~ ArithRes Sub 'TNat 'TInt, ArithOp Sub 'TNat 'TInt) Source #
ArithOp Sub 'TNat 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TNat 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TNat -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TInt)) (Value' instr (ArithRes Sub 'TNat 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TNat 'TInt ~ ArithRes Sub 'TInt 'TNat, ArithOp Sub 'TInt 'TNat) Source #
ArithOp Sub 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Sub 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TNat 'TNat ~ ArithRes Sub 'TNat 'TNat, ArithOp Sub 'TNat 'TNat) Source #
ArithOp Sub 'TTimestamp 'TInt Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TTimestamp 'TInt :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TTimestamp -> Value' instr 'TInt -> Either (ArithError (Value' instr 'TTimestamp) (Value' instr 'TInt)) (Value' instr (ArithRes Sub 'TTimestamp 'TInt)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TTimestamp 'TInt ~ ArithRes Sub 'TInt 'TTimestamp, ArithOp Sub 'TInt 'TTimestamp) Source #
ArithOp Sub 'TTimestamp 'TTimestamp Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Sub 'TTimestamp 'TTimestamp :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Sub -> Value' instr 'TTimestamp -> Value' instr 'TTimestamp -> Either (ArithError (Value' instr 'TTimestamp) (Value' instr 'TTimestamp)) (Value' instr (ArithRes Sub 'TTimestamp 'TTimestamp)) Source # commutativityProof :: Maybe $ Dict (ArithRes Sub 'TTimestamp 'TTimestamp ~ ArithRes Sub 'TTimestamp 'TTimestamp, ArithOp Sub 'TTimestamp 'TTimestamp) Source #
ArithOp SubMutez 'TMutez 'TMutez Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes SubMutez 'TMutez 'TMutez :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy SubMutez -> Value' instr 'TMutez -> Value' instr 'TMutez -> Either (ArithError (Value' instr 'TMutez) (Value' instr 'TMutez)) (Value' instr (ArithRes SubMutez 'TMutez 'TMutez)) Source # commutativityProof :: Maybe $ Dict (ArithRes SubMutez 'TMutez 'TMutez ~ ArithRes SubMutez 'TMutez 'TMutez, ArithOp SubMutez 'TMutez 'TMutez) Source #
ArithOp Xor 'TBool 'TBool Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Xor 'TBool 'TBool :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Xor -> Value' instr 'TBool -> Value' instr 'TBool -> Either (ArithError (Value' instr 'TBool) (Value' instr 'TBool)) (Value' instr (ArithRes Xor 'TBool 'TBool)) Source # commutativityProof :: Maybe $ Dict (ArithRes Xor 'TBool 'TBool ~ ArithRes Xor 'TBool 'TBool, ArithOp Xor 'TBool 'TBool) Source #
ArithOp Xor 'TBytes 'TBytes Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Xor 'TBytes 'TBytes :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Xor -> Value' instr 'TBytes -> Value' instr 'TBytes -> Either (ArithError (Value' instr 'TBytes) (Value' instr 'TBytes)) (Value' instr (ArithRes Xor 'TBytes 'TBytes)) Source # commutativityProof :: Maybe $ Dict (ArithRes Xor 'TBytes 'TBytes ~ ArithRes Xor 'TBytes 'TBytes, ArithOp Xor 'TBytes 'TBytes) Source #
ArithOp Xor 'TNat 'TNat Source #
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type ArithRes Xor 'TNat 'TNat :: T Source # Methods evalOp :: forall proxy (instr :: [T] -> [T] -> Type). proxy Xor -> Value' instr 'TNat -> Value' instr 'TNat -> Either (ArithError (Value' instr 'TNat) (Value' instr 'TNat)) (Value' instr (ArithRes Xor 'TNat 'TNat)) Source # commutativityProof :: Maybe $ Dict (ArithRes Xor 'TNat 'TNat ~ ArithRes Xor 'TNat 'TNat, ArithOp Xor 'TNat 'TNat) Source #

compareOp :: Comparable t => Value' i t -> Value' i t -> Integer Source #

Implementation for COMPARE instruction.

evalToNatOp :: Value' instr 'TBytes -> Value' instr 'TNat Source #

data SomeMeta where Source #

Constructors

SomeMeta :: forall meta. With [NFData, Show, Typeable] meta => meta -> SomeMeta

Instances

Instances details

Show SomeMeta Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> SomeMeta -> ShowS # show :: SomeMeta -> String # showList :: [SomeMeta] -> ShowS #
NFData SomeMeta Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: SomeMeta -> () #

data ExtInstr s Source #

Constructors

TEST_ASSERT (TestAssert s)
PRINT (PrintComment s)
DOC_ITEM SomeDocItem
COMMENT_ITEM CommentType
STACKTYPE StackTypePattern

Instances

Instances details

Generic (ExtInstr s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Associated Types type Rep (ExtInstr s) :: Type -> Type # Methods from :: ExtInstr s -> Rep (ExtInstr s) x # to :: Rep (ExtInstr s) x -> ExtInstr s #
Show (ExtInstr s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> ExtInstr s -> ShowS # show :: ExtInstr s -> String # showList :: [ExtInstr s] -> ShowS #
NFData (ExtInstr s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: ExtInstr s -> () #
type Rep (ExtInstr s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr type Rep (ExtInstr s) = D1 ('MetaData "ExtInstr" "Morley.Michelson.Typed.Instr" "morley-1.19.1-inplace" 'False) ((C1 ('MetaCons "TEST_ASSERT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (TestAssert s))) :+: C1 ('MetaCons "PRINT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (PrintComment s)))) :+: (C1 ('MetaCons "DOC_ITEM" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SomeDocItem)) :+: (C1 ('MetaCons "COMMENT_ITEM" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CommentType)) :+: C1 ('MetaCons "STACKTYPE" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 StackTypePattern)))))

data CommentType Source #

Constructors

FunctionStarts Text
FunctionEnds Text
StatementStarts Text
StatementEnds Text
JustComment Text
StackTypeComment (Maybe [T])	`Nothing` for any stack type

Instances

Instances details

IsString CommentType Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods fromString :: String -> CommentType #
Generic CommentType Source #
Instance details Defined in Morley.Michelson.Typed.Instr Associated Types type Rep CommentType :: Type -> Type # Methods from :: CommentType -> Rep CommentType x # to :: Rep CommentType x -> CommentType #
Show CommentType Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> CommentType -> ShowS # show :: CommentType -> String # showList :: [CommentType] -> ShowS #
NFData CommentType Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: CommentType -> () #
type Rep CommentType Source #
Instance details Defined in Morley.Michelson.Typed.Instr type Rep CommentType = D1 ('MetaData "CommentType" "Morley.Michelson.Typed.Instr" "morley-1.19.1-inplace" 'False) ((C1 ('MetaCons "FunctionStarts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "FunctionEnds" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "StatementStarts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)))) :+: (C1 ('MetaCons "StatementEnds" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "JustComment" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "StackTypeComment" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe [T]))))))

newtype PrintComment (st :: [T]) Source #

A print format with references into the stack

Constructors

PrintComment
Fields unPrintComment :: [Either Text (StackRef st)]

Instances

Instances details

IsString (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods fromString :: String -> PrintComment st #
Monoid (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods mempty :: PrintComment st # mappend :: PrintComment st -> PrintComment st -> PrintComment st # mconcat :: [PrintComment st] -> PrintComment st #
Semigroup (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods (<>) :: PrintComment st -> PrintComment st -> PrintComment st # sconcat :: NonEmpty (PrintComment st) -> PrintComment st # stimes :: Integral b => b -> PrintComment st -> PrintComment st #
Generic (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Associated Types type Rep (PrintComment st) :: Type -> Type # Methods from :: PrintComment st -> Rep (PrintComment st) x # to :: Rep (PrintComment st) x -> PrintComment st #
Show (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> PrintComment st -> ShowS # show :: PrintComment st -> String # showList :: [PrintComment st] -> ShowS #
NFData (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: PrintComment st -> () #
Eq (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods (==) :: PrintComment st -> PrintComment st -> Bool # (/=) :: PrintComment st -> PrintComment st -> Bool #
type Rep (PrintComment st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr type Rep (PrintComment st) = D1 ('MetaData "PrintComment" "Morley.Michelson.Typed.Instr" "morley-1.19.1-inplace" 'True) (C1 ('MetaCons "PrintComment" 'PrefixI 'True) (S1 ('MetaSel ('Just "unPrintComment") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Either Text (StackRef st)])))

data StackRef (st :: [T]) where Source #

A reference into the stack of a given type.

Constructors

StackRef :: RequireLongerThan st idx => PeanoNatural idx -> StackRef st

Keeps 0-based index to a stack element counting from the top.

Instances

Instances details

Show (StackRef st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> StackRef st -> ShowS # show :: StackRef st -> String # showList :: [StackRef st] -> ShowS #
NFData (StackRef st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: StackRef st -> () #
Buildable (StackRef st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods build :: StackRef st -> Builder #
Eq (StackRef st) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods (==) :: StackRef st -> StackRef st -> Bool # (/=) :: StackRef st -> StackRef st -> Bool #

data TestAssert (s :: [T]) where Source #

Constructors

TestAssert :: Text -> PrintComment inp -> Instr inp ('TBool ': out) -> TestAssert inp

Instances

Instances details

Show (TestAssert s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> TestAssert s -> ShowS # show :: TestAssert s -> String # showList :: [TestAssert s] -> ShowS #
NFData (TestAssert s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: TestAssert s -> () #
SingI s => Eq (TestAssert s) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods (==) :: TestAssert s -> TestAssert s -> Bool # (/=) :: TestAssert s -> TestAssert s -> Bool #

data Instr (inp :: [T]) (out :: [T]) where Source #

Representation of Michelson instruction or sequence of instructions.

Each Michelson instruction is represented by exactly one constructor of this data type. Sequence of instructions is represented with use of Seq constructor in following way: SWAP; DROP ; DUP; -> SWAP `Seq` DROP `Seq` DUP. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP `Seq` DROP).

Type parameter inp states for input stack type. That is, type of the stack that is required for operation to execute.

Type parameter out states for output stack type or type of stack that will be left after instruction's execution.

Each constructor here corresponding to an instruction that can have annotations is represented as AnnX, where X is the name of the instruction. These constructors accept a typed heterogenous list of annotations as the first argument. Pattern synonyms without the Ann prefix are provided, those ignore annotations entirely.

We need this AnnX constructors to carry annotations for PACK.

When typechecking a sequence of instructions, we'll attach annotations from the "untyped" instruction to the typed one. Note that if an instruction has a type argument, e.g. `PUSH (int :t) 2` we'll attach typed Notes for this type instead; other annotations are used as-is.

The interpreter mostly ignores annotations, with the exception of those used for entrypoint resolution.

The serializer (Morley.Michelson.Interpret.Pack) can restore the original "untyped" instruction from annotations on the "typed" one.

AnnSELF and AnnCONTRACT are a special case: field annotations on these instructions carry semantic meaning (specify the entrypoint), hence those are stored separately from other annotations, to simplify checking for invariants in "typed" contracts.

Constructors

WithLoc :: ErrorSrcPos -> Instr a b -> Instr a b	A wrapper carrying original source location of the instruction. TODO [#283]: replace this wrapper with something more clever and abstract.
Meta :: SomeMeta -> Instr a b -> Instr a b	A wrapper allowing arbitrary user metadata to be stored by some instruction. TODO [#689]: Use this instead of `DOC_ITEM`.
Seq :: Instr a b -> Instr b c -> Instr a c infixr 8
Nop :: Instr s s	Nop operation. Missing in Michelson spec, added to parse construction like `IF {} { SWAP; DROP; }`.
Ext :: ExtInstr s -> Instr s s
Nested :: Instr inp out -> Instr inp out	Nested wrapper is going to wrap a sequence of instructions with { }. It is crucial because serialisation of a contract depends on precise structure of its code.
DocGroup :: DocGrouping -> Instr inp out -> Instr inp out	Places documentation generated for given instruction under some group. This is not part of `ExtInstr` because it does not behave like `Nop`; instead, it inherits the behaviour of the instruction put within it.
AnnCAR :: Anns '[VarAnn, FieldAnn] -> Instr ('TPair a b ': s) (a ': s)
AnnCDR :: Anns '[VarAnn, FieldAnn] -> Instr ('TPair a b ': s) (b ': s)
DROP :: Instr (a ': s) s
DROPN :: forall (n :: Peano) s. RequireLongerOrSameLength s n => PeanoNatural n -> Instr s (Drop n s)
AnnDUP :: DupableScope a => AnnVar -> Instr (a ': s) (a ': (a ': s))
AnnDUPN :: forall (n :: Peano) inp out a. (ConstraintDUPN n inp out a, DupableScope a) => AnnVar -> PeanoNatural n -> Instr inp out
SWAP :: Instr (a ': (b ': s)) (b ': (a ': s))
DIG :: forall (n :: Peano) inp out a. ConstraintDIG n inp out a => PeanoNatural n -> Instr inp out
DUG :: forall (n :: Peano) inp out a. ConstraintDUG n inp out a => PeanoNatural n -> Instr inp out
AnnPUSH :: forall t s. ConstantScope t => Anns '[VarAnn, Notes t] -> Value' Instr t -> Instr s (t ': s)
AnnSOME :: Anns '[TypeAnn, VarAnn] -> Instr (a ': s) ('TOption a ': s)
AnnNONE :: forall a s. SingI a => Anns '[TypeAnn, VarAnn, Notes a] -> Instr s ('TOption a ': s)
AnnUNIT :: Anns '[TypeAnn, VarAnn] -> Instr s ('TUnit ': s)
IF_NONE :: Instr s s' -> Instr (a ': s) s' -> Instr ('TOption a ': s) s'
AnnPAIR :: Anns '[TypeAnn, VarAnn, FieldAnn, FieldAnn] -> Instr (a ': (b ': s)) ('TPair a b ': s)
AnnUNPAIR :: Anns '[VarAnn, VarAnn, FieldAnn, FieldAnn] -> Instr ('TPair a b ': s) (a ': (b ': s))
AnnPAIRN :: forall n inp. ConstraintPairN n inp => AnnVar -> PeanoNatural n -> Instr inp (PairN n inp)	`>>>` `:t PAIRN (toPeanoNatural' @3) :: Instr '[ 'TInt, 'TUnit, 'TString ] _`... ...:: Instr ... '[ 'TInt, 'TUnit, 'TString] ... '[ 'TPair 'TInt ('TPair 'TUnit 'TString)] `>>>` `PAIRN (toPeanoNatural' @1) :: Instr '[ 'TInt, 'TInt ] _`... ... 'PAIR n' expects n ≥ 2 ... `>>>` `PAIRN (toPeanoNatural' @3) :: Instr '[ 'TInt, 'TInt ] _`... ... Expected stack with length >= 3 ... Current stack has size of only 2: ...
UNPAIRN :: forall (n :: Peano) (pair :: T) (s :: [T]). ConstraintUnpairN n pair => PeanoNatural n -> Instr (pair ': s) (UnpairN n pair ++ s)	`>>>` `:t UNPAIRN (toPeanoNatural' @3) :: Instr '[ 'TPair 'TInt ('TPair 'TUnit 'TString) ] _`... ...:: Instr ... '[ 'TPair 'TInt ('TPair 'TUnit 'TString)] ... '[ 'TInt, 'TUnit, 'TString] `>>>` `:t UNPAIRN (toPeanoNatural' @3) :: Instr '[ 'TPair 'TInt ('TPair 'TUnit ('TPair 'TString 'TNat)) ] _`... ...:: Instr ... '[ 'TPair 'TInt ('TPair 'TUnit ('TPair 'TString 'TNat))] ... '[ 'TInt, 'TUnit, 'TPair 'TString 'TNat] `>>>` `UNPAIRN (toPeanoNatural' @1) :: Instr '[ 'TPair 'TInt 'TUnit ] _`... ...'UNPAIR n' expects n ≥ 2 ... `>>>` `UNPAIRN (toPeanoNatural' @2) :: Instr '[ 'TInt, 'TUnit, 'TString ] _`... ...Expected a pair at the top of the stack, but found: 'TInt ... `>>>` `UNPAIRN (toPeanoNatural' @3) :: Instr '[ 'TPair 'TInt 'TUnit ] _`... ...'UNPAIR 3' expects a right-combed pair with at least 3 elements at the top of the stack, ...but the pair only contains 2 elements. ...
AnnLEFT :: SingI b => Anns '[TypeAnn, VarAnn, FieldAnn, FieldAnn, Notes b] -> Instr (a ': s) ('TOr a b ': s)
AnnRIGHT :: SingI a => Anns '[TypeAnn, VarAnn, FieldAnn, FieldAnn, Notes a] -> Instr (b ': s) ('TOr a b ': s)
IF_LEFT :: Instr (a ': s) s' -> Instr (b ': s) s' -> Instr ('TOr a b ': s) s'
AnnNIL :: SingI p => Anns '[TypeAnn, VarAnn, Notes p] -> Instr s ('TList p ': s)
AnnCONS :: AnnVar -> Instr (a ': ('TList a ': s)) ('TList a ': s)
IF_CONS :: Instr (a ': ('TList a ': s)) s' -> Instr s s' -> Instr ('TList a ': s) s'
AnnSIZE :: SizeOp c => AnnVar -> Instr (c ': s) ('TNat ': s)
AnnEMPTY_SET :: (SingI e, Comparable e) => Anns '[TypeAnn, VarAnn, Notes e] -> Instr s ('TSet e ': s)
AnnEMPTY_MAP :: (SingI a, SingI b, Comparable a) => Anns '[TypeAnn, VarAnn, Notes a, Notes b] -> Instr s ('TMap a b ': s)
AnnEMPTY_BIG_MAP :: (SingI a, SingI b, Comparable a, HasNoBigMap b) => Anns '[TypeAnn, VarAnn, Notes a, Notes b] -> Instr s ('TBigMap a b ': s)
AnnMAP :: (MapOp c, SingI b) => AnnVar -> Instr (MapOpInp c ': s) (b ': s) -> Instr (c ': s) (MapOpRes c b ': s)
ITER :: IterOp c => Instr (IterOpEl c ': s) s -> Instr (c ': s) s
AnnMEM :: MemOp c => AnnVar -> Instr (MemOpKey c ': (c ': s)) ('TBool ': s)
AnnGET :: (GetOp c, SingI (GetOpVal c)) => AnnVar -> Instr (GetOpKey c ': (c ': s)) ('TOption (GetOpVal c) ': s)
AnnGETN :: forall (ix :: Peano) (pair :: T) (s :: [T]). ConstraintGetN ix pair => AnnVar -> PeanoNatural ix -> Instr (pair ': s) (GetN ix pair ': s)	Get the node at index `ix` of a right-combed pair. Nodes are 0-indexed, and are numbered in a breadth-first, left-to-right fashion. For example, a pair with 3 elements `pair a b c` will be represented as a tree with 5 nodes: pair / \ a pair / \ b c Where the nodes are numbered as follows: 0 / \ 1 2 / \ 3 4 `>>>` `:t GETN (toPeanoNatural' @1) :: Instr '[ 'TPair 'TInt 'TUnit] _`... ...:: Instr '[ 'TPair 'TInt 'TUnit] '[ 'TInt] `>>>` `GETN (toPeanoNatural' @1) :: Instr '[ 'TUnit ] _`... ...Expected a pair at the top of the stack, but found: 'TUnit ... `>>>` `GETN (toPeanoNatural' @3) :: Instr '[ 'TPair 'TInt 'TUnit ] _`... ...'GET 3' expects a right-combed pair with at least 4 nodes at the top of the stack, ...but the pair only contains 3 nodes. ... Note that `GET 0` is just the identity function and works for all types (not just pairs). `>>>` `:t GETN (toPeanoNatural' @0) :: Instr '[ 'TInt ] _`... ...:: Instr '[ 'TInt] '[ 'TInt]
AnnUPDATE :: UpdOp c => AnnVar -> Instr (UpdOpKey c ': (UpdOpParams c ': (c ': s))) (c ': s)
AnnUPDATEN :: forall (ix :: Peano) (val :: T) (pair :: T) (s :: [T]). ConstraintUpdateN ix pair => AnnVar -> PeanoNatural ix -> Instr (val ': (pair ': s)) (UpdateN ix val pair ': s)	Update the node at index `ix` of a right-combed pair. `>>>` `:t UPDATEN (toPeanoNatural' @1) :: Instr '[ 'TString, 'TPair 'TInt 'TUnit] _`... ...:: Instr ... '[ 'TString, 'TPair 'TInt 'TUnit] '[ 'TPair 'TString 'TUnit] `>>>` `UPDATEN (toPeanoNatural' @1) :: Instr '[ 'TUnit, 'TInt ] _`... ...Expected the 2nd element of the stack to be a pair, but found: 'TInt ... `>>>` `UPDATEN (toPeanoNatural' @3) :: Instr '[ 'TString, 'TPair 'TInt 'TUnit ] _`... ...'UPDATE 3' expects the 2nd element of the stack to be a right-combed pair with at least 4 nodes, ...but the pair only contains 3 nodes. ... Note that `UPDATE 0` is equivalent to `DIP { DROP }`. `>>>` `:t UPDATEN (toPeanoNatural' @0) :: Instr '[ 'TInt, 'TString ] _`... ...:: Instr '[ 'TInt, 'TString] '[ 'TInt]
AnnGET_AND_UPDATE :: (GetOp c, UpdOp c, SingI (GetOpVal c), UpdOpKey c ~ GetOpKey c) => AnnVar -> Instr (UpdOpKey c ': (UpdOpParams c ': (c ': s))) ('TOption (GetOpVal c) ': (c ': s))
IF :: Instr s s' -> Instr s s' -> Instr ('TBool ': s) s'
LOOP :: Instr s ('TBool ': s) -> Instr ('TBool ': s) s
LOOP_LEFT :: Instr (a ': s) ('TOr a b ': s) -> Instr ('TOr a b ': s) (b ': s)
AnnLAMBDA :: forall i o s. (SingI i, SingI o) => Anns '[VarAnn, Notes i, Notes o] -> RemFail Instr '[i] '[o] -> Instr s ('TLambda i o ': s)
AnnLAMBDA_REC :: forall i o s. (SingI i, SingI o) => Anns '[VarAnn, Notes i, Notes o] -> RemFail Instr '[i, 'TLambda i o] '[o] -> Instr s ('TLambda i o ': s)
AnnEXEC :: AnnVar -> Instr (t1 ': ('TLambda t1 t2 ': s)) (t2 ': s)
AnnAPPLY :: forall a b c s. (ConstantScope a, SingI b) => AnnVar -> Instr (a ': ('TLambda ('TPair a b) c ': s)) ('TLambda b c ': s)
DIP :: Instr a c -> Instr (b ': a) (b ': c)
DIPN :: forall (n :: Peano) inp out s s'. ConstraintDIPN n inp out s s' => PeanoNatural n -> Instr s s' -> Instr inp out
FAILWITH :: (SingI a, ConstantScope a) => Instr (a ': s) t
AnnCAST :: forall a s. SingI a => Anns '[VarAnn, Notes a] -> Instr (a ': s) (a ': s)
AnnRENAME :: AnnVar -> Instr (a ': s) (a ': s)
AnnPACK :: PackedValScope a => AnnVar -> Instr (a ': s) ('TBytes ': s)
AnnUNPACK :: (UnpackedValScope a, SingI a) => Anns '[TypeAnn, VarAnn, Notes a] -> Instr ('TBytes ': s) ('TOption a ': s)
AnnCONCAT :: ConcatOp c => AnnVar -> Instr (c ': (c ': s)) (c ': s)
AnnCONCAT' :: ConcatOp c => AnnVar -> Instr ('TList c ': s) (c ': s)
AnnSLICE :: (SliceOp c, SingI c) => AnnVar -> Instr ('TNat ': ('TNat ': (c ': s))) ('TOption c ': s)
AnnISNAT :: AnnVar -> Instr ('TInt ': s) ('TOption 'TNat ': s)
AnnADD :: ArithOp Add n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Add n m ': s)
AnnSUB :: ArithOp Sub n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Sub n m ': s)
AnnSUB_MUTEZ :: AnnVar -> Instr ('TMutez ': ('TMutez ': s)) ('TOption 'TMutez ': s)
AnnMUL :: ArithOp Mul n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Mul n m ': s)
AnnEDIV :: ArithOp EDiv n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes EDiv n m ': s)
AnnABS :: UnaryArithOp Abs n => AnnVar -> Instr (n ': s) (UnaryArithRes Abs n ': s)
AnnNEG :: UnaryArithOp Neg n => AnnVar -> Instr (n ': s) (UnaryArithRes Neg n ': s)
AnnLSL :: ArithOp Lsl n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Lsl n m ': s)
AnnLSR :: ArithOp Lsr n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Lsr n m ': s)
AnnOR :: ArithOp Or n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Or n m ': s)
AnnAND :: ArithOp And n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes And n m ': s)
AnnXOR :: ArithOp Xor n m => AnnVar -> Instr (n ': (m ': s)) (ArithRes Xor n m ': s)
AnnNOT :: (SingI n, UnaryArithOp Not n) => AnnVar -> Instr (n ': s) (UnaryArithRes Not n ': s)
AnnCOMPARE :: (Comparable n, SingI n) => AnnVar -> Instr (n ': (n ': s)) ('TInt ': s)
AnnEQ :: UnaryArithOp Eq' n => AnnVar -> Instr (n ': s) (UnaryArithRes Eq' n ': s)
AnnNEQ :: UnaryArithOp Neq n => AnnVar -> Instr (n ': s) (UnaryArithRes Neq n ': s)
AnnLT :: UnaryArithOp Lt n => AnnVar -> Instr (n ': s) (UnaryArithRes Lt n ': s)
AnnGT :: UnaryArithOp Gt n => AnnVar -> Instr (n ': s) (UnaryArithRes Gt n ': s)
AnnLE :: UnaryArithOp Le n => AnnVar -> Instr (n ': s) (UnaryArithRes Le n ': s)
AnnGE :: UnaryArithOp Ge n => AnnVar -> Instr (n ': s) (UnaryArithRes Ge n ': s)
AnnINT :: ToIntArithOp n => AnnVar -> Instr (n ': s) ('TInt ': s)
AnnBYTES :: ToBytesArithOp n => AnnVar -> Instr (n ': s) ('TBytes ': s)
AnnNAT :: AnnVar -> Instr ('TBytes ': s) ('TNat ': s)
AnnVIEW :: (SingI arg, ViewableScope ret) => Anns '[VarAnn, Notes ret] -> ViewName -> Instr (arg ': ('TAddress ': s)) ('TOption ret ': s)
AnnSELF :: forall (arg :: T) s. (ParameterScope arg, IsNotInView) => AnnVar -> SomeEntrypointCallT arg -> Instr s ('TContract arg ': s)	Note that the field annotation on `SELF` is stored as the second parameter to `AnnSELF`, because it's not as much an annotation as an entrypoint specification.
AnnCONTRACT :: ParameterScope p => Anns '[VarAnn, Notes p] -> EpName -> Instr ('TAddress ': s) ('TOption ('TContract p) ': s)	Note that the field annotation on `CONTRACT` is stored as the second parameter to `AnnCONTRACT`, because it's not as much an annotation as an entrypoint specification.
AnnTRANSFER_TOKENS :: (ParameterScope p, IsNotInView) => AnnVar -> Instr (p ': ('TMutez ': ('TContract p ': s))) ('TOperation ': s)
AnnSET_DELEGATE :: IsNotInView => AnnVar -> Instr ('TOption 'TKeyHash ': s) ('TOperation ': s)
AnnCREATE_CONTRACT :: (ParameterScope p, StorageScope g, IsNotInView) => Anns '[VarAnn, VarAnn] -> Contract' Instr p g -> Instr ('TOption 'TKeyHash ': ('TMutez ': (g ': s))) ('TOperation ': ('TAddress ': s))
AnnIMPLICIT_ACCOUNT :: AnnVar -> Instr ('TKeyHash ': s) ('TContract 'TUnit ': s)
AnnNOW :: AnnVar -> Instr s ('TTimestamp ': s)
AnnAMOUNT :: AnnVar -> Instr s ('TMutez ': s)
AnnBALANCE :: AnnVar -> Instr s ('TMutez ': s)
AnnVOTING_POWER :: AnnVar -> Instr ('TKeyHash ': s) ('TNat ': s)
AnnTOTAL_VOTING_POWER :: AnnVar -> Instr s ('TNat ': s)
AnnCHECK_SIGNATURE :: AnnVar -> Instr ('TKey ': ('TSignature ': ('TBytes ': s))) ('TBool ': s)
AnnSHA256 :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
AnnSHA512 :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
AnnBLAKE2B :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
AnnSHA3 :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
AnnKECCAK :: AnnVar -> Instr ('TBytes ': s) ('TBytes ': s)
AnnHASH_KEY :: AnnVar -> Instr ('TKey ': s) ('TKeyHash ': s)
AnnPAIRING_CHECK :: AnnVar -> Instr ('TList ('TPair 'TBls12381G1 'TBls12381G2) ': s) ('TBool ': s)
AnnSOURCE :: AnnVar -> Instr s ('TAddress ': s)
AnnSENDER :: AnnVar -> Instr s ('TAddress ': s)
AnnADDRESS :: AnnVar -> Instr ('TContract a ': s) ('TAddress ': s)
AnnCHAIN_ID :: AnnVar -> Instr s ('TChainId ': s)
AnnLEVEL :: AnnVar -> Instr s ('TNat ': s)
AnnSELF_ADDRESS :: AnnVar -> Instr s ('TAddress ': s)
NEVER :: Instr ('TNever ': s) t
AnnTICKET_DEPRECATED :: Comparable a => AnnVar -> Instr (a ': ('TNat ': s)) ('TTicket a ': s)
AnnTICKET :: Comparable a => AnnVar -> Instr (a ': ('TNat ': s)) ('TOption ('TTicket a) ': s)
AnnREAD_TICKET :: AnnVar -> Instr ('TTicket a ': s) (RightComb ['TAddress, a, 'TNat] ': ('TTicket a ': s))
AnnSPLIT_TICKET :: AnnVar -> Instr ('TTicket a ': ('TPair 'TNat 'TNat ': s)) ('TOption ('TPair ('TTicket a) ('TTicket a)) ': s)
AnnJOIN_TICKETS :: AnnVar -> Instr ('TPair ('TTicket a) ('TTicket a) ': s) ('TOption ('TTicket a) ': s)
AnnOPEN_CHEST :: AnnVar -> Instr ('TChestKey ': ('TChest ': ('TNat ': s))) ('TOr 'TBytes 'TBool ': s)
AnnSAPLING_EMPTY_STATE :: AnnVar -> Sing n -> Instr s ('TSaplingState n ': s)
AnnSAPLING_VERIFY_UPDATE :: AnnVar -> Instr ('TSaplingTransaction n ': ('TSaplingState n ': s)) ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n))) ': s)
AnnMIN_BLOCK_TIME :: [AnyAnn] -> Instr s ('TNat ': s)
AnnEMIT :: PackedValScope t => AnnVar -> FieldAnn -> Maybe (Notes t) -> Instr (t ': s) ('TOperation ': s)

Bundled Patterns

pattern NAT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TNat s) => Instr inp out
pattern BYTES :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) 'TBytes s, ToBytesArithOp n) => Instr inp out
pattern EMIT :: forall {inp} {out}. () => forall (t :: T) (s :: [T]). (inp ~ '(:) t s, out ~ '(:) 'TOperation s, PackedValScope t) => FieldAnn -> Maybe (Notes t) -> Instr inp out
pattern MIN_BLOCK_TIME :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TNat s) => Instr inp out
pattern SAPLING_VERIFY_UPDATE :: forall {inp} {out}. () => forall (n :: Peano) (s :: [T]). (inp ~ '(:) ('TSaplingTransaction n) ('(:) ('TSaplingState n) s), out ~ '(:) ('TOption ('TPair 'TBytes ('TPair 'TInt ('TSaplingState n)))) s) => Instr inp out
pattern SAPLING_EMPTY_STATE :: forall {inp} {out}. () => forall (n :: Peano) (s :: [T]). (inp ~ s, out ~ '(:) ('TSaplingState n) s) => Sing n -> Instr inp out
pattern OPEN_CHEST :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TChestKey ('(:) 'TChest ('(:) 'TNat s)), out ~ '(:) ('TOr 'TBytes 'TBool) s) => Instr inp out	Deprecated: Due to a vulnerability discovered in time-lock protocol, OPEN_CHEST is temporarily deprecated since Lima
pattern JOIN_TICKETS :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TPair ('TTicket a) ('TTicket a)) s, out ~ '(:) ('TOption ('TTicket a)) s) => Instr inp out
pattern SPLIT_TICKET :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TTicket a) ('(:) ('TPair 'TNat 'TNat) s), out ~ '(:) ('TOption ('TPair ('TTicket a) ('TTicket a))) s) => Instr inp out
pattern READ_TICKET :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TTicket a) s, out ~ '(:) (RightComb ('(:) 'TAddress ('(:) a ('(:) 'TNat ('[] :: [T]))))) ('(:) ('TTicket a) s)) => Instr inp out
pattern TICKET_DEPRECATED :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a ('(:) 'TNat s), out ~ '(:) ('TTicket a) s, Comparable a) => Instr inp out
pattern TICKET :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a ('(:) 'TNat s), out ~ '(:) ('TOption ('TTicket a)) s, Comparable a) => Instr inp out
pattern SELF_ADDRESS :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TAddress s) => Instr inp out
pattern LEVEL :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TNat s) => Instr inp out
pattern CHAIN_ID :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TChainId s) => Instr inp out
pattern ADDRESS :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) ('TContract a) s, out ~ '(:) 'TAddress s) => Instr inp out
pattern SENDER :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TAddress s) => Instr inp out
pattern SOURCE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TAddress s) => Instr inp out
pattern PAIRING_CHECK :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) ('TList ('TPair 'TBls12381G1 'TBls12381G2)) s, out ~ '(:) 'TBool s) => Instr inp out
pattern HASH_KEY :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKey s, out ~ '(:) 'TKeyHash s) => Instr inp out
pattern KECCAK :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
pattern SHA3 :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
pattern BLAKE2B :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
pattern CHECK_SIGNATURE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKey ('(:) 'TSignature ('(:) 'TBytes s)), out ~ '(:) 'TBool s) => Instr inp out
pattern TOTAL_VOTING_POWER :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TNat s) => Instr inp out
pattern VOTING_POWER :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKeyHash s, out ~ '(:) 'TNat s) => Instr inp out
pattern BALANCE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TMutez s) => Instr inp out
pattern AMOUNT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TMutez s) => Instr inp out
pattern NOW :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TTimestamp s) => Instr inp out
pattern IMPLICIT_ACCOUNT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TKeyHash s, out ~ '(:) ('TContract 'TUnit) s) => Instr inp out
pattern CREATE_CONTRACT :: forall {inp} {out}. () => forall (p :: T) (g :: T) (s :: [T]). (inp ~ '(:) ('TOption 'TKeyHash) ('(:) 'TMutez ('(:) g s)), out ~ '(:) 'TOperation ('(:) 'TAddress s), ParameterScope p, StorageScope g, IsNotInView) => Contract' Instr p g -> Instr inp out
pattern SET_DELEGATE :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) ('TOption 'TKeyHash) s, out ~ '(:) 'TOperation s, IsNotInView) => Instr inp out
pattern TRANSFER_TOKENS :: forall {inp} {out}. () => forall (p :: T) (s :: [T]). (inp ~ '(:) p ('(:) 'TMutez ('(:) ('TContract p) s)), out ~ '(:) 'TOperation s, ParameterScope p, IsNotInView) => Instr inp out
pattern CONTRACT :: forall {inp} {out}. () => forall (p :: T) (s :: [T]). (inp ~ '(:) 'TAddress s, out ~ '(:) ('TOption ('TContract p)) s, ParameterScope p) => EpName -> Instr inp out
pattern SELF :: forall {inp} {out}. () => forall (arg :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TContract arg) s, ParameterScope arg, IsNotInView) => SomeEntrypointCallT arg -> Instr inp out
pattern VIEW :: forall {inp} {out}. () => forall (arg :: T) (ret :: T) (s :: [T]). (inp ~ '(:) arg ('(:) 'TAddress s), out ~ '(:) ('TOption ret) s, SingI arg, ViewableScope ret) => ViewName -> Instr inp out
pattern INT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) 'TInt s, ToIntArithOp n) => Instr inp out
pattern NEQ :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Neq n) s, UnaryArithOp Neq n) => Instr inp out
pattern COMPARE :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n ('(:) n s), out ~ '(:) 'TInt s, Comparable n, SingI n) => Instr inp out
pattern NOT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Not n) s, SingI n, UnaryArithOp Not n) => Instr inp out
pattern XOR :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Xor n m) s, ArithOp Xor n m) => Instr inp out
pattern AND :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes And n m) s, ArithOp And n m) => Instr inp out
pattern OR :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Or n m) s, ArithOp Or n m) => Instr inp out
pattern LSR :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Lsr n m) s, ArithOp Lsr n m) => Instr inp out
pattern LSL :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Lsl n m) s, ArithOp Lsl n m) => Instr inp out
pattern NEG :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Neg n) s, UnaryArithOp Neg n) => Instr inp out
pattern ABS :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Abs n) s, UnaryArithOp Abs n) => Instr inp out
pattern EDIV :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes EDiv n m) s, ArithOp EDiv n m) => Instr inp out
pattern MUL :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Mul n m) s, ArithOp Mul n m) => Instr inp out
pattern SUB_MUTEZ :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TMutez ('(:) 'TMutez s), out ~ '(:) ('TOption 'TMutez) s) => Instr inp out
pattern SUB :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Sub n m) s, ArithOp Sub n m) => Instr inp out
pattern ADD :: forall {inp} {out}. () => forall (n :: T) (m :: T) (s :: [T]). (inp ~ '(:) n ('(:) m s), out ~ '(:) (ArithRes Add n m) s, ArithOp Add n m) => Instr inp out
pattern ISNAT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TInt s, out ~ '(:) ('TOption 'TNat) s) => Instr inp out
pattern SLICE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) 'TNat ('(:) 'TNat ('(:) c s)), out ~ '(:) ('TOption c) s, SliceOp c, SingI c) => Instr inp out
pattern CONCAT' :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) ('TList c) s, out ~ '(:) c s, ConcatOp c) => Instr inp out
pattern CONCAT :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) c ('(:) c s), out ~ '(:) c s, ConcatOp c) => Instr inp out
pattern UNPACK :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) ('TOption a) s, UnpackedValScope a, SingI a) => Instr inp out
pattern PACK :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) 'TBytes s, PackedValScope a) => Instr inp out
pattern RENAME :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) a s) => Instr inp out
pattern CAST :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) a s, SingI a) => Instr inp out
pattern APPLY :: forall {inp} {out}. () => forall (a :: T) (b :: T) (c :: T) (s :: [T]). (inp ~ '(:) a ('(:) ('TLambda ('TPair a b) c) s), out ~ '(:) ('TLambda b c) s, ConstantScope a, SingI b) => Instr inp out
pattern EXEC :: forall {inp} {out}. () => forall (t1 :: T) (t2 :: T) (s :: [T]). (inp ~ '(:) t1 ('(:) ('TLambda t1 t2) s), out ~ '(:) t2 s) => Instr inp out
pattern LAMBDA_REC :: forall s r. () => forall i o. (SingI i, SingI o, r ~ ('TLambda i o ': s)) => (IsNotInView => RemFail Instr '[i, 'TLambda i o] '[o]) -> Instr s r
pattern LAMBDA :: forall s r. () => forall i o. (SingI i, SingI o, r ~ ('TLambda i o ': s)) => (IsNotInView => RemFail Instr '[i] '[o]) -> Instr s r
pattern GET_AND_UPDATE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (UpdOpKey c) ('(:) (UpdOpParams c) ('(:) c s)), out ~ '(:) ('TOption (GetOpVal c)) ('(:) c s), GetOp c, UpdOp c, SingI (GetOpVal c), (~) (UpdOpKey c) (GetOpKey c)) => Instr inp out
pattern UPDATEN :: forall {inp} {out}. () => forall (ix :: Peano) (val :: T) (pair :: T) (s :: [T]). (inp ~ '(:) val ('(:) pair s), out ~ '(:) (UpdateN ix val pair) s, ConstraintUpdateN ix pair) => PeanoNatural ix -> Instr inp out
pattern UPDATE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (UpdOpKey c) ('(:) (UpdOpParams c) ('(:) c s)), out ~ '(:) c s, UpdOp c) => Instr inp out
pattern GETN :: forall {inp} {out}. () => forall (ix :: Peano) (pair :: T) (s :: [T]). (inp ~ '(:) pair s, out ~ '(:) (GetN ix pair) s, ConstraintGetN ix pair) => PeanoNatural ix -> Instr inp out
pattern GET :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (GetOpKey c) ('(:) c s), out ~ '(:) ('TOption (GetOpVal c)) s, GetOp c, SingI (GetOpVal c)) => Instr inp out
pattern MEM :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) (MemOpKey c) ('(:) c s), out ~ '(:) 'TBool s, MemOp c) => Instr inp out
pattern MAP :: forall {inp} {out}. () => forall (c :: T) (b :: T) (s :: [T]). (inp ~ '(:) c s, out ~ '(:) (MapOpRes c b) s, MapOp c, SingI b) => Instr ('(:) (MapOpInp c) s) ('(:) b s) -> Instr inp out
pattern EMPTY_BIG_MAP :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TBigMap a b) s, SingI a, SingI b, Comparable a, HasNoBigMap b) => Instr inp out
pattern EMPTY_MAP :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TMap a b) s, SingI a, SingI b, Comparable a) => Instr inp out
pattern EMPTY_SET :: forall {inp} {out}. () => forall (e :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TSet e) s, SingI e, Comparable e) => Instr inp out
pattern SIZE :: forall {inp} {out}. () => forall (c :: T) (s :: [T]). (inp ~ '(:) c s, out ~ '(:) 'TNat s, SizeOp c) => Instr inp out
pattern CONS :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a ('(:) ('TList a) s), out ~ '(:) ('TList a) s) => Instr inp out
pattern NIL :: forall {inp} {out}. () => forall (p :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TList p) s, SingI p) => Instr inp out
pattern RIGHT :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) b s, out ~ '(:) ('TOr a b) s, SingI a) => Instr inp out
pattern LEFT :: forall {inp} {out}. () => forall (b :: T) (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) ('TOr a b) s, SingI b) => Instr inp out
pattern PAIRN :: forall {inp} {out}. () => forall (n :: Peano) (inp :: [T]). (inp ~ inp, out ~ PairN n inp, ConstraintPairN n inp) => PeanoNatural n -> Instr inp out
pattern UNPAIR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) ('TPair a b) s, out ~ '(:) a ('(:) b s)) => Instr inp out
pattern PAIR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) a ('(:) b s), out ~ '(:) ('TPair a b) s) => Instr inp out
pattern UNIT :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ s, out ~ '(:) 'TUnit s) => Instr inp out
pattern SOME :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) ('TOption a) s) => Instr inp out
pattern PUSH :: forall {inp} {out}. () => forall (t :: T) (s :: [T]). (inp ~ s, out ~ '(:) t s, ConstantScope t) => Value' Instr t -> Instr inp out
pattern DUPN :: forall {inp} {out}. () => forall (n :: Peano) (inp :: [T]) (out :: [T]) (a :: T). (inp ~ inp, out ~ out, ConstraintDUPN n inp out a, DupableScope a) => PeanoNatural n -> Instr inp out
pattern DUP :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ '(:) a s, out ~ '(:) a ('(:) a s), DupableScope a) => Instr inp out
pattern CDR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) ('TPair a b) s, out ~ '(:) b s) => Instr inp out
pattern CAR :: forall {inp} {out}. () => forall (a :: T) (b :: T) (s :: [T]). (inp ~ '(:) ('TPair a b) s, out ~ '(:) a s) => Instr inp out
pattern GE :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Ge n) s, UnaryArithOp Ge n) => Instr inp out
pattern SHA256 :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
pattern SHA512 :: forall {inp} {out}. () => forall (s :: [T]). (inp ~ '(:) 'TBytes s, out ~ '(:) 'TBytes s) => Instr inp out
pattern LE :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Le n) s, UnaryArithOp Le n) => Instr inp out
pattern NONE :: forall {inp} {out}. () => forall (a :: T) (s :: [T]). (inp ~ s, out ~ '(:) ('TOption a) s, SingI a) => Instr inp out
pattern GT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Gt n) s, UnaryArithOp Gt n) => Instr inp out
pattern LT :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Lt n) s, UnaryArithOp Lt n) => Instr inp out
pattern EQ :: forall {inp} {out}. () => forall (n :: T) (s :: [T]). (inp ~ '(:) n s, out ~ '(:) (UnaryArithRes Eq' n) s, UnaryArithOp Eq' n) => Instr inp out

Instances

Instances details

HasRPCRepr Operation Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Operation Source #
WithClassifiedInstr Instr Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.WithClassifiedInstr Associated Types type WCIConstraint Instr cls' Source # Methods withClassifiedInstr :: forall t (inp :: [T]) (out :: [T]) r. ClassifyInstr t => (forall (cls :: InstrClass). (SingI cls, WCIConstraint Instr cls) => Sing (GetClassified cls) -> ClassifiedInstr cls inp out -> r) -> Instr inp out -> r Source #
TypeHasDoc Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Operation :: FieldDescriptions Source # Methods typeDocName :: Proxy Operation -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Operation -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Operation Source # typeDocMichelsonRep :: TypeDocMichelsonRep Operation Source #
IsoValue Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Operation :: T Source # Methods toVal :: Operation -> Value (ToT Operation) Source # fromVal :: Value (ToT Operation) -> Operation Source #
(FromExp x Value, SingI t) => FromExp x (Value t) Source #
Instance details Defined in Morley.Micheline.Class Methods fromExp :: Exp x -> Either (FromExpError x) (Value t) Source #
(SingI inp, SingI out) => FromExp RegularExp (Instr '[inp] '[out]) Source #
Instance details Defined in Morley.Micheline.Class Methods fromExp :: Exp RegularExp -> Either (FromExpError RegularExp) (Instr '[inp] '[out]) Source #
HasRPCRepr (Value t) Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Value t) Source #
HasNoOp t => ToExpression (Value t) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Value t -> Expression Source #
(forall (t :: T). cs t => HasNoOp t) => RenderDoc (SomeConstrainedValue cs) Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods renderDoc :: RenderContext -> SomeConstrainedValue cs -> Doc Source # isRenderable :: SomeConstrainedValue cs -> Bool Source #
WellTyped t => IsoValue (Value t) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Value t) :: T Source # Methods toVal :: Value t -> Value (ToT (Value t)) Source # fromVal :: Value (ToT (Value t)) -> Value t Source #
Monoid (Instr s s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods mempty :: Instr s s # mappend :: Instr s s -> Instr s s -> Instr s s # mconcat :: [Instr s s] -> Instr s s #
Semigroup (Instr s s) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods (<>) :: Instr s s -> Instr s s -> Instr s s # sconcat :: NonEmpty (Instr s s) -> Instr s s # stimes :: Integral b => b -> Instr s s -> Instr s s #
Show (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> Instr inp out -> ShowS # show :: Instr inp out -> String # showList :: [Instr inp out] -> ShowS #
NFData (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: Instr inp out -> () #
Buildable (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods build :: Instr inp out -> Builder #
Buildable (Value' Instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods build :: Value' Instr t -> Builder #
Eq (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods (==) :: Instr inp out -> Instr inp out -> Bool # (/=) :: Instr inp out -> Instr inp out -> Bool #
ToExpression (Contract cp st) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Contract cp st -> Expression Source #
ToExpression (Instr inp out) Source #
Instance details Defined in Morley.Micheline.Class Methods toExpression :: Instr inp out -> Expression Source #
ContainsDoc (Contract cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods buildDocUnfinalized :: Contract cp st -> ContractDoc Source #
ContainsDoc (ContractCode inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods buildDocUnfinalized :: ContractCode inp out -> ContractDoc Source #
ContainsDoc (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods buildDocUnfinalized :: Instr inp out -> ContractDoc Source #
ContainsUpdateableDoc (Contract cp st) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> Contract cp st -> Contract cp st Source #
ContainsUpdateableDoc (ContractCode inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> ContractCode inp out -> ContractCode inp out Source #
ContainsUpdateableDoc (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Doc Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> Instr inp out -> Instr inp out Source #
RenderDoc (Instr inp out) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods renderDoc :: RenderContext -> Instr inp out -> Doc Source # isRenderable :: Instr inp out -> Bool Source #
HasNoOp t => RenderDoc (Value' Instr t) Source #
Instance details Defined in Morley.Michelson.Typed.Convert Methods renderDoc :: RenderContext -> Value' Instr t -> Doc Source # isRenderable :: Value' Instr t -> Bool Source #
type AsRPC Operation Source #
Instance details Defined in Morley.AsRPC type AsRPC Operation = Operation
type TypeDocFieldDescriptions Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Operation = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Operation = 'TOperation
type WCIConstraint Instr _1 Source #
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.WithClassifiedInstr type WCIConstraint Instr _1 = ()
type AsRPC (Value t) Source #
Instance details Defined in Morley.AsRPC type AsRPC (Value t) = Value (TAsRPC t)
type ToT (Value t) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Value t) = t

pattern ConcreteMeta :: Typeable meta => meta -> Instr i o -> Instr i o Source #

A convenience pattern synonym for Meta, matching on a concrete given type wrapped by SomeMeta, e.g.

\case { ContreteMeta (x :: Word) -> ... }

pattern (:#) :: Instr a b -> Instr b c -> Instr a c infixr 8 Source #

Right-associative operator for Seq.

>>> Debug.show (DROP :# UNIT :# Nop) == Debug.show (DROP :# (UNIT :# Nop))
True

castInstr :: forall inp1 out1 inp2 out2. (SingI inp1, SingI out1, SingI inp2, SingI out2) => Instr inp1 out1 -> Maybe (Instr inp2 out2) Source #

mkStackRef :: forall (gn :: Nat) st n. (n ~ ToPeano gn, SingIPeano gn, RequireLongerThan st n) => StackRef st Source #

Create a stack reference, performing checks at compile time.

frameInstr :: forall s a b. Instr a b -> Instr (a ++ s) (b ++ s) Source #

Execute given instruction on truncated stack.

This is sound because for all Michelson instructions the following property holds: if some code accepts stack i and produces stack o, when it can also be run on stack i + s producing stack o + s; and also because Michelson never makes implicit assumptions on types, rather you have to express all "yet ambiguous" type information in code.

The complexity of this operation is linear in the number of instructions. If possible, avoid nested uses as that would imply multiple traversals. Worst case, complexity can become quadratic.

type SomeViewsSet = SomeViewsSet' Instr Source #

type ViewsSet = ViewsSet' Instr Source #

type SomeView = SomeView' Instr Source #

type View = View' Instr Source #

type ViewCode arg st ret = ViewCode' Instr arg st ret Source #

type Contract = Contract' Instr Source #

type ContractCode cp st = ContractCode' Instr cp st Source #

type Operation = Operation' Instr Source #

type Value = Value' Instr Source #

data SomeAnns where Source #

A wrapper around either typechecked Anns or unchecked NonEmpty of AnyAnn. Annotations on some instructions aren't typechecked, hence these two constructors.

Helper for instrAnns.

Constructors

SomeAnns :: Anns xs -> SomeAnns
SomeUncheckedAnns :: NonEmpty AnyAnn -> SomeAnns

data PushableStorageSplit s st where Source #

Result of splitting a storage Value of st on the stack s.

The idea behind this is to either: prove that the whole Value can be put on the stack without containing a single big_map or to split it into: a Value containing its big_maps and an instruction to reconstruct the storage.

The main idea behind this is to create a large storage in Michelson code to then create a contract using CREATE_CONTRACT. Note: a simpler solution would have been to replace big_map Values with an EMPTY_BIG_MAP followed by many UPDATE to push its content, but sadly a bug (tezostezos1154) prevents this from being done.

Constructors

ConstantStorage :: ConstantScope st => Value st -> PushableStorageSplit s st	The type of the storage is fully constant.
PushableValueStorage :: StorageScope st => Instr s (st ': s) -> PushableStorageSplit s st	The type of the storage is not a constant, but its value does not contain `big_map`s. E.g. A 'Right ()' value of type 'Either (BigMap k v) ()'.
PartlyPushableStorage :: (StorageScope heavy, StorageScope st) => Value heavy -> Instr (heavy ': s) (st ': s) -> PushableStorageSplit s st	The type of the storage and part of its value (here `heavy`) contain one or more `big_map`s or `ticket`s. The instruction can take the non-pushable 'Value heavy' and reconstruct the original 'Value st' without using any `EMPTY_BIG_MAP`.

data CtorEffectsApp m Source #

Describes how intermediate nodes in instruction tree are accounted.

Constructors

CtorEffectsApp
Fields ceaName :: Text Name of this way. ceaPostStep :: forall i o. Monad m => Instr i o -> m (Instr i o) -> m (Instr i o) This transformation is applied after the step. It will be provided with the old instruction and the action gathered with the recursive traversal for the instruction subtree, and the result will go to the parent node.

Instances

Instances details

Buildable (CtorEffectsApp x) Source #
Instance details Defined in Morley.Michelson.Typed.Util Methods build :: CtorEffectsApp x -> Builder #

data DfsSettings m Source #

Options for dfsTraverseInstr family of functions.

Constructors

DfsSettings
Fields dsGoToValues :: Bool Whether `dfsTraverseInstr` function should go into values which contain other instructions: lambdas and constant contracts (which can be passed to `CREATE_CONTRACT`). dsCtorEffectsApp :: CtorEffectsApp m How do we handle intermediate nodes in instruction tree. dsInstrStep :: forall i o. Instr i o -> m (Instr i o) dsValueStep :: forall t'. Value t' -> m (Value t')

Instances

Instances details

Applicative x => Default (DfsSettings x) Source #
Instance details Defined in Morley.Michelson.Typed.Util Methods def :: DfsSettings x #

dfsTraverseInstr :: forall m inp out. Monad m => DfsSettings m -> Instr inp out -> m (Instr inp out) Source #

Traverse a typed instruction in depth-first order.

The dsInstrStep and dsValueStep actions will be applied in bottom-to-top order, i.e. first to the children of a node, then to the node itself.

dfsFoldInstr :: forall x inp out. Monoid x => DfsSettings (Writer x) -> (forall i o. Instr i o -> x) -> Instr inp out -> x Source #

Specialization of dfsTraverseInstr for case when changing the instruction is not required.

dfsModifyInstr :: DfsSettings Identity -> (forall i o. Instr i o -> Instr i o) -> Instr inp out -> Instr inp out Source #

Specialization of dfsTraverseInstr which only modifies given instruction.

analyzeInstrFailure :: Instr i o -> RemFail Instr i o Source #

Check whether instruction fails at each execution path or have at least one non-failing path.

This function assumes that given instruction contains no dead code (contract with dead code cannot be valid Michelson contract) and may behave in unexpected way if such is present. Term "dead code" includes instructions which render into empty Michelson, like Morley extensions. On the other hand, this function does not traverse the whole instruction tree; performs fastest on left-growing combs.

Often we already have information about instruction failure, use this function only in cases when this info is actually unavailable or hard to use.

linearizeLeft :: Instr inp out -> Instr inp out Source #

There are many ways to represent a sequence of more than 2 instructions. E. g. for i1; i2; i3 it can be Seq i1 $ Seq i2 i3 or Seq (Seq i1 i2) i3. This function enforces a particular structure. Specifically, it makes each Seq have a single instruction (i. e. not Seq) in its second argument. This function also erases redundant Nops.

Please note that this function is not recursive, it does not linearize contents of IF and similar instructions.

linearizeLeftDeep :: Instr inp out -> Instr inp out Source #

"Deep" version of linearizeLeft. It recursively linearizes instructions stored in other instructions.

dfsMapValue :: forall t. DfsSettings Identity -> Value t -> Value t Source #

Traverse a value in depth-first order.

dfsTraverseValue :: forall t m. Monad m => DfsSettings m -> Value t -> m (Value t) Source #

Traverse a value in depth-first order.

dfsFoldMapValue :: Monoid x => (forall t'. Value t' -> x) -> Value t -> x Source #

Specialization of dfsMapValue for case when changing the value is not required.

dfsFoldMapValueM :: (Monoid x, Monad m) => (forall t'. Value t' -> m x) -> Value t -> m x Source #

Specialization of dfsMapValue for case when changing the value is not required.

isStringValue :: Value t -> Maybe MText Source #

If value is a string, return the stored string.

isBytesValue :: Value t -> Maybe ByteString Source #

If value is a bytestring, return the stored bytestring.

allAtomicValues :: forall t a. (forall t'. Value t' -> Maybe a) -> Value t -> [a] Source #

Takes a selector which checks whether a value can be converted to something. Recursively applies it to all values. Collects extracted values in a list.

splitPushableStorage :: StorageScope t => Value t -> PushableStorageSplit s t Source #

Splits the given storage Value into a PushableStorageSplit.

This is based off the fact that the only storages that cannot be directly PUSHed are the ones that contain BigMaps and tickets. See difference between StorageScope and ConstantScope.

So what we do here is to create a Value as small as possible with all the big_maps in it (if any) and an Instr that can use it to rebuild the original storage Value.

Note: This is done this way to avoid using EMPTY_BIG_MAP instructions, see PushableStorageSplit for motivation.

isMichelsonInstr :: Instr i o -> Bool Source #

Whether this instruction is a real Michelson instruction.

Only the root is in question, children in the instruction tree are not accounted for.

>>> isMichelsonInstr (Seq Nop Nop)
True

>>> isMichelsonInstr (Ext $ COMMENT_ITEM "comment")
False

This function is helpful e.g. in debugger.

instrAnns :: Instr i o -> Maybe SomeAnns Source #

Get annotations from a typed Instr. This doesn't recurse, use with dfsFoldInstr to collect all annotations in a tree/sequence.

class IsoValuesStack (ts :: [Type]) where Source #

Isomorphism between Michelson stack and its Haskell reflection.

Methods

toValStack :: Rec Identity ts -> Rec Value (ToTs ts) Source #

fromValStack :: Rec Value (ToTs ts) -> Rec Identity ts Source #

Instances

Instances details

IsoValuesStack ('[] :: [Type]) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods toValStack :: Rec Identity '[] -> Rec Value (ToTs '[]) Source # fromValStack :: Rec Value (ToTs '[]) -> Rec Identity '[] Source #
(IsoValue t, IsoValuesStack st) => IsoValuesStack (t ': st) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods toValStack :: Rec Identity (t ': st) -> Rec Value (ToTs (t ': st)) Source # fromValStack :: Rec Value (ToTs (t ': st)) -> Rec Identity (t ': st) Source #

type family ToTs' t where ... Source #

Overloaded version of ToTs to work on Haskell and T stacks.

Equations

ToTs' (t :: [T]) = t
ToTs' (a :: [Type]) = ToTs a

type family ToTs (ts :: [Type]) :: [T] where ... Source #

Type function to convert a Haskell stack type to T-based one.

Equations

ToTs '[] = '[]
ToTs (x ': xs) = ToT x ': ToTs xs

type GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t)) Source #

Whether Michelson representation of the type is derived via Generics.

class ToBigMap m where Source #

Associated Types

type ToBigMapKey m Source #

type ToBigMapValue m Source #

Methods

mkBigMap :: m -> BigMap (ToBigMapKey m) (ToBigMapValue m) Source #

Instances

Instances details

Ord k => ToBigMap (NonEmpty (k, v)) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToBigMapKey (NonEmpty (k, v)) Source # type ToBigMapValue (NonEmpty (k, v)) Source # Methods mkBigMap :: NonEmpty (k, v) -> BigMap (ToBigMapKey (NonEmpty (k, v))) (ToBigMapValue (NonEmpty (k, v))) Source #
Ord k => ToBigMap [(k, v)] Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToBigMapKey [(k, v)] Source # type ToBigMapValue [(k, v)] Source # Methods mkBigMap :: [(k, v)] -> BigMap (ToBigMapKey [(k, v)]) (ToBigMapValue [(k, v)]) Source #
ToBigMap (Map k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToBigMapKey (Map k v) Source # type ToBigMapValue (Map k v) Source # Methods mkBigMap :: Map k v -> BigMap (ToBigMapKey (Map k v)) (ToBigMapValue (Map k v)) Source #
Ord k => ToBigMap (SizedList' n (k, v)) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToBigMapKey (SizedList' n (k, v)) Source # type ToBigMapValue (SizedList' n (k, v)) Source # Methods mkBigMap :: SizedList' n (k, v) -> BigMap (ToBigMapKey (SizedList' n (k, v))) (ToBigMapValue (SizedList' n (k, v))) Source #

data BigMap k v Source #

Instances

Instances details

Foldable (BigMap k) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods fold :: Monoid m => BigMap k m -> m # foldMap :: Monoid m => (a -> m) -> BigMap k a -> m # foldMap' :: Monoid m => (a -> m) -> BigMap k a -> m # foldr :: (a -> b -> b) -> b -> BigMap k a -> b # foldr' :: (a -> b -> b) -> b -> BigMap k a -> b # foldl :: (b -> a -> b) -> b -> BigMap k a -> b # foldl' :: (b -> a -> b) -> b -> BigMap k a -> b # foldr1 :: (a -> a -> a) -> BigMap k a -> a # foldl1 :: (a -> a -> a) -> BigMap k a -> a # toList :: BigMap k a -> [a] # null :: BigMap k a -> Bool # length :: BigMap k a -> Int # elem :: Eq a => a -> BigMap k a -> Bool # maximum :: Ord a => BigMap k a -> a # minimum :: Ord a => BigMap k a -> a # sum :: Num a => BigMap k a -> a # product :: Num a => BigMap k a -> a #
(Data k, Data v, Ord k) => Data (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BigMap k v -> c (BigMap k v) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BigMap k v) # toConstr :: BigMap k v -> Constr # dataTypeOf :: BigMap k v -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BigMap k v)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BigMap k v)) # gmapT :: (forall b. Data b => b -> b) -> BigMap k v -> BigMap k v # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BigMap k v -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BigMap k v -> r # gmapQ :: (forall d. Data d => d -> u) -> BigMap k v -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BigMap k v -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BigMap k v -> m (BigMap k v) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMap k v -> m (BigMap k v) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMap k v -> m (BigMap k v) #
Ord k => Semigroup (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (<>) :: BigMap k v -> BigMap k v -> BigMap k v # sconcat :: NonEmpty (BigMap k v) -> BigMap k v # stimes :: Integral b => b -> BigMap k v -> BigMap k v #
Ord k => IsList (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Item (BigMap k v) # Methods fromList :: [Item (BigMap k v)] -> BigMap k v # fromListN :: Int -> [Item (BigMap k v)] -> BigMap k v # toList :: BigMap k v -> [Item (BigMap k v)] #
Generic (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Rep (BigMap k v) :: Type -> Type # Methods from :: BigMap k v -> Rep (BigMap k v) x # to :: Rep (BigMap k v) x -> BigMap k v #
(Show k, Show v) => Show (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> BigMap k v -> ShowS # show :: BigMap k v -> String # showList :: [BigMap k v] -> ShowS #
Default (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods def :: BigMap k v #
(Ord k, Buildable k, Buildable v) => Buildable (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods build :: BigMap k v -> Builder #
Ord k => At (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods at :: Index (BigMap k v) -> Lens' (BigMap k v) (Maybe (IxValue (BigMap k v))) #
Ord k => Ixed (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods ix :: Index (BigMap k v) -> Traversal' (BigMap k v) (IxValue (BigMap k v)) #
HasRPCRepr (BigMap k v) Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (BigMap k v) Source #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (BigMap k v) :: FieldDescriptions Source # Methods typeDocName :: Proxy (BigMap k v) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (BigMap k v) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (BigMap k v) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v) Source #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v, HasNoBigMapToT v, HasNoOpToT v) => IsoValue (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMap k v) :: T Source # Methods toVal :: BigMap k v -> Value (ToT (BigMap k v)) Source # fromVal :: Value (ToT (BigMap k v)) -> BigMap k v Source #
Container (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Element (BigMap k v) # Methods toList :: BigMap k v -> [Element (BigMap k v)] # null :: BigMap k v -> Bool # foldr :: (Element (BigMap k v) -> b -> b) -> b -> BigMap k v -> b # foldl :: (b -> Element (BigMap k v) -> b) -> b -> BigMap k v -> b # foldl' :: (b -> Element (BigMap k v) -> b) -> b -> BigMap k v -> b # length :: BigMap k v -> Int # elem :: Element (BigMap k v) -> BigMap k v -> Bool # foldMap :: Monoid m => (Element (BigMap k v) -> m) -> BigMap k v -> m # fold :: BigMap k v -> Element (BigMap k v) # foldr' :: (Element (BigMap k v) -> b -> b) -> b -> BigMap k v -> b # notElem :: Element (BigMap k v) -> BigMap k v -> Bool # all :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Bool # any :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Bool # and :: BigMap k v -> Bool # or :: BigMap k v -> Bool # find :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Maybe (Element (BigMap k v)) # safeHead :: BigMap k v -> Maybe (Element (BigMap k v)) # safeMaximum :: BigMap k v -> Maybe (Element (BigMap k v)) # safeMinimum :: BigMap k v -> Maybe (Element (BigMap k v)) # safeFoldr1 :: (Element (BigMap k v) -> Element (BigMap k v) -> Element (BigMap k v)) -> BigMap k v -> Maybe (Element (BigMap k v)) # safeFoldl1 :: (Element (BigMap k v) -> Element (BigMap k v) -> Element (BigMap k v)) -> BigMap k v -> Maybe (Element (BigMap k v)) #
One (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type OneItem (BigMap k v) # Methods one :: OneItem (BigMap k v) -> BigMap k v #
type Item (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Item (BigMap k v) = Item (Map k v)
type Rep (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Rep (BigMap k v) = D1 ('MetaData "BigMap" "Morley.Michelson.Typed.Haskell.Value" "morley-1.19.1-inplace" 'False) (C1 ('MetaCons "BigMap" 'PrefixI 'True) (S1 ('MetaSel ('Just "bmId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe (BigMapId k v))) :*: S1 ('MetaSel ('Just "bmMap") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Map k v))))
type Index (BigMap k _1) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Index (BigMap k _1) = k
type IxValue (BigMap _1 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type IxValue (BigMap _1 v) = v
type AsRPC (BigMap k v) Source #
Instance details Defined in Morley.AsRPC type AsRPC (BigMap k v) = BigMapId k v
type TypeDocFieldDescriptions (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (BigMap k v) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (BigMap k v) = 'TBigMap (ToT k) (ToT v)
type Element (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Element (BigMap k v) = ElementDefault (BigMap k v)
type OneItem (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type OneItem (BigMap k v) = OneItem (Map k v)

newtype BigMapId k v Source #

Phantom type that represents the ID of a big_map with keys of type k and values of type v.

Constructors

BigMapId
Fields unBigMapId :: Natural

Instances

Instances details

(Typeable k2, Typeable v, Typeable k1, Typeable k3) => Data (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BigMapId k2 v -> c (BigMapId k2 v) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BigMapId k2 v) # toConstr :: BigMapId k2 v -> Constr # dataTypeOf :: BigMapId k2 v -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BigMapId k2 v)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BigMapId k2 v)) # gmapT :: (forall b. Data b => b -> b) -> BigMapId k2 v -> BigMapId k2 v # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BigMapId k2 v -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BigMapId k2 v -> r # gmapQ :: (forall d. Data d => d -> u) -> BigMapId k2 v -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BigMapId k2 v -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BigMapId k2 v -> m (BigMapId k2 v) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMapId k2 v -> m (BigMapId k2 v) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMapId k2 v -> m (BigMapId k2 v) #
Num (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (+) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # (-) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # (*) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # negate :: BigMapId k2 v -> BigMapId k2 v # abs :: BigMapId k2 v -> BigMapId k2 v # signum :: BigMapId k2 v -> BigMapId k2 v # fromInteger :: Integer -> BigMapId k2 v #
Show (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> BigMapId k2 v -> ShowS # show :: BigMapId k2 v -> String # showList :: [BigMapId k2 v] -> ShowS #
Buildable (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods build :: BigMapId k2 v -> Builder #
IsoValue (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMapId k2 v) :: T Source # Methods toVal :: BigMapId k2 v -> Value (ToT (BigMapId k2 v)) Source # fromVal :: Value (ToT (BigMapId k2 v)) -> BigMapId k2 v Source #
type ToT (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (BigMapId k2 v) = ToT Natural

data Ticket (arg :: Type) Source #

Ticket type.

Constructors

Ticket
Fields tTicketer :: Address tData :: arg tAmount :: Natural

Instances

Instances details

Show arg => Show (Ticket arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> Ticket arg -> ShowS # show :: Ticket arg -> String # showList :: [Ticket arg] -> ShowS #
Eq arg => Eq (Ticket arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: Ticket arg -> Ticket arg -> Bool # (/=) :: Ticket arg -> Ticket arg -> Bool #
PolyTypeHasDocC '[a] => TypeHasDoc (Ticket a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Ticket a) :: FieldDescriptions Source # Methods typeDocName :: Proxy (Ticket a) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (Ticket a) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (Ticket a) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (Ticket a) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (Ticket a) Source #
(Comparable (ToT a), IsoValue a) => IsoValue (Ticket a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Ticket a) :: T Source # Methods toVal :: Ticket a -> Value (ToT (Ticket a)) Source # fromVal :: Value (ToT (Ticket a)) -> Ticket a Source #
type TypeDocFieldDescriptions (Ticket a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Ticket a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Ticket a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Ticket a) = 'TTicket (ToT a)

data ContractRef (arg :: Type) Source #

Since Contract name is used to designate contract code, lets call analogy of TContract type as follows.

Note that type argument always designates an argument of entrypoint. If a contract has explicit default entrypoint (and no root entrypoint), ContractRef referring to it can never have the entire parameter as its type argument.

Constructors

ContractRef
Fields crAddress :: Address crEntrypoint :: SomeEntrypointCall arg

Instances

Instances details

Show (ContractRef arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> ContractRef arg -> ShowS # show :: ContractRef arg -> String # showList :: [ContractRef arg] -> ShowS #
IsoValue (ContractRef arg) => Buildable (ContractRef arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods build :: ContractRef arg -> Builder #
Eq (ContractRef arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: ContractRef arg -> ContractRef arg -> Bool # (/=) :: ContractRef arg -> ContractRef arg -> Bool #
HasRPCRepr (ContractRef arg) Source #
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (ContractRef arg) Source #
PolyTypeHasDocC '[cp] => TypeHasDoc (ContractRef cp) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (ContractRef cp) :: FieldDescriptions Source # Methods typeDocName :: Proxy (ContractRef cp) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (ContractRef cp) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (ContractRef cp) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp) Source #
(HasNoOpToT arg, HasNoNestedBigMaps (ToT arg), WellTypedToT arg) => IsoValue (ContractRef arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (ContractRef arg) :: T Source # Methods toVal :: ContractRef arg -> Value (ToT (ContractRef arg)) Source # fromVal :: Value (ToT (ContractRef arg)) -> ContractRef arg Source #
type AsRPC (ContractRef arg) Source #
Instance details Defined in Morley.AsRPC type AsRPC (ContractRef arg) = ContractRef arg
type TypeDocFieldDescriptions (ContractRef cp) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (ContractRef cp) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (ContractRef arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (ContractRef arg) = 'TContract (ToT arg)

type HasNoOpToT a = (IsoValue a, HasNoOp (ToT a)) Source #

type WellTypedToT a = (IsoValue a, WellTyped (ToT a)) Source #

type SomeEntrypointCall arg = SomeEntrypointCallT (ToT arg) Source #

type EntrypointCall param arg = EntrypointCallT (ToT param) (ToT arg) Source #

type family ToT' t where ... Source #

Overloaded version of ToT to work on Haskell and T types.

Equations

ToT' (t :: T) = t
ToT' (t :: Type) = ToT t

class WellTypedToT a => IsoValue a where Source #

Isomorphism between Michelson values and plain Haskell types.

Default implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s.

Minimal complete definition

Nothing

Associated Types

type ToT a :: T Source #

Type function that converts a regular Haskell type into a T type.

type ToT a = GValueType (Rep a)

Methods

toVal :: a -> Value (ToT a) Source #

Converts a Haskell structure into Value representation.

default toVal :: (Generic a, GIsoValue (Rep a), ToT a ~ GValueType (Rep a)) => a -> Value (ToT a) Source #

fromVal :: Value (ToT a) -> a Source #

Converts a Value into Haskell type.

default fromVal :: (Generic a, GIsoValue (Rep a), ToT a ~ GValueType (Rep a)) => Value (ToT a) -> a Source #

Instances

Instances details

IsoValue Void Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Void :: T Source # Methods toVal :: Void -> Value (ToT Void) Source # fromVal :: Value (ToT Void) -> Void Source #
IsoValue ByteString Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ByteString :: T Source # Methods toVal :: ByteString -> Value (ToT ByteString) Source # fromVal :: Value (ToT ByteString) -> ByteString Source #
IsoValue MText Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT MText :: T Source # Methods toVal :: MText -> Value (ToT MText) Source # fromVal :: Value (ToT MText) -> MText Source #
IsoValue Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Operation :: T Source # Methods toVal :: Operation -> Value (ToT Operation) Source # fromVal :: Value (ToT Operation) -> Operation Source #
IsoValue EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT EpAddress :: T Source # Methods toVal :: EpAddress -> Value (ToT EpAddress) Source # fromVal :: Value (ToT EpAddress) -> EpAddress Source #
IsoValue MyCompoundType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyCompoundType :: T Source # Methods toVal :: MyCompoundType -> Value (ToT MyCompoundType) Source # fromVal :: Value (ToT MyCompoundType) -> MyCompoundType Source #
IsoValue Address Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Address :: T Source # Methods toVal :: Address -> Value (ToT Address) Source # fromVal :: Value (ToT Address) -> Address Source #
IsoValue ChainId Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ChainId :: T Source # Methods toVal :: ChainId -> Value (ToT ChainId) Source # fromVal :: Value (ToT ChainId) -> ChainId Source #
IsoValue Mutez Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Mutez :: T Source # Methods toVal :: Mutez -> Value (ToT Mutez) Source # fromVal :: Value (ToT Mutez) -> Mutez Source #
IsoValue Timestamp Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Timestamp :: T Source # Methods toVal :: Timestamp -> Value (ToT Timestamp) Source # fromVal :: Value (ToT Timestamp) -> Timestamp Source #
IsoValue KeyHash Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT KeyHash :: T Source # Methods toVal :: KeyHash -> Value (ToT KeyHash) Source # fromVal :: Value (ToT KeyHash) -> KeyHash Source #
IsoValue PublicKey Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT PublicKey :: T Source # Methods toVal :: PublicKey -> Value (ToT PublicKey) Source # fromVal :: Value (ToT PublicKey) -> PublicKey Source #
IsoValue Signature Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Signature :: T Source # Methods toVal :: Signature -> Value (ToT Signature) Source # fromVal :: Value (ToT Signature) -> Signature Source #
IsoValue Bls12381Fr Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381Fr :: T Source # Methods toVal :: Bls12381Fr -> Value (ToT Bls12381Fr) Source # fromVal :: Value (ToT Bls12381Fr) -> Bls12381Fr Source #
IsoValue Bls12381G1 Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381G1 :: T Source # Methods toVal :: Bls12381G1 -> Value (ToT Bls12381G1) Source # fromVal :: Value (ToT Bls12381G1) -> Bls12381G1 Source #
IsoValue Bls12381G2 Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381G2 :: T Source # Methods toVal :: Bls12381G2 -> Value (ToT Bls12381G2) Source # fromVal :: Value (ToT Bls12381G2) -> Bls12381G2 Source #
IsoValue Chest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Chest :: T Source # Methods toVal :: Chest -> Value (ToT Chest) Source # fromVal :: Value (ToT Chest) -> Chest Source #
IsoValue ChestKey Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ChestKey :: T Source # Methods toVal :: ChestKey -> Value (ToT ChestKey) Source # fromVal :: Value (ToT ChestKey) -> ChestKey Source #
(Bottom, DoNotUseTextError :: Constraint) => IsoValue Text Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Text :: T Source # Methods toVal :: Text -> Value (ToT Text) Source # fromVal :: Value (ToT Text) -> Text Source #
IsoValue Integer Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Integer :: T Source # Methods toVal :: Integer -> Value (ToT Integer) Source # fromVal :: Value (ToT Integer) -> Integer Source #
IsoValue Natural Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Natural :: T Source # Methods toVal :: Natural -> Value (ToT Natural) Source # fromVal :: Value (ToT Natural) -> Natural Source #
IsoValue () Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT () :: T Source # Methods toVal :: () -> Value (ToT ()) Source # fromVal :: Value (ToT ()) -> () Source #
IsoValue Bool Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bool :: T Source # Methods toVal :: Bool -> Value (ToT Bool) Source # fromVal :: Value (ToT Bool) -> Bool Source #
IsoValue a => IsoValue (Identity a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Identity a) :: T Source # Methods toVal :: Identity a -> Value (ToT (Identity a)) Source # fromVal :: Value (ToT (Identity a)) -> Identity a Source #
(Comparable (ToT c), Ord c, IsoValue c) => IsoValue (Set c) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Set c) :: T Source # Methods toVal :: Set c -> Value (ToT (Set c)) Source # fromVal :: Value (ToT (Set c)) -> Set c Source #
WellTyped t => IsoValue (Value t) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Value t) :: T Source # Methods toVal :: Value t -> Value (ToT (Value t)) Source # fromVal :: Value (ToT (Value t)) -> Value t Source #
(HasNoOpToT arg, HasNoNestedBigMaps (ToT arg), WellTypedToT arg) => IsoValue (ContractRef arg) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (ContractRef arg) :: T Source # Methods toVal :: ContractRef arg -> Value (ToT (ContractRef arg)) Source # fromVal :: Value (ToT (ContractRef arg)) -> ContractRef arg Source #
(Comparable (ToT a), IsoValue a) => IsoValue (Ticket a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Ticket a) :: T Source # Methods toVal :: Ticket a -> Value (ToT (Ticket a)) Source # fromVal :: Value (ToT (Ticket a)) -> Ticket a Source #
IsoValue a => IsoValue (Maybe a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Maybe a) :: T Source # Methods toVal :: Maybe a -> Value (ToT (Maybe a)) Source # fromVal :: Value (ToT (Maybe a)) -> Maybe a Source #
IsoValue a => IsoValue [a] Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT [a] :: T Source # Methods toVal :: [a] -> Value (ToT [a]) Source # fromVal :: Value (ToT [a]) -> [a] Source #
(IsoValue l, IsoValue r) => IsoValue (Either l r) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Either l r) :: T Source # Methods toVal :: Either l r -> Value (ToT (Either l r)) Source # fromVal :: Value (ToT (Either l r)) -> Either l r Source #
IsoValue (Fixed p) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Fixed p) :: T Source # Methods toVal :: Fixed p -> Value (ToT (Fixed p)) Source # fromVal :: Value (ToT (Fixed p)) -> Fixed p Source #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v) => IsoValue (Map k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Map k v) :: T Source # Methods toVal :: Map k v -> Value (ToT (Map k v)) Source # fromVal :: Value (ToT (Map k v)) -> Map k v Source #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v, HasNoBigMapToT v, HasNoOpToT v) => IsoValue (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMap k v) :: T Source # Methods toVal :: BigMap k v -> Value (ToT (BigMap k v)) Source # fromVal :: Value (ToT (BigMap k v)) -> BigMap k v Source #
(IsoValue a, IsoValue b) => IsoValue (a, b) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b) :: T Source # Methods toVal :: (a, b) -> Value (ToT (a, b)) Source # fromVal :: Value (ToT (a, b)) -> (a, b) Source #
IsoValue a => IsoValue (NamedF Identity a name) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (NamedF Identity a name) :: T Source # Methods toVal :: NamedF Identity a name -> Value (ToT (NamedF Identity a name)) Source # fromVal :: Value (ToT (NamedF Identity a name)) -> NamedF Identity a name Source #
IsoValue a => IsoValue (NamedF Maybe a name) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (NamedF Maybe a name) :: T Source # Methods toVal :: NamedF Maybe a name -> Value (ToT (NamedF Maybe a name)) Source # fromVal :: Value (ToT (NamedF Maybe a name)) -> NamedF Maybe a name Source #
(IsoValue a, IsoValue b, IsoValue c) => IsoValue (a, b, c) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c) :: T Source # Methods toVal :: (a, b, c) -> Value (ToT (a, b, c)) Source # fromVal :: Value (ToT (a, b, c)) -> (a, b, c) Source #
IsoValue (BigMapId k2 v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMapId k2 v) :: T Source # Methods toVal :: BigMapId k2 v -> Value (ToT (BigMapId k2 v)) Source # fromVal :: Value (ToT (BigMapId k2 v)) -> BigMapId k2 v Source #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d) => IsoValue (a, b, c, d) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d) :: T Source # Methods toVal :: (a, b, c, d) -> Value (ToT (a, b, c, d)) Source # fromVal :: Value (ToT (a, b, c, d)) -> (a, b, c, d) Source #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e) => IsoValue (a, b, c, d, e) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d, e) :: T Source # Methods toVal :: (a, b, c, d, e) -> Value (ToT (a, b, c, d, e)) Source # fromVal :: Value (ToT (a, b, c, d, e)) -> (a, b, c, d, e) Source #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e, IsoValue f) => IsoValue (a, b, c, d, e, f) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d, e, f) :: T Source # Methods toVal :: (a, b, c, d, e, f) -> Value (ToT (a, b, c, d, e, f)) Source # fromVal :: Value (ToT (a, b, c, d, e, f)) -> (a, b, c, d, e, f) Source #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e, IsoValue f, IsoValue g) => IsoValue (a, b, c, d, e, f, g) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d, e, f, g) :: T Source # Methods toVal :: (a, b, c, d, e, f, g) -> Value (ToT (a, b, c, d, e, f, g)) Source # fromVal :: Value (ToT (a, b, c, d, e, f, g)) -> (a, b, c, d, e, f, g) Source #

type KnownIsoT a = (IsoValue a, SingI (ToT a)) Source #

isoValue :: (IsoValue a, IsoValue b) => Iso (Value (ToT a)) (Value (ToT b)) a b Source #

An optic witnessing the isomorphism between a michelson type and a haskell type.

coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b Source #

Replace type argument of ContractRef with isomorphic one.

contractRefToAddr :: ContractRef cp -> EpAddress Source #

totsKnownLemma :: forall s. KnownList s :- KnownList (ToTs s) Source #

totsAppendLemma :: forall a b. KnownList a => Dict (ToTs (a ++ b) ~ (ToTs a ++ ToTs b)) Source #

type InstrUnwrapC dt name = (GenericIsoValue dt, GInstrUnwrap (Rep dt) (LnrBranch (GetNamed name dt)) (CtorOnlyField name dt)) Source #

type family GCaseBranchInput ctor x :: CaseClauseParam Source #

Instances

Instances details

type GCaseBranchInput ctor (U1 :: Type -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (U1 :: Type -> Type) = 'CaseClauseParam ctor 'NoFields
type GCaseBranchInput ctor (Rec0 a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (Rec0 a) = 'CaseClauseParam ctor ('OneField a)
type GCaseBranchInput ctor (x :*: y) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (x :*: y) = 'CaseClauseParam ctor 'NoFields
type GCaseBranchInput ctor (S1 i x) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (S1 i x) = GCaseBranchInput ctor x

type family GCaseBranchInput ctor x :: CaseClauseParam Source #

Instances

Instances details

type GCaseBranchInput ctor (U1 :: Type -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (U1 :: Type -> Type) = 'CaseClauseParam ctor 'NoFields
type GCaseBranchInput ctor (Rec0 a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (Rec0 a) = 'CaseClauseParam ctor ('OneField a)
type GCaseBranchInput ctor (x :*: y) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (x :*: y) = 'CaseClauseParam ctor 'NoFields
type GCaseBranchInput ctor (S1 i x) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseBranchInput ctor (S1 i x) = GCaseBranchInput ctor x

type family GCaseClauses x rest :: [CaseClauseParam] Source #

Instances

Instances details

type GCaseClauses (V1 :: Type -> Type) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (V1 :: Type -> Type) rest = rest
type GCaseClauses (x :+: y) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (x :+: y) rest = GCaseClauses x (GCaseClauses y rest)
type GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest = GCaseBranchInput ctor x ': rest
type GCaseClauses (D1 i x) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (D1 i x) rest = GCaseClauses x rest

type family GCaseClauses x rest :: [CaseClauseParam] Source #

Instances

Instances details

type GCaseClauses (V1 :: Type -> Type) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (V1 :: Type -> Type) rest = rest
type GCaseClauses (x :+: y) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (x :+: y) rest = GCaseClauses x (GCaseClauses y rest)
type GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest = GCaseBranchInput ctor x ': rest
type GCaseClauses (D1 i x) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type GCaseClauses (D1 i x) rest = GCaseClauses x rest

type CaseClauses a = GCaseClauses (Rep a) '[] Source #

List of CaseClauseParams required to pattern match on the given type.

data CaseClause (inp :: [T]) (out :: [T]) (param :: CaseClauseParam) where Source #

Type information about single case clause.

Constructors

CaseClause :: RemFail Instr (AppendCtorField x inp) out -> CaseClause inp out ('CaseClauseParam ctor x)

data CaseClauseParam Source #

In what different case branches differ - related constructor name and input stack type which the branch starts with.

Constructors

CaseClauseParam Symbol CtorField

type InstrCaseC dt = (GenericIsoValue dt, GInstrCase (Rep dt) '[]) Source #

data MyCompoundType Source #

Instances

Instances details

Generic MyCompoundType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type Rep MyCompoundType :: Type -> Type # Methods from :: MyCompoundType -> Rep MyCompoundType x # to :: Rep MyCompoundType x -> MyCompoundType #
IsoValue MyCompoundType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyCompoundType :: T Source # Methods toVal :: MyCompoundType -> Value (ToT MyCompoundType) Source # fromVal :: Value (ToT MyCompoundType) -> MyCompoundType Source #
type Rep MyCompoundType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type Rep MyCompoundType
type ToT MyCompoundType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type ToT MyCompoundType = GValueType (Rep MyCompoundType)

type InstrWrapOneC dt name = (InstrWrapC dt name, GetCtorField dt name ~ 'OneField (CtorOnlyField name dt)) Source #

type InstrWrapC dt name = (GenericIsoValue dt, GInstrWrap (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt))) Source #

type CtorOnlyField name dt = RequireOneField name (GetCtorField dt name) Source #

Expect referred constructor to have only one field (otherwise compile error is raised) and extract its type.

type CtorHasOnlyField ctor dt f = GetCtorField dt ctor ~ 'OneField f Source #

Expect referred constructor to have only one field (in form of constraint) and extract its type.

type GetCtorField dt ctor = LnrFieldType (GetNamed ctor dt) Source #

Get type of constructor fields (one or zero) referred by given datatype and name.

type family IsPrimitiveValue (x :: Type) :: Bool where ... Source #

Whether given type represents an atomic Michelson value.

Equations

IsPrimitiveValue (Maybe _) = 'True
IsPrimitiveValue (NamedF _ _ _) = 'True
IsPrimitiveValue Integer = 'True
IsPrimitiveValue Natural = 'True
IsPrimitiveValue Text = 'True
IsPrimitiveValue MText = 'True
IsPrimitiveValue Bool = 'True
IsPrimitiveValue ByteString = 'True
IsPrimitiveValue Mutez = 'True
IsPrimitiveValue Address = 'True
IsPrimitiveValue EpAddress = 'True
IsPrimitiveValue KeyHash = 'True
IsPrimitiveValue Timestamp = 'True
IsPrimitiveValue PublicKey = 'True
IsPrimitiveValue Signature = 'True
IsPrimitiveValue (ContractRef _) = 'True
IsPrimitiveValue (BigMap _ _) = 'True
IsPrimitiveValue (Map _ _) = 'True
IsPrimitiveValue (Set _) = 'True
IsPrimitiveValue [_] = 'True
IsPrimitiveValue (Operation' _) = 'True
IsPrimitiveValue ChainId = 'True
IsPrimitiveValue _ = 'False

type AppendCtorFieldAxiom (cf :: CtorField) (st :: [Type]) = ToTs (AppendCtorField cf st) ~ AppendCtorField cf (ToTs st) Source #

To use AppendCtorField not only here for T-based stacks, but also later in Lorentz with Type-based stacks we need the following property.

type family AppendCtorField cf l where ... Source #

Push field to stack, if any.

Equations

AppendCtorField ('OneField t) (l :: [T]) = ToT t ': l
AppendCtorField ('OneField t) (l :: [Type]) = t ': l
AppendCtorField 'NoFields (l :: [T]) = l
AppendCtorField 'NoFields (l :: [Type]) = l

type family ExtractCtorField (cf :: CtorField) where ... Source #

Get something as field of the given constructor.

Equations

ExtractCtorField ('OneField t) = t
ExtractCtorField 'NoFields = ()

data CtorField Source #

We support only two scenarious - constructor with one field and without fields. Nonetheless, it's not that sad since for sum types we can't even assign names to fields if there are many (the style guide prohibits partial records).

Constructors

OneField Type
NoFields

appendCtorFieldAxiom :: (AppendCtorFieldAxiom ('OneField Word) '[Int], AppendCtorFieldAxiom 'NoFields '[Int]) => Dict (AppendCtorFieldAxiom cf st) Source #

Proof of AppendCtorFieldAxiom.

instrWrap :: forall dt name st. InstrWrapC dt name => Label name -> Instr (AppendCtorField (GetCtorField dt name) st) (ToT dt ': st) Source #

Wrap given element into a constructor with the given name.

Mentioned constructor must have only one field.

Since labels interpretable by OverloadedLabels extension cannot start with capital latter, prepend constructor name with letter "c" (see examples below).

instrWrapOne :: forall dt name st. InstrWrapOneC dt name => Label name -> Instr (ToT (CtorOnlyField name dt) ': st) (ToT dt ': st) Source #

Like instrWrap but only works for contructors with a single field. Results in a type error if a constructor with no field is used instead.

hsWrap :: forall dt name. InstrWrapC dt name => Label name -> ExtractCtorField (GetCtorField dt name) -> dt Source #

Wrap a haskell value into a constructor with the given name.

This is symmetric to instrWrap.

instrCase :: forall dt out inp. InstrCaseC dt => Rec (CaseClause inp out) (CaseClauses dt) -> RemFail Instr (ToT dt ': inp) out Source #

Pattern-match on the given datatype.

(//->) :: Label ("c" `AppendSymbol` ctor) -> RemFail Instr (AppendCtorField x inp) out -> CaseClause inp out ('CaseClauseParam ctor x) infixr 8 Source #

Lift an instruction to case clause.

You should write out constructor name corresponding to the clause explicitly. Prefix constructor name with "c" letter, otherwise your label will not be recognized by Haskell parser. Passing constructor name can be circumvented but doing so is not recomended as mentioning contructor name improves readability and allows avoiding some mistakes.

unsafeInstrUnwrap :: forall dt name st. InstrUnwrapC dt name => Label name -> Instr (ToT dt ': st) (ToT (CtorOnlyField name dt) ': st) Source #

Unwrap a constructor with the given name.

Rules which apply to instrWrap function work here as well. Although, unlike instrWrap, this function does not work for nullary constructors.

hsUnwrap :: forall dt name. InstrUnwrapC dt name => Label name -> dt -> Maybe (CtorOnlyField name dt) Source #

Try to unwrap a constructor with the given name.

type InstrDeconstructC dt st = (GenericIsoValue dt, GInstrDeconstruct (Rep dt) '[] st) Source #

Constraint for instrConstruct.

type family GFieldTypes x rest :: [Type] Source #

Instances

Instances details

type GFieldTypes (U1 :: Type -> Type) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (U1 :: Type -> Type) rest = rest
type GFieldTypes (V1 :: Type -> Type) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (V1 :: Type -> Type) rest = '[] :: [Type]
type GFieldTypes (Rec0 a) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (Rec0 a) rest = a ': rest
type GFieldTypes (x :*: y) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (x :*: y) rest = GFieldTypes x (GFieldTypes y rest)
type GFieldTypes (x :+: y) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (x :+: y) rest = '[] :: [Type]
type GFieldTypes (M1 t i x) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (M1 t i x) rest = GFieldTypes x rest

type family GFieldTypes x rest :: [Type] Source #

Instances

Instances details

type GFieldTypes (U1 :: Type -> Type) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (U1 :: Type -> Type) rest = rest
type GFieldTypes (V1 :: Type -> Type) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (V1 :: Type -> Type) rest = '[] :: [Type]
type GFieldTypes (Rec0 a) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (Rec0 a) rest = a ': rest
type GFieldTypes (x :*: y) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (x :*: y) rest = GFieldTypes x (GFieldTypes y rest)
type GFieldTypes (x :+: y) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (x :+: y) rest = '[] :: [Type]
type GFieldTypes (M1 t i x) rest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type GFieldTypes (M1 t i x) rest = GFieldTypes x rest

type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep dt) '[]) Source #

Constraint for instrConstruct and gInstrConstructStack.

type ConstructorFieldNames dt = GFieldNames (Rep dt) Source #

Names of all fields in a datatype.

type ConstructorFieldTypes dt = GFieldTypes (Rep dt) '[] Source #

Types of all fields in a datatype.

class ToTs xs ~ ToTs ys => CastFieldConstructors xs ys where Source #

Ability to pass list of fields with the same ToTs. It may be useful if you don't want to work with NamedF in ConstructorFieldTypes.

Methods

castFieldConstructorsImpl :: Rec (FieldConstructor st) xs -> Rec (FieldConstructor st) ys Source #

Instances

Instances details

CastFieldConstructors ('[] :: [Type]) ('[] :: [Type]) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product Methods castFieldConstructorsImpl :: forall {k} (st :: [k]). Rec (FieldConstructor st) '[] -> Rec (FieldConstructor st) '[] Source #
(CastFieldConstructors xs ys, ToTs xs ~ ToTs ys, ToT x ~ ToT y) => CastFieldConstructors (x ': xs) (y ': ys) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product Methods castFieldConstructorsImpl :: forall {k} (st :: [k]). Rec (FieldConstructor st) (x ': xs) -> Rec (FieldConstructor st) (y ': ys) Source #

newtype FieldConstructor (st :: [k]) (field :: Type) Source #

Way to construct one of the fields in a complex datatype.

Constructors

FieldConstructor (Instr (ToTs' st) (ToT field ': ToTs' st))

type InstrSetFieldC dt name = (GenericIsoValue dt, GInstrSetField name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt))) Source #

Constraint for instrSetField.

type InstrGetFieldC dt name = (GenericIsoValue dt, GInstrGet name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt))) Source #

Constraint for instrGetField.

type GetFieldType dt name = LnrFieldType (GetNamed name dt) Source #

Get type of field by datatype it is contained in and field name.

type family GLookupNamed (name :: Symbol) (x :: Type -> Type) :: Maybe LookupNamedResult where ... Source #

Equations

GLookupNamed name (D1 _ x) = GLookupNamed name x
GLookupNamed name (C1 _ x) = GLookupNamed name x
GLookupNamed name (S1 ('MetaSel ('Just recName) _ _ _) (Rec0 a)) = If (name == recName) ('Just $ 'LNR a '[]) 'Nothing
GLookupNamed name (S1 _ (Rec0 (NamedF f a fieldName))) = If (name == fieldName) ('Just $ 'LNR (NamedInner (NamedF f a fieldName)) '[]) 'Nothing
GLookupNamed _ (S1 _ _) = 'Nothing
GLookupNamed name (x :*: y) = LNMergeFound name (GLookupNamed name x) (GLookupNamed name y)
GLookupNamed name (_ :+: _) = TypeError (('Text "Cannot seek for a field " :<>: 'ShowType name) :<>: 'Text " in sum type")
GLookupNamed _ U1 = 'Nothing
GLookupNamed _ V1 = TypeError ('Text "Cannot access fields of void-like type")

instrToField :: forall dt name st. InstrGetFieldC dt name => Label name -> Instr (ToT dt ': st) (ToT (GetFieldType dt name) ': st) Source #

Make an instruction which accesses given field of the given datatype.

instrGetField :: forall dt name st. (InstrGetFieldC dt name, DupableScope (ToT (GetFieldType dt name))) => Label name -> Instr (ToT dt ': st) (ToT (GetFieldType dt name) ': (ToT dt ': st)) Source #

Make an instruction which copies given field of the given datatype.

This behaves exactly as Seq DUP (instrToField #name), but does not require the entire datatype to be dupable (the field ofc still must be dupable).

If we follow the path from the root to the copied field in the pairs tree, the more nodes contain non-dupable elements in the subtree, the less efficient this function becomes. Assuming that all fields are accessed equally often, the most optimal representation would be to put all dupable elements to one subtree of the root, and all non-dupable elements in the second subtree of the root.

instrGetFieldOpen :: forall dt name res st. InstrGetFieldC dt name => Instr '[ToT (GetFieldType dt name)] '[res, ToT (GetFieldType dt name)] -> Instr '[ToT (GetFieldType dt name)] '[res] -> Label name -> Instr (ToT dt ': st) (res ': (ToT dt ': st)) Source #

"Open" version of instrGetField, meaning that it accepts continuations that accept the copied field. This allows chaining getters without requiring DupableScope on the intermediate fields.

Accepted continuations:

The one that leaves the field on stack (and does a duplication inside). Used when the datatype had an unfortunate placement of non-dupable fields, or the intermediate field contains non-dupable elements, so the duplication cannot occur automatically in between.
The one that consumes the field, used in case we managed to call DUP earlier to make the instruction's implementation smaller, and now we only need to access the field with CAR and CDRs.

Note that only one continuation will be chosen eventually, no contract size overhead is expected in this regard.

instrSetField :: forall dt name st. InstrSetFieldC dt name => Label name -> Instr (ToT (GetFieldType dt name) ': (ToT dt ': st)) (ToT dt ': st) Source #

For given complex type dt and its field fieldTy update the field value.

instrSetFieldOpen :: forall dt name new st. InstrSetFieldC dt name => Instr '[new, ToT (GetFieldType dt name)] '[ToT (GetFieldType dt name)] -> Label name -> Instr (new ': (ToT dt ': st)) (ToT dt ': st) Source #

"Open" version of instrSetField, meaning that it accepts a continuation that describes how to update the field. This allows chaining setters with zero overhead and without requiring DupableScope on the intermediate fields (if we supported only closed setters that work directly with one datatype, we would need to duplicate intermediate fields to chain setters).

instrConstruct :: forall dt st. InstrConstructC dt => Rec (FieldConstructor st) (ConstructorFieldTypes dt) -> Instr st (ToT dt ': st) Source #

For given complex type dt and its field fieldTy update the field value.

instrConstructStack :: forall dt stack st. (InstrConstructC dt, stack ~ ToTs (ConstructorFieldTypes dt)) => Instr (stack ++ st) (ToT dt ': st) Source #

instrDeconstruct :: forall dt stack (st :: [T]). (InstrDeconstructC dt st, stack ~ ToTs (GFieldTypes (Rep dt) '[])) => Instr (ToT dt ': st) (stack ++ st) Source #

For given complex type dt deconstruct it to its field types.

convertParamNotes :: ParamNotes cp -> ParameterType Source #

Convert typed parameter annotations to an untyped ParameterType.

convertContractCode :: forall param store. (SingI param, SingI store) => ContractCode param store -> Contract Source #

Convert typed ContractCode to an untyped Contract.

convertView :: forall arg store ret. View arg store ret -> View Source #

convertSomeView :: SomeView st -> View Source #

convertContract :: Contract param store -> Contract Source #

Convert typed Contract to an untyped Contract.

untypeValue :: HasNoOp t => Value' Instr t -> Value Source #

Convert a typed value to an untyped human-readable representation

untypeValueHashable :: HasNoOp t => Value' Instr t -> Value Source #

Like untypeValueOptimized, but without list notation for pairs.

Created to match octez-client hash data behaviour for typed values.

untypeValueOptimized :: HasNoOp t => Value' Instr t -> Value Source #

Convert a typed value to an untyped optimized representation

untypeDemoteT :: forall (t :: T). SingI t => Ty Source #

Convert a Haskell type-level type tag into an untyped value representation.

This function is intended to be used with TypeApplications.

instrToOpsOptimized :: HasCallStack => Instr inp out -> [ExpandedOp] Source #

Convert Haskell-typed Instr to a list of optimized untyped operations

instrToOps :: HasCallStack => Instr inp out -> [ExpandedOp] Source #

Convert Haskell-typed Instr to a list of human-readable untyped operations

eqInstrExt :: Instr i1 o1 -> Instr i2 o2 -> Bool Source #

Extended equality of Instr - this behaves like (==) but does not require the compared instructions to be of strictly the same type.

sampleTypedValue :: forall t. WellTyped t => Sing t -> Maybe (Value t) Source #

Generate a value used for generating examples in documentation.

Since not for all types it is possible to produce a sensible example, the result is optional. E.g. for operations, never, not proper types like contract operation we return Nothing.

flattenEntrypoints :: HandleImplicitDefaultEp -> ParamNotes t -> Map EpName Ty Source #

Flatten a provided list of notes to a map of its entrypoints and its corresponding utype. Please refer to mkEntrypointsMap in regards to how duplicate entrypoints are handled.

data SomeVBigMap where Source #

Constructors

SomeVBigMap :: forall k v. Value ('TBigMap k v) -> SomeVBigMap

data SomeContractAndStorage where Source #

Represents a typed contract & a storage value of the type expected by the contract.

Constructors

SomeContractAndStorage :: forall cp st. (StorageScope st, ParameterScope cp) => Contract cp st -> Value st -> SomeContractAndStorage

Instances

Instances details

Show SomeContractAndStorage Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods showsPrec :: Int -> SomeContractAndStorage -> ShowS # show :: SomeContractAndStorage -> String # showList :: [SomeContractAndStorage] -> ShowS #

data SomeContract where Source #

Constructors

SomeContract :: Contract cp st -> SomeContract

Instances

Instances details

Show SomeContract Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods showsPrec :: Int -> SomeContract -> ShowS # show :: SomeContract -> String # showList :: [SomeContract] -> ShowS #
NFData SomeContract Source #
Instance details Defined in Morley.Michelson.Typed.Existential Methods rnf :: SomeContract -> () #

data SomeIsoValue where Source #

Hides some Haskell value put in line with Michelson Value.

Constructors

SomeIsoValue :: KnownIsoT a => a -> SomeIsoValue

type SomePackedVal = SomeConstrainedValue PackedValScope Source #

type SomeStorage = SomeConstrainedValue StorageScope Source #

type SomeConstant = SomeConstrainedValue ConstantScope Source #

type SomeValue = SomeConstrainedValue SingI Source #

type SomeConstrainedValue c = Constrained c Value Source #

type LooseSumC dt = (Generic dt, GLooseSum (Rep dt)) Source #

Constraint for toTaggedVal and fromTaggedVal.

data ComposeResult a Source #

Possible outcomes of an attempt to construct a Haskell ADT value from constructor name and relevant data.

Constructors

ComposeOk a	Composed fine.
ComposeCtorNotFound	No constructor with such name.
ComposeFieldTypeMismatch T T	Found required constructor, but type of data does not correspond to provided one.

Instances

Instances details

Functor ComposeResult Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.LooseSum Methods fmap :: (a -> b) -> ComposeResult a -> ComposeResult b # (<$) :: a -> ComposeResult b -> ComposeResult a #
Monoid (ComposeResult a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.LooseSum Methods mempty :: ComposeResult a # mappend :: ComposeResult a -> ComposeResult a -> ComposeResult a # mconcat :: [ComposeResult a] -> ComposeResult a #
Semigroup (ComposeResult a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.LooseSum Methods (<>) :: ComposeResult a -> ComposeResult a -> ComposeResult a # sconcat :: NonEmpty (ComposeResult a) -> ComposeResult a # stimes :: Integral b => b -> ComposeResult a -> ComposeResult a #

toTaggedVal :: LooseSumC dt => dt -> (Text, SomeValue) Source #

Decompose Haskell type into constructor name and data it carries, converting the latter into Michelson Value.

fromTaggedVal :: LooseSumC dt => (Text, SomeValue) -> ComposeResult dt Source #

Inverse to toTaggedVal.

data SomeAnnotatedValue where Source #

Constructors

SomeAnnotatedValue :: forall t. SingI t => Notes t -> Value t -> SomeAnnotatedValue

Instances

Instances details

Show SomeAnnotatedValue Source #
Instance details Defined in Morley.Michelson.Typed.AnnotatedValue Methods showsPrec :: Int -> SomeAnnotatedValue -> ShowS # show :: SomeAnnotatedValue -> String # showList :: [SomeAnnotatedValue] -> ShowS #
Buildable SomeAnnotatedValue Source #
Instance details Defined in Morley.Michelson.Typed.AnnotatedValue Methods build :: SomeAnnotatedValue -> Builder #
Eq SomeAnnotatedValue Source #
Instance details Defined in Morley.Michelson.Typed.AnnotatedValue Methods (==) :: SomeAnnotatedValue -> SomeAnnotatedValue -> Bool # (/=) :: SomeAnnotatedValue -> SomeAnnotatedValue -> Bool #

data AnnotatedValue v Source #

Constructors

AnnotatedValue
Fields avNotes :: Notes (ToT v) avValue :: Value (ToT v)

Instances

Instances details

Show (AnnotatedValue v) Source #
Instance details Defined in Morley.Michelson.Typed.AnnotatedValue Methods showsPrec :: Int -> AnnotatedValue v -> ShowS # show :: AnnotatedValue v -> String # showList :: [AnnotatedValue v] -> ShowS #
Buildable (AnnotatedValue v) Source #
Instance details Defined in Morley.Michelson.Typed.AnnotatedValue Methods build :: AnnotatedValue v -> Builder #
Eq (AnnotatedValue v) Source #
Instance details Defined in Morley.Michelson.Typed.AnnotatedValue Methods (==) :: AnnotatedValue v -> AnnotatedValue v -> Bool # (/=) :: AnnotatedValue v -> AnnotatedValue v -> Bool #

data FieldRep a Source #

Representation of a field with an optional description.

Constructors

FieldRep
Fields frName :: Maybe Text frDescription :: Maybe Text frTypeRep :: a

data ConstructorRep a Source #

Representation of a constructor with an optional description.

Constructors

ConstructorRep
Fields crName :: Text crDescription :: Maybe Text crFields :: [FieldRep a]

type ADTRep a = [ConstructorRep a] Source #

Stands for representation of some Haskell ADT corresponding to Michelson value. Type parameter a is what you put in place of each field of the datatype, e.g. information about field type.

This representation also includes descriptions of constructors and fields.

crDescriptionL :: forall a. Lens' (ConstructorRep a) (Maybe Text) Source #

crFieldsL :: forall a a. Lens (ConstructorRep a) (ConstructorRep a) [FieldRep a] [FieldRep a] Source #

crNameL :: forall a. Lens' (ConstructorRep a) Text Source #

type PolyTypeHasDocC ts = Each '[TypeHasDoc] ts Source #

Constraint, required when deriving TypeHasDoc for polymorphic type with the least possible number of methods defined manually.

class GProductHasDoc (x :: Type -> Type) Source #

Product type traversal for TypeHasDoc.

Minimal complete definition

gProductDocHaskellRep

Instances

Instances details

GProductHasDoc (U1 :: Type -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]
(GProductHasDoc x, GProductHasDoc y) => GProductHasDoc (x :*: y) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]
(TypeHasDoc a, KnownSymbol field) => GProductHasDoc (S1 ('MetaSel ('Just field) _1 _2 _3) (Rec0 a)) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]
TypeHasDoc a => GProductHasDoc (S1 ('MetaSel ('Nothing :: Maybe Symbol) _1 _2 _3) (Rec0 a)) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]

class GTypeHasDoc (x :: Type -> Type) Source #

Generic traversal for automatic deriving of some methods in TypeHasDoc.

Minimal complete definition

gTypeDocHaskellRep

Instances

Instances details

GTypeHasDoc (V1 :: Type -> Type) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc
(GTypeHasDoc x, GTypeHasDoc y) => GTypeHasDoc (x :+: y) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc
(GProductHasDoc x, KnownSymbol ctor) => GTypeHasDoc (C1 ('MetaCons ctor _1 _2) x) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc
GTypeHasDoc x => GTypeHasDoc (D1 ('MetaData _a _b _c 'False) x) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc
GTypeHasDoc x => GTypeHasDoc (D1 ('MetaData _a _b _c 'True) x) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc

class IsHomomorphic a Source #

Require this type to be homomorphic.

Instances

Instances details

IsHomomorphic (a :: k) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc
(TypeError ('Text "Type is not homomorphic: " :<>: 'ShowType (a b)) :: Constraint) => IsHomomorphic (a b :: k2) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc

class HaveCommonTypeCtor a b Source #

Require two types to be built from the same type constructor.

E.g. HaveCommonTypeCtor (Maybe Integer) (Maybe Natural) is defined, while HaveCmmonTypeCtor (Maybe Integer) [Integer] is not.

Instances

Instances details

HaveCommonTypeCtor (a :: k) (a :: k) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc
HaveCommonTypeCtor ac bc => HaveCommonTypeCtor (ac a :: k2) (bc b :: k4) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc

newtype DStorageType Source #

Doc element with description of contract storage type.

Constructors

DStorageType DType

Instances

Instances details

Generic DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type Rep DStorageType :: Type -> Type # Methods from :: DStorageType -> Rep DStorageType x # to :: Rep DStorageType x -> DStorageType #
Eq DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods (==) :: DStorageType -> DStorageType -> Bool # (/=) :: DStorageType -> DStorageType -> Bool #
Ord DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods compare :: DStorageType -> DStorageType -> Ordering # (<) :: DStorageType -> DStorageType -> Bool # (<=) :: DStorageType -> DStorageType -> Bool # (>) :: DStorageType -> DStorageType -> Bool # (>=) :: DStorageType -> DStorageType -> Bool # max :: DStorageType -> DStorageType -> DStorageType # min :: DStorageType -> DStorageType -> DStorageType #
DocItem DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type DocItemPlacement DStorageType :: DocItemPlacementKind Source # type DocItemReferenced DStorageType :: DocItemReferencedKind Source # Methods docItemPos :: Natural Source # docItemSectionName :: Maybe Text Source # docItemSectionDescription :: Maybe Markdown Source # docItemSectionNameStyle :: DocSectionNameStyle Source # docItemRef :: DStorageType -> DocItemRef (DocItemPlacement DStorageType) (DocItemReferenced DStorageType) Source # docItemToMarkdown :: HeaderLevel -> DStorageType -> Markdown Source # docItemToToc :: HeaderLevel -> DStorageType -> Markdown Source # docItemDependencies :: DStorageType -> [SomeDocDefinitionItem] Source # docItemsOrder :: [DStorageType] -> [DStorageType] Source #
type Rep DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type Rep DStorageType = D1 ('MetaData "DStorageType" "Morley.Michelson.Typed.Haskell.Doc" "morley-1.19.1-inplace" 'True) (C1 ('MetaCons "DStorageType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))
type DocItemPlacement DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemPlacement DStorageType = 'DocItemInlined
type DocItemReferenced DStorageType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemReferenced DStorageType = 'True

data DType where Source #

Doc element with description of a type.

Constructors

DType :: TypeHasDoc a => Proxy a -> DType

Instances

Instances details

Buildable DType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods build :: DType -> Builder #
Eq DType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods (==) :: DType -> DType -> Bool # (/=) :: DType -> DType -> Bool #
Ord DType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods compare :: DType -> DType -> Ordering # (<) :: DType -> DType -> Bool # (<=) :: DType -> DType -> Bool # (>) :: DType -> DType -> Bool # (>=) :: DType -> DType -> Bool # max :: DType -> DType -> DType # min :: DType -> DType -> DType #
DocItem DType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type DocItemPlacement DType :: DocItemPlacementKind Source # type DocItemReferenced DType :: DocItemReferencedKind Source # Methods docItemPos :: Natural Source # docItemSectionName :: Maybe Text Source # docItemSectionDescription :: Maybe Markdown Source # docItemSectionNameStyle :: DocSectionNameStyle Source # docItemRef :: DType -> DocItemRef (DocItemPlacement DType) (DocItemReferenced DType) Source # docItemToMarkdown :: HeaderLevel -> DType -> Markdown Source # docItemToToc :: HeaderLevel -> DType -> Markdown Source # docItemDependencies :: DType -> [SomeDocDefinitionItem] Source # docItemsOrder :: [DType] -> [DType] Source #
type DocItemPlacement DType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemPlacement DType = 'DocItemInDefinitions
type DocItemReferenced DType Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemReferenced DType = 'True

data SomeTypeWithDoc where Source #

Data hides some type implementing TypeHasDoc.

Constructors

SomeTypeWithDoc :: TypeHasDoc td => Proxy td -> SomeTypeWithDoc

type TypeDocMichelsonRep a = Proxy a -> (Maybe DocTypeRepLHS, T) Source #

Signature of typeDocMichelsonRep function.

As in TypeDocHaskellRep, set the first element of the pair to Nothing for primitive types, otherwise it stands as some instantiation of a type, and its Michelson representation is given in the second element of the pair.

Examples of rendered representation:

pair int nat - for homomorphic type.
MyError Integer = pair string int - concrete sample for polymorphic type.

type TypeDocHaskellRep a = Proxy a -> FieldDescriptionsV -> Maybe (Maybe DocTypeRepLHS, ADTRep SomeTypeWithDoc) Source #

Signature of typeDocHaskellRep function.

A value of FieldDescriptionsV is provided by the library to make sure that instances won't replace it with an unchecked value.

When value is Just, it contains types which this type is built from.

First element of provided pair may contain name a concrete type which has the same type constructor as a (or just a for homomorphic types), and the second element of the pair - its unfolding in Haskell.

For example, for some newtype MyNewtype = MyNewtype (Integer, Natural) we would not specify the first element in the pair because MyNewtype is already a concrete type, and second element would contain (Integer, Natural). For polymorphic types like newtype MyPolyNewtype a = MyPolyNewtype (Text, a), we want to describe its representation on some example of a, because working with type variables is too non-trivial; so the first element of the pair may be e.g. "MyPolyNewType Integer", and the second one shows that it unfolds to (Text, Integer).

When rendered, values of this type look like:

(Integer, Natural) - for homomorphic type.
MyError Integer = (Text, Integer) - concrete sample for polymorphic type.

class (Typeable a, SingI (TypeDocFieldDescriptions a), FieldDescriptionsValid (TypeDocFieldDescriptions a) a) => TypeHasDoc a where Source #

Description for a Haskell type appearing in documentation.

Minimal complete definition

typeDocMdDescription

Associated Types

type TypeDocFieldDescriptions a :: FieldDescriptions Source #

Description of constructors and fields of a.

See FieldDescriptions documentation for an example of usage.

Descriptions will be checked at compile time to make sure that only existing constructors and fields are referenced.

For that check to work instance Generic a is required whenever TypeDocFieldDescriptions is not empty.

For implementation of the check see FieldDescriptionsValid type family.

type TypeDocFieldDescriptions _ = '[]

Methods

typeDocName :: Proxy a -> Text Source #

Name of type as it appears in definitions section.

Each type must have its own unique name because it will be used in identifier for references.

Default definition derives name from Generics. If it does not fit, consider defining this function manually. (We tried using Data.Data for this, but it produces names including module names which is not do we want).

default typeDocName :: (Generic a, KnownSymbol (GenericTypeName a)) => Proxy a -> Text Source #

typeDocMdDescription :: Markdown Source #

Explanation of a type. Markdown formatting is allowed.

typeDocMdReference :: Proxy a -> WithinParens -> Markdown Source #

How reference to this type is rendered, in Markdown.

Examples:

[Integer](#type-integer),
[Maybe](#type-Maybe) [()](#type-unit).

Consider using one of the following functions as default implementation; which one to use depends on number of type arguments in your type:

If none of them fits your purposes precisely, consider using customTypeDocMdReference.

default typeDocMdReference :: (Typeable a, IsHomomorphic a) => Proxy a -> WithinParens -> Markdown Source #

typeDocDependencies :: Proxy a -> [SomeDocDefinitionItem] Source #

All types which this type directly contains.

Used in automatic types discovery.

default typeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem] Source #

typeDocHaskellRep :: TypeDocHaskellRep a Source #

For complex types - their immediate Haskell representation.

For primitive types set this to Nothing.

For homomorphic types use homomorphicTypeDocHaskellRep implementation.

For polymorphic types consider using concreteTypeDocHaskellRep as implementation.

Modifier haskellRepNoFields can be used to hide names of fields, beneficial for newtypes.

Use haskellRepAdjust or haskellRepMap for more involved adjustments.

Also, consider defining an instance of TypeHasFieldNamingStrategy instead of defining this method -- the former can be used downstream, e.g. in lorentz, for better naming consistency.

default typeDocHaskellRep :: (Generic a, GTypeHasDoc (Rep a), IsHomomorphic a, TypeHasFieldNamingStrategy a) => TypeDocHaskellRep a Source #

typeDocMichelsonRep :: TypeDocMichelsonRep a Source #

Final michelson representation of a type.

For homomorphic types use homomorphicTypeDocMichelsonRep implementation.

For polymorphic types consider using concreteTypeDocMichelsonRep as implementation.

default typeDocMichelsonRep :: (KnownIsoT a, IsHomomorphic a) => TypeDocMichelsonRep a Source #

Instances

Instances details

TypeHasDoc ByteString Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ByteString :: FieldDescriptions Source # Methods typeDocName :: Proxy ByteString -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy ByteString -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy ByteString -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep ByteString Source # typeDocMichelsonRep :: TypeDocMichelsonRep ByteString Source #
TypeHasDoc MText Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions MText :: FieldDescriptions Source # Methods typeDocName :: Proxy MText -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy MText -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy MText -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep MText Source # typeDocMichelsonRep :: TypeDocMichelsonRep MText Source #
TypeHasDoc Operation Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Operation :: FieldDescriptions Source # Methods typeDocName :: Proxy Operation -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Operation -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Operation Source # typeDocMichelsonRep :: TypeDocMichelsonRep Operation Source #
TypeHasDoc EpAddress Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions EpAddress :: FieldDescriptions Source # Methods typeDocName :: Proxy EpAddress -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy EpAddress -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep EpAddress Source # typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress Source #
TypeHasDoc Address Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Address :: FieldDescriptions Source # Methods typeDocName :: Proxy Address -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Address -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Address -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Address Source # typeDocMichelsonRep :: TypeDocMichelsonRep Address Source #
TypeHasDoc ChainId Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ChainId :: FieldDescriptions Source # Methods typeDocName :: Proxy ChainId -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy ChainId -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy ChainId -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep ChainId Source # typeDocMichelsonRep :: TypeDocMichelsonRep ChainId Source #
TypeHasDoc Mutez Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Mutez :: FieldDescriptions Source # Methods typeDocName :: Proxy Mutez -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Mutez -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Mutez -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Mutez Source # typeDocMichelsonRep :: TypeDocMichelsonRep Mutez Source #
TypeHasDoc Timestamp Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Timestamp :: FieldDescriptions Source # Methods typeDocName :: Proxy Timestamp -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Timestamp -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Timestamp -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Timestamp Source # typeDocMichelsonRep :: TypeDocMichelsonRep Timestamp Source #
TypeHasDoc KeyHash Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions KeyHash :: FieldDescriptions Source # Methods typeDocName :: Proxy KeyHash -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy KeyHash -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy KeyHash -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep KeyHash Source # typeDocMichelsonRep :: TypeDocMichelsonRep KeyHash Source #
TypeHasDoc PublicKey Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions PublicKey :: FieldDescriptions Source # Methods typeDocName :: Proxy PublicKey -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy PublicKey -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy PublicKey -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep PublicKey Source # typeDocMichelsonRep :: TypeDocMichelsonRep PublicKey Source #
TypeHasDoc Signature Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Signature :: FieldDescriptions Source # Methods typeDocName :: Proxy Signature -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Signature -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Signature -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Signature Source # typeDocMichelsonRep :: TypeDocMichelsonRep Signature Source #
TypeHasDoc Chest Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Chest :: FieldDescriptions Source # Methods typeDocName :: Proxy Chest -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Chest -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Chest -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Chest Source # typeDocMichelsonRep :: TypeDocMichelsonRep Chest Source #
TypeHasDoc ChestKey Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ChestKey :: FieldDescriptions Source # Methods typeDocName :: Proxy ChestKey -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy ChestKey -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy ChestKey -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep ChestKey Source # typeDocMichelsonRep :: TypeDocMichelsonRep ChestKey Source #
TypeHasDoc Integer Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Integer :: FieldDescriptions Source # Methods typeDocName :: Proxy Integer -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Integer -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Integer -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Integer Source # typeDocMichelsonRep :: TypeDocMichelsonRep Integer Source #
TypeHasDoc Natural Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Natural :: FieldDescriptions Source # Methods typeDocName :: Proxy Natural -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Natural -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Natural -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Natural Source # typeDocMichelsonRep :: TypeDocMichelsonRep Natural Source #
TypeHasDoc () Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions () :: FieldDescriptions Source # Methods typeDocName :: Proxy () -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy () -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy () -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep () Source # typeDocMichelsonRep :: TypeDocMichelsonRep () Source #
TypeHasDoc Bool Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Bool :: FieldDescriptions Source # Methods typeDocName :: Proxy Bool -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy Bool -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy Bool -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep Bool Source # typeDocMichelsonRep :: TypeDocMichelsonRep Bool Source #
PolyCTypeHasDocC '[a] => TypeHasDoc (Set a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Set a) :: FieldDescriptions Source # Methods typeDocName :: Proxy (Set a) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (Set a) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (Set a) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (Set a) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (Set a) Source #
PolyTypeHasDocC '[cp] => TypeHasDoc (ContractRef cp) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (ContractRef cp) :: FieldDescriptions Source # Methods typeDocName :: Proxy (ContractRef cp) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (ContractRef cp) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (ContractRef cp) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp) Source #
PolyTypeHasDocC '[a] => TypeHasDoc (Ticket a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Ticket a) :: FieldDescriptions Source # Methods typeDocName :: Proxy (Ticket a) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (Ticket a) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (Ticket a) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (Ticket a) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (Ticket a) Source #
PolyTypeHasDocC '[a] => TypeHasDoc (Maybe a) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Maybe a) :: FieldDescriptions Source # Methods typeDocName :: Proxy (Maybe a) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (Maybe a) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (Maybe a) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (Maybe a) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (Maybe a) Source #
PolyTypeHasDocC '[a] => TypeHasDoc [a] Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions [a] :: FieldDescriptions Source # Methods typeDocName :: Proxy [a] -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy [a] -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy [a] -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep [a] Source # typeDocMichelsonRep :: TypeDocMichelsonRep [a] Source #
PolyTypeHasDocC '[l, r] => TypeHasDoc (Either l r) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Either l r) :: FieldDescriptions Source # Methods typeDocName :: Proxy (Either l r) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (Either l r) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (Either l r) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (Either l r) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (Either l r) Source #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (Map k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Map k v) :: FieldDescriptions Source # Methods typeDocName :: Proxy (Map k v) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (Map k v) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (Map k v) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (Map k v) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (Map k v) Source #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (BigMap k v) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (BigMap k v) :: FieldDescriptions Source # Methods typeDocName :: Proxy (BigMap k v) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (BigMap k v) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (BigMap k v) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v) Source #
PolyTypeHasDocC '[a, b] => TypeHasDoc (a, b) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b) :: FieldDescriptions Source # Methods typeDocName :: Proxy (a, b) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (a, b) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (a, b) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (a, b) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b) Source #
(TypeHasDoc (ApplyNamedFunctor f a), KnownSymbol n, KnownIsoT (ApplyNamedFunctor f Integer), Typeable f, Typeable a) => TypeHasDoc (NamedF f a n) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (NamedF f a n) :: FieldDescriptions Source # Methods typeDocName :: Proxy (NamedF f a n) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (NamedF f a n) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (NamedF f a n) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (NamedF f a n) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (NamedF f a n) Source #
PolyTypeHasDocC '[a, b, c] => TypeHasDoc (a, b, c) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c) :: FieldDescriptions Source # Methods typeDocName :: Proxy (a, b, c) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (a, b, c) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (a, b, c) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c) Source #
PolyTypeHasDocC '[a, b, c, d] => TypeHasDoc (a, b, c, d) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d) :: FieldDescriptions Source # Methods typeDocName :: Proxy (a, b, c, d) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (a, b, c, d) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (a, b, c, d) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d) Source #
PolyTypeHasDocC '[a, b, c, d, e] => TypeHasDoc (a, b, c, d, e) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d, e) :: FieldDescriptions Source # Methods typeDocName :: Proxy (a, b, c, d, e) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (a, b, c, d, e) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (a, b, c, d, e) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e) Source #
PolyTypeHasDocC '[a, b, c, d, e, f] => TypeHasDoc (a, b, c, d, e, f) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d, e, f) :: FieldDescriptions Source # Methods typeDocName :: Proxy (a, b, c, d, e, f) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (a, b, c, d, e, f) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (a, b, c, d, e, f) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e, f) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e, f) Source #
PolyTypeHasDocC '[a, b, c, d, e, f, g] => TypeHasDoc (a, b, c, d, e, f, g) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d, e, f, g) :: FieldDescriptions Source # Methods typeDocName :: Proxy (a, b, c, d, e, f, g) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (a, b, c, d, e, f, g) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (a, b, c, d, e, f, g) -> [SomeDocDefinitionItem] Source # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e, f, g) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e, f, g) Source #

data FieldSnakeCase Source #

Empty datatype used as marker for DerivingVia with TypeHasFieldNamingStrategy.

Uses toSnake . dropPrefix strategy.

Instances

Instances details

TypeHasFieldNamingStrategy FieldSnakeCase Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text Source #

data FieldCamelCase Source #

Empty datatype used as marker for DerivingVia with TypeHasFieldNamingStrategy.

Uses stripFieldPrefix strategy.

Instances

Instances details

TypeHasFieldNamingStrategy FieldCamelCase Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text Source #

class TypeHasFieldNamingStrategy a where Source #

Field naming strategy used by a type. id by default.

Some common options include: > typeFieldNamingStrategy = stripFieldPrefix > typeFieldNamingStrategy = toSnake . dropPrefix

This is used by the default implementation of typeDocHaskellRep and intended to be reused downstream.

You can also use DerivingVia together with FieldCamelCase and FieldSnakeCase to easily define instances of this class:

data MyType = ... deriving TypeHasFieldNamingStrategy via FieldCamelCase

Minimal complete definition

Nothing

Methods

typeFieldNamingStrategy :: Text -> Text Source #

Instances

Instances details

TypeHasFieldNamingStrategy (a :: k) Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text Source #
TypeHasFieldNamingStrategy FieldCamelCase Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text Source #
TypeHasFieldNamingStrategy FieldSnakeCase Source #
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text Source #

newtype WithinParens Source #

Whether given text should be rendered grouped in parentheses (if they make sense).

Constructors

WithinParens Bool

frDescriptionL :: forall a. Lens' (FieldRep a) (Maybe Text) Source #

frNameL :: forall a. Lens' (FieldRep a) (Maybe Text) Source #

frTypeRepL :: forall a a. Lens (FieldRep a) (FieldRep a) a a Source #

buildADTRep :: forall a. (WithinParens -> a -> Markdown) -> ADTRep a -> Markdown Source #

Show given ADTRep in a neat way.

applyWithinParens :: WithinParens -> Markdown -> Markdown Source #

buildTypeWithinParens :: forall a. Typeable a => WithinParens -> Markdown Source #

Show type, wrapping into parentheses if necessary.

typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder Source #

Fully render Michelson representation of a type.

dTypeDep :: forall (t :: Type). TypeHasDoc t => SomeDocDefinitionItem Source #

Create a DType in form suitable for putting to typeDocDependencies.

dTypeDepP :: forall (t :: Type). TypeHasDoc t => Proxy t -> SomeDocDefinitionItem Source #

Proxy version of dTypeDep.

dStorage :: forall store. TypeHasDoc store => DStorageType Source #

Shortcut for DStorageType.

customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown Source #

Render a reference to a type which consists of type constructor (you have to provide name of this type constructor and documentation for the whole type) and zero or more type arguments.

customTypeDocMdReference' :: (Text, DType) -> [WithinParens -> Markdown] -> WithinParens -> Markdown Source #

More generic version of customTypeDocMdReference, it accepts arguments not as types with doc, but printers for them.

homomorphicTypeDocMdReference :: forall (t :: Type). (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown Source #

Derive typeDocMdReference, for homomorphic types only.

poly1TypeDocMdReference :: forall t (r :: Type) (a :: Type). (r ~ t a, Typeable t, Each '[TypeHasDoc] [r, a], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown Source #

Derive typeDocMdReference, for polymorphic type with one type argument, like Maybe Integer.

poly2TypeDocMdReference :: forall t (r :: Type) (a :: Type) (b :: Type). (r ~ t a b, Typeable t, Each '[TypeHasDoc] [r, a, b], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown Source #

Derive typeDocMdReference, for polymorphic type with two type arguments, like Lambda Integer Natural.

genericTypeDocDependencies :: forall a. (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem] Source #

Implement typeDocDependencies via getting all immediate fields of a datatype.

Note: this will not include phantom types, I'm not sure yet how this scenario should be handled (@martoon).

homomorphicTypeDocHaskellRep :: forall a. (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a Source #

Implement typeDocHaskellRep for a homomorphic type.

Note that it does not require your type to be of IsHomomorphic instance, which can be useful for some polymorphic types which, for documentation purposes, we want to consider homomorphic.

Example: Operation is in fact polymorphic, but we don't want this fact to be reflected in the documentation.

concreteTypeDocHaskellRep :: forall a b. (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b Source #

Implement typeDocHaskellRep on example of given concrete type.

This is a best effort attempt to implement typeDocHaskellRep for polymorphic types, as soon as there is no simple way to preserve type variables when automatically deriving Haskell representation of a type.

unsafeConcreteTypeDocHaskellRep :: forall a b. (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b Source #

Version of concreteTypeDocHaskellRep which does not ensure whether the type for which representation is built is any similar to the original type which you implement a TypeHasDoc instance for.

haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a Source #

Erase fields from Haskell datatype representation.

Use this when rendering fields names is undesired.

haskellRepMap :: (Text -> Text) -> TypeDocHaskellRep a -> TypeDocHaskellRep a Source #

Like haskellRepAdjust, but can't add or remove field names.

haskellRepStripFieldPrefix :: TypeDocHaskellRep a -> TypeDocHaskellRep a Source #

Deprecated: Use haskellRepMap with utilities from Morley.Util.Text instead

Map over fields with stripFieldPrefix. Equivalent to haskellRepMap stripFieldPrefix. Left for compatibility.

haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a Source #

Add field name for newtype.

Since newtype field is automatically erased. Use this function to add the desired field name.

haskellRepAdjust :: (Maybe Text -> Maybe Text) -> TypeDocHaskellRep a -> TypeDocHaskellRep a Source #

Adjust field names using a function. Can add or remove field names.

homomorphicTypeDocMichelsonRep :: forall a. KnownIsoT a => TypeDocMichelsonRep a Source #

Implement typeDocMichelsonRep for homomorphic type.

concreteTypeDocMichelsonRep :: forall a b. (Typeable a, KnownIsoT a, HaveCommonTypeCtor b a) => TypeDocMichelsonRep b Source #

Implement typeDocMichelsonRep on example of given concrete type.

This function exists for the same reason as concreteTypeDocHaskellRep.

unsafeConcreteTypeDocMichelsonRep :: forall a b. (Typeable a, KnownIsoT a) => TypeDocMichelsonRep b Source #

Version of unsafeConcreteTypeDocHaskellRep which does not ensure whether the type for which representation is built is any similar to the original type which you implement a TypeHasDoc instance for.

docInstr :: DocItem di => di -> Instr s s Source #

Put a document item.

cutInstrNonDoc :: (forall i o. Instr i o -> Instr i o) -> Instr inp out -> Instr s s Source #

Leave only instructions related to documentation.

Generated documentation for resulting instruction remains the same, but semantics of instruction itself gets lost. We have to pass optimizer here as an argument to avoid cyclic dependencies.

TKey
TUnit
TSignature
TChainId
TOption T
TList T
TSet T
TOperation
TContract T
TTicket T
TPair T T
TOr T T
TLambda T T
TMap T T
TBigMap T T
TInt
TNat
TString
TBytes
TMutez
TBool
TKeyHash
TBls12381Fr
TBls12381G1
TBls12381G2
TTimestamp
TAddress
TChest
TChestKey
TSaplingState Peano
TSaplingTransaction Peano
TNever