Lorentz.Coercions

Identity transformations between different Haskell types.

Safe coercions

class CanCastTo a b where

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.

Minimal complete definition

Nothing

Methods

castDummy :: Proxy a -> Proxy b -> ()

An optional method which helps passing -Wredundant-constraints check. Also, you can set specific implementation for it with specific sanity checks.

Instances

CanCastTo (a :: k) (a :: k)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy a -> Proxy a -> ()

CanCastTo Address (TAddress p :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy Address -> Proxy (TAddress p) -> ()

CanCastTo (FutureContract p :: Type) EpAddress

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (FutureContract p) -> Proxy EpAddress -> ()

CanCastTo (TSignature a :: Type) ByteString

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (TSignature a) -> Proxy ByteString -> ()

CanCastTo (Packed a :: Type) ByteString

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Packed a) -> Proxy ByteString -> ()

CanCastTo a b => CanCastTo ([a] :: Type) ([b] :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy [a] -> Proxy [b] -> ()

CanCastTo a b => CanCastTo (Maybe a :: Type) (Maybe b :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Maybe a) -> Proxy (Maybe b) -> ()

CanCastTo k1 k2 => CanCastTo (Set k1 :: Type) (Set k2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Set k1) -> Proxy (Set k2) -> ()

CanCastTo a1 a2 => CanCastTo (ContractRef a1 :: Type) (ContractRef a2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (ContractRef a1) -> Proxy (ContractRef a2) -> ()

CanCastTo a b => CanCastTo (TSignature a :: Type) (TSignature b :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (TSignature a) -> Proxy (TSignature b) -> ()

CanCastTo a b => CanCastTo (Packed a :: Type) (Packed b :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Packed a) -> Proxy (Packed b) -> ()

SameEntries entries1 entries2 => CanCastTo (UParam entries1 :: Type) (UParam entries2 :: Type)

Allows casts only between UParam_ and UParam.

Defined in Lorentz.UParam

Methods

castDummy :: Proxy (UParam entries1) -> Proxy (UParam entries2) -> ()

CanCastTo (TAddress p :: Type) Address

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (TAddress p) -> Proxy Address -> ()

CanCastTo (Hash alg a :: Type) ByteString

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Hash alg a) -> Proxy ByteString -> ()

(CanCastTo l1 l2, CanCastTo r1 r2) => CanCastTo (Either l1 r1 :: Type) (Either l2 r2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Either l1 r1) -> Proxy (Either l2 r2) -> ()

(CanCastTo a1 a2, CanCastTo b1 b2) => CanCastTo ((a1, b1) :: Type) ((a2, b2) :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (a1, b1) -> Proxy (a2, b2) -> ()

(CanCastTo k1 k2, CanCastTo v1 v2) => CanCastTo (Map k1 v1 :: Type) (Map k2 v2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Map k1 v1) -> Proxy (Map k2 v2) -> ()

(CanCastTo k1 k2, CanCastTo v1 v2) => CanCastTo (BigMap k1 v1 :: Type) (BigMap k2 v2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (BigMap k1 v1) -> Proxy (BigMap k2 v2) -> ()

(CanCastTo (ZippedStack i1) (ZippedStack i2), CanCastTo (ZippedStack o1) (ZippedStack o2)) => CanCastTo (i1 :-> o1 :: Type) (i2 :-> o2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (i1 :-> o1) -> Proxy (i2 :-> o2) -> ()

(CanCastTo alg1 alg2, CanCastTo a1 a2) => CanCastTo (Hash alg1 a1 :: Type) (Hash alg2 a2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (Hash alg1 a1) -> Proxy (Hash alg2 a2) -> ()

(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (Void_ a1 r1 :: Type) (Void_ a2 r2 :: Type)

Defined in Lorentz.Macro

Methods

castDummy :: Proxy (Void_ a1 r1) -> Proxy (Void_ a2 r2) -> ()

(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (View a1 r1 :: Type) (View a2 r2 :: Type)

Defined in Lorentz.Macro

Methods

castDummy :: Proxy (View a1 r1) -> Proxy (View a2 r2) -> ()

(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2) => CanCastTo ((a1, b1, c1) :: Type) ((a2, b2, c2) :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (a1, b1, c1) -> Proxy (a2, b2, c2) -> ()

(CanCastTo a b, f ~ g) => CanCastTo (NamedF f a n :: Type) (NamedF g b m :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (NamedF f a n) -> Proxy (NamedF g b m) -> ()

(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2, CanCastTo d1 d2) => CanCastTo ((a1, b1, c1, d1) :: Type) ((a2, b2, c2, d2) :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (a1, b1, c1, d1) -> Proxy (a2, b2, c2, d2) -> ()

(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2, CanCastTo d1 d2, CanCastTo e1 e2) => CanCastTo ((a1, b1, c1, d1, e1) :: Type) ((a2, b2, c2, d2, e2) :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (a1, b1, c1, d1, e1) -> Proxy (a2, b2, c2, d2, e2) -> ()

(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2, CanCastTo d1 d2, CanCastTo e1 e2, CanCastTo f1 f2) => CanCastTo ((a1, b1, c1, d1, e1, f1) :: Type) ((a2, b2, c2, d2, e2, f2) :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (a1, b1, c1, d1, e1, f1) -> Proxy (a2, b2, c2, d2, e2, f2) -> ()

castDummyG :: (Generic a, Generic b, GCanCastTo (Rep a) (Rep b)) => Proxy a -> Proxy b -> ()

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

checkedCoerce :: forall a b. (CanCastTo a b, Coercible a b) => a -> b

Coercion in Haskell world which respects CanCastTo.

type Castable_ a b = (MichelsonCoercible a b, CanCastTo a b)

Coercion from a to b is permitted and safe.

type Coercible_ a b = (MichelsonCoercible a b, CanCastTo a b, CanCastTo b a)

Coercions between a to b are permitted and safe.

checkedCoerce_ :: forall a b s. Castable_ a b => (a ': s) :-> (b ': s)

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

checkedCoercing_ :: forall a b s. Coercible_ a b => ((b ': s) :-> (b ': s)) -> (a ': s) :-> (a ': s)

Pretends that the top item of the stack was coerced.

allowCheckedCoerceTo :: forall b a. Dict (CanCastTo a b)

Locally provide given CanCastTo instance.

allowCheckedCoerce :: forall a b. Dict (CanCastTo a b, CanCastTo b a)

Locally provide bidirectional CanCastTo instance.

coerceUnwrap :: forall a s. Wrappable a => (a ': s) :-> (Unwrappable a ': s)

Specialized version of coerce_ to unwrap a haskell newtype.

coerceWrap :: forall a s. Wrappable a => (Unwrappable a ': s) :-> (a ': s)

Specialized version of coerce_ to wrap into a haskell newtype.

toNamed :: Label name -> (a ': s) :-> (NamedF Identity a name ': s)

Lift given value to a named value.

fromNamed :: Label name -> (NamedF Identity a name ': s) :-> (a ': s)

Unpack named value.

Unsafe coercions

type MichelsonCoercible a b = ToT a ~ ToT b

Whether two types have the same Michelson representation.

forcedCoerce :: Coercible a b => a -> b

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.

forcedCoerce_ :: MichelsonCoercible a b => (a ': s) :-> (b ': s)

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 from morley-upgradeable), 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.

gForcedCoerce_ :: MichelsonCoercible (t a) (t b) => (t a ': s) :-> (t b ': s)

fakeCoerce :: s1 :-> s2

Convert between two stacks via failing.

fakeCoercing :: (s1 :-> s2) -> s1' :-> s2'

Re-exports

class ToT s ~ ToT (Unwrappable s) => Wrappable (s :: Type)

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.

Associated Types

type Unwrappable s :: Type

type Unwrappable s = GUnwrappable (Rep s)

Instances

Wrappable (UParam entries)

Defined in Lorentz.UParam

Associated Types

type Unwrappable (UParam entries)

Wrappable (ParameterWrapper deriv cp)

Defined in Lorentz.Entrypoints.Manual

Associated Types

type Unwrappable (ParameterWrapper deriv cp)

Wrappable (Extensible x)

Defined in Lorentz.Extensible

Associated Types

type Unwrappable (Extensible x)

Wrappable (NamedF Maybe a name)

Defined in Lorentz.Wrappable

Associated Types

type Unwrappable (NamedF Maybe a name)

Wrappable (NamedF Identity a name)

Defined in Lorentz.Wrappable

Associated Types

type Unwrappable (NamedF Identity a name)