Safe Haskell | None |
---|---|
Language | Haskell2010 |
Conversions between haskell types/values and Michelson ones.
Synopsis
- class WellTypedToT a => IsoValue a where
- class GIsoValue (x :: Type -> Type) where
- type GValueType x :: T
- type family ToT' (t :: k) :: T where ...
- data SomeIsoValue where
- SomeIsoValue :: (Typeable a, IsoValue a) => a -> SomeIsoValue
- newtype AnyIsoValue = AnyIsoValue (forall a. IsoValue a => a)
- type GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t))
- class WellTyped (t :: T)
- type WellTypedIsoValue a = (WellTyped (ToT a), IsoValue a)
- type WellTypedToT a = WellTyped (ToT a)
- data Dict a where
- type EntryPointCall param arg = EntryPointCallT (ToT param) (ToT arg)
- type SomeEntryPointCall arg = SomeEntryPointCallT (ToT arg)
- data ContractRef (arg :: Type) = ContractRef {
- crAddress :: Address
- crEntryPoint :: SomeEntryPointCall arg
- coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b
- contractRefToAddr :: ContractRef cp -> EpAddress
- newtype BigMap k v = BigMap {}
- type family ToTs (ts :: [Type]) :: [T] where ...
- type family ToTs' (t :: [k]) :: [T] where ...
- class IsoValuesStack (ts :: [Type]) where
- totsKnownLemma :: forall s. KnownList s :- KnownList (ToTs s)
- totsAppendLemma :: forall a b. KnownList a => Dict (ToTs (a ++ b) ~ (ToTs a ++ ToTs b))
Value conversions
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.
Nothing
Type function that converts a regular Haskell type into a T
type.
type ToT a = GValueType (Rep a) Source #
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.
Instances
class GIsoValue (x :: Type -> Type) Source #
Implements ADT conversion to Michelson value.
Thanks to Generic, Michelson representation will be a balanced tree; this reduces average access time in general case.
A drawback of such approach is that, in theory, in new GHC version generified representation may change; however, chances are small and I (martoon) believe that contract versions will change much faster anyway.
gToValue, gFromValue
type GValueType x :: T Source #
Instances
type family ToT' (t :: k) :: T where ... Source #
Overloaded version of ToT
to work on Haskell and T
types.
data SomeIsoValue where Source #
Hides some Haskell value put in line with Michelson Value
.
SomeIsoValue :: (Typeable a, IsoValue a) => a -> SomeIsoValue |
newtype AnyIsoValue Source #
Any Haskell value which can be converted to Michelson Value
.
AnyIsoValue (forall a. IsoValue a => a) |
type GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t)) Source #
Whether Michelson representation of the type is derived via Generics.
class 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.
Instances
type WellTypedToT a = WellTyped (ToT a) Source #
Values of type
capture a dictionary for a constraint of type Dict
pp
.
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.
Instances
HasDict a (Dict a) | |
Defined in Data.Constraint | |
a :=> (Read (Dict a)) | |
a :=> (Monoid (Dict a)) | |
a :=> (Enum (Dict a)) | |
a :=> (Bounded (Dict a)) | |
() :=> (Eq (Dict a)) | |
() :=> (Ord (Dict a)) | |
() :=> (Show (Dict a)) | |
() :=> (Semigroup (Dict a)) | |
a => Bounded (Dict a) | |
a => Enum (Dict a) | |
Defined in Data.Constraint | |
Eq (Dict a) | |
(Typeable p, p) => Data (Dict p) | |
Defined in Data.Constraint 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) # | |
Ord (Dict a) | |
a => Read (Dict a) | |
Show (Dict a) | |
Semigroup (Dict a) | |
a => Monoid (Dict a) | |
NFData (Dict c) | |
Defined in Data.Constraint |
Re-exporting to use in tests.
Missing Haskell analogies to Michelson values
type EntryPointCall param arg = EntryPointCallT (ToT param) (ToT arg) Source #
type SomeEntryPointCall arg = SomeEntryPointCallT (ToT arg) Source #
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.
Instances
coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b Source #
Replace type argument of ContractAddr
with isomorphic one.
contractRefToAddr :: ContractRef cp -> EpAddress Source #
Instances
(Eq k, Eq v) => Eq (BigMap k v) Source # | |
(Show k, Show v) => Show (BigMap k v) Source # | |
Ord k => Semigroup (BigMap k v) Source # | |
Ord k => Monoid (BigMap k v) Source # | |
(WellTypedToT k, WellTypedToT v, Comparable (ToT k), Arbitrary k, Arbitrary v, Ord k) => Arbitrary (BigMap k v) Source # | |
Default (BigMap k v) Source # | |
Defined in Michelson.Typed.Haskell.Value | |
(WellTypedToT k, WellTypedToT v, Comparable (ToT k), Ord k, IsoValue k, IsoValue v) => IsoValue (BigMap k v) Source # | |
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (BigMap k v) Source # | |
Defined in Michelson.Typed.Haskell.Doc typeDocName :: Proxy (BigMap k v) -> Text Source # typeDocMdDescription :: Markdown Source # typeDocMdReference :: Proxy (BigMap k v) -> WithinParens -> Markdown Source # typeDocDependencies :: Proxy (BigMap k v) -> [SomeTypeWithDoc] Source # typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v) Source # typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v) Source # | |
type ToT (BigMap k v) Source # | |
Stack conversion
type family ToTs (ts :: [Type]) :: [T] where ... Source #
Type function to convert a Haskell stack type to T
-based one.
type family ToTs' (t :: [k]) :: [T] where ... Source #
Overloaded version of ToTs
to work on Haskell and T
stacks.
class IsoValuesStack (ts :: [Type]) where Source #
Isomorphism between Michelson stack and its Haskell reflection.
toValStack :: Rec Identity ts -> Rec Value (ToTs ts) Source #
fromValStack :: Rec Value (ToTs ts) -> Rec Identity ts Source #
Instances
IsoValuesStack ('[] :: [Type]) Source # | |
(IsoValue t, IsoValuesStack st) => IsoValuesStack (t ': st) Source # | |