Explicitly allowed coercions.

a CanCastTo b proclaims that a can be casted to b without violating any invariants of b.

This relation is reflexive; it may be symmetric or not. It tends to be composable: casting complex types usually requires permission to cast their respective parts; for such types consider using castDummyG as implementation of the method of this typeclass.

For cases when a cast from a to b requires some validation, consider rather making a dedicated function which performs the necessary checks and then calls forcedCoerce.

Implementation of castDummy for types composed from smaller types. It helps to ensure that all necessary constraints are requested in instance head.

Coercion in Haskell world which respects CanCastTo.

Coercion from a to b is permitted and safe.

Coercions between a to b are permitted and safe.

Coerce between types which have an explicit permission for that in the face of CanCastTo constraint.

Pretends that the top item of the stack was coerced.

Locally provide given CanCastTo instance.

Locally provide bidirectional CanCastTo instance.

Specialized version of coerce_ to unwrap a haskell newtype.

Specialized version of coerce_ to wrap into a haskell newtype.

Lift given value to a named value.

Unpack named value.

Whether two types have the same Michelson representation.

Coercion for Haskell world.

We discourage using this function on Lorentz types, consider using coerce instead. One of the reasons forthat is that in Lorentz it's common to declare types as newtypes consisting of existing primitives, and forcedCoerce tends to ignore all phantom type variables of newtypes thus violating their invariants.

Convert between values of types that have the same representation.

This function is not safe in a sense that this allows breaking invariants of casted type (example: UStore) or may stop compile on code changes (example: coercion of pair to a datatype with two fields will break if new field is added). Still, produced Michelson code will always be valid.

Prefer using one of more specific functions from this module.

Convert between two stacks via failing.

Wrappable is similar to lens Wrapped class without the method. It provides type family that is mainly used as constraint when unwrapping Lorentz instruction into a Haskell newtype and vice versa.