Safe Haskell	Safe-Inferred
Language	Haskell2010

Morley.Michelson.Typed.Scope.Internal.Deprecated

Synopsis

type IsComparable t = Not (ContainsT 'PSNonComparable t)
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)
type SaplingStatePresence (t :: T) = TPresence 'PSSaplingState t
type NestedBigMapsPresence (t :: T) = TPresence 'PSNestedBigMaps t
type BigMapPresence (t :: T) = TPresence 'PSBigMap t
type TicketPresence (t :: T) = TPresence 'PSTicket t
type ContractPresence (t :: T) = TPresence 'PSContract t
type OpPresence (t :: T) = TPresence 'PSOp t
class ContainsNestedBigMaps t ~ 'False => HasNoNestedBigMaps t
class ContainsSaplingState t ~ 'False => HasNoSaplingState 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 ContainsSaplingState t = ContainsT 'PSSaplingState t
type ContainsNestedBigMaps t = ContainsT 'PSNestedBigMaps t
type ContainsBigMap t = ContainsT 'PSBigMap t
type ContainsTicket t = ContainsT 'PSTicket t
type ContainsContract t = ContainsT 'PSContract t
type ContainsOp t = ContainsT 'PSOp t
pattern SaplingStateAbsent :: () => ContainsSaplingState t ~ 'False => SaplingStatePresence t
pattern SaplingStatePresent :: () => ContainsSaplingState t ~ 'True => SaplingStatePresence t
pattern NestedBigMapsAbsent :: () => ContainsNestedBigMaps t ~ 'False => NestedBigMapsPresence t
pattern NestedBigMapsPresent :: () => ContainsNestedBigMaps t ~ 'True => NestedBigMapsPresence t
pattern BigMapAbsent :: () => ContainsBigMap t ~ 'False => BigMapPresence t
pattern BigMapPresent :: () => ContainsBigMap t ~ 'True => BigMapPresence t
pattern TicketAbsent :: () => ContainsTicket t ~ 'False => TicketPresence t
pattern TicketPresent :: () => ContainsTicket t ~ 'True => TicketPresence t
pattern ContractAbsent :: () => ContainsContract t ~ 'False => ContractPresence t
pattern ContractPresent :: () => ContainsContract t ~ 'True => ContractPresence t
pattern OpAbsent :: () => ContainsOp t ~ 'False => OpPresence t
pattern OpPresent :: () => ContainsOp t ~ 'True => OpPresence t
checkOpPresence :: Sing (ty :: T) -> TPresence 'PSOp ty
checkContractTypePresence :: Sing (ty :: T) -> TPresence 'PSContract ty
checkTicketPresence :: Sing (ty :: T) -> TPresence 'PSTicket ty
checkBigMapPresence :: Sing (ty :: T) -> TPresence 'PSBigMap ty
checkNestedBigMapsPresence :: Sing (ty :: T) -> TPresence 'PSNestedBigMaps ty
opAbsense :: Sing (t :: T) -> Maybe (Dict $ ForbidOp t)
contractTypeAbsense :: Sing (t :: T) -> Maybe (Dict $ ForbidContract t)
bigMapAbsense :: Sing (t :: T) -> Maybe (Dict $ ForbidBigMap t)
nestedBigMapsAbsense :: Sing (t :: T) -> Maybe (Dict $ ForbidNestedBigMaps t)
comparabilityImpliesNoNestedBigMaps :: forall t. (SingI t, IsComparable t ~ 'True) => ContainsNestedBigMaps t :~: 'False
comparabilityImpliesNoOp :: forall t. (SingI t, IsComparable t ~ 'True) => ContainsOp t :~: 'False
getComparableProofS :: Sing (a :: T) -> Maybe (Dict (Comparable a))

Documentation

type IsComparable t = Not (ContainsT 'PSNonComparable t) Source #

Deprecated: Use 'Not (ContainsT PSNonComparable t)' instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

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

Deprecated: Use *Scope instead

type SaplingStatePresence (t :: T) = TPresence 'PSSaplingState t Source #

Deprecated: Use TPresence instead

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

type NestedBigMapsPresence (t :: T) = TPresence 'PSNestedBigMaps t Source #

Deprecated: Use TPresence instead

Whether a value of this type _may_ contain nested big_maps.

type BigMapPresence (t :: T) = TPresence 'PSBigMap t Source #

Deprecated: Use TPresence instead

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

type TicketPresence (t :: T) = TPresence 'PSTicket t Source #

Deprecated: Use TPresence instead

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

type ContractPresence (t :: T) = TPresence 'PSContract t Source #

Deprecated: Use TPresence instead

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

type OpPresence (t :: T) = TPresence 'PSOp t Source #

Deprecated: Use TPresence instead

Whether a value of this type _may_ contain an operation.

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

Deprecated: Use Forbid* instead

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.Internal.Deprecated

class ContainsSaplingState t ~ 'False => HasNoSaplingState t Source #

Deprecated: Use Forbid* instead

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

Instances

Instances details

ContainsSaplingState t ~ 'False => HasNoSaplingState t Source #
Instance details Defined in Morley.Michelson.Typed.Scope.Internal.Deprecated

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

Deprecated: Use Forbid* instead

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.Internal.Deprecated

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

Deprecated: Use Forbid* instead

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.Internal.Deprecated

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

Deprecated: Use Forbid* instead

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.Internal.Deprecated

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

Deprecated: Use Forbid* instead

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.Internal.Deprecated

type ContainsSaplingState t = ContainsT 'PSSaplingState t Source #

Deprecated: Use ContainsT with the corresponding type marker, e.g. 'ContainsT PSOp', 'ContainsT PSTicket', etc

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

type ContainsNestedBigMaps t = ContainsT 'PSNestedBigMaps t Source #

Deprecated: Use ContainsT with the corresponding type marker, e.g. 'ContainsT PSOp', 'ContainsT PSTicket', etc

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.

type ContainsBigMap t = ContainsT 'PSBigMap t Source #

Deprecated: Use ContainsT with the corresponding type marker, e.g. 'ContainsT PSOp', 'ContainsT PSTicket', etc

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

type ContainsTicket t = ContainsT 'PSTicket t Source #

Deprecated: Use ContainsT with the corresponding type marker, e.g. 'ContainsT PSOp', 'ContainsT PSTicket', etc

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

type ContainsContract t = ContainsT 'PSContract t Source #

Deprecated: Use ContainsT with the corresponding type marker, e.g. 'ContainsT PSOp', 'ContainsT PSTicket', etc

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.

type ContainsOp t = ContainsT 'PSOp t Source #

Deprecated: Use ContainsT with the corresponding type marker, e.g. 'ContainsT PSOp', 'ContainsT PSTicket', etc

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.

pattern SaplingStateAbsent :: () => ContainsSaplingState t ~ 'False => SaplingStatePresence t Source #

Deprecated: Use TPresence instead

pattern SaplingStatePresent :: () => ContainsSaplingState t ~ 'True => SaplingStatePresence t Source #

Deprecated: Use TPresence instead

pattern NestedBigMapsAbsent :: () => ContainsNestedBigMaps t ~ 'False => NestedBigMapsPresence t Source #

Deprecated: Use TPresence instead

pattern NestedBigMapsPresent :: () => ContainsNestedBigMaps t ~ 'True => NestedBigMapsPresence t Source #

Deprecated: Use TPresence instead

pattern BigMapAbsent :: () => ContainsBigMap t ~ 'False => BigMapPresence t Source #

Deprecated: Use TPresence instead

pattern BigMapPresent :: () => ContainsBigMap t ~ 'True => BigMapPresence t Source #

Deprecated: Use TPresence instead

pattern TicketAbsent :: () => ContainsTicket t ~ 'False => TicketPresence t Source #

Deprecated: Use TPresence instead

pattern TicketPresent :: () => ContainsTicket t ~ 'True => TicketPresence t Source #

Deprecated: Use TPresence instead

pattern ContractAbsent :: () => ContainsContract t ~ 'False => ContractPresence t Source #

Deprecated: Use TPresence instead

pattern ContractPresent :: () => ContainsContract t ~ 'True => ContractPresence t Source #

Deprecated: Use TPresence instead

pattern OpAbsent :: () => ContainsOp t ~ 'False => OpPresence t Source #

Deprecated: Use TPresence instead

pattern OpPresent :: () => ContainsOp t ~ 'True => OpPresence t Source #

Deprecated: Use TPresence instead

checkOpPresence :: Sing (ty :: T) -> TPresence 'PSOp ty Source #

Deprecated: Use checkTPresence instead

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

checkContractTypePresence :: Sing (ty :: T) -> TPresence 'PSContract ty Source #

Deprecated: Use checkTPresence instead

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

checkTicketPresence :: Sing (ty :: T) -> TPresence 'PSTicket ty Source #

Deprecated: Use checkTPresence instead

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

checkBigMapPresence :: Sing (ty :: T) -> TPresence 'PSBigMap ty Source #

Deprecated: Use checkTPresence instead

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

checkNestedBigMapsPresence :: Sing (ty :: T) -> TPresence 'PSNestedBigMaps ty Source #

Deprecated: Use checkTPresence instead

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

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

Deprecated: Use tAbsence instead

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

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

Deprecated: Use tAbsence instead

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

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

Deprecated: Use tAbsence instead

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

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

Deprecated: Use tAbsence instead

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

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

Deprecated: Already implied by Comparable constraint

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 #

Deprecated: Already implied by Comparable constraint

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

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

Deprecated: Use comparabilityPresence