| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Michelson.Typed.Haskell.Value
Description
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.
Minimal complete definition
Nothing
Associated Types
Type function that converts a regular Haskell type into a T type.
type ToT a = GValueType (Rep a) Source #
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.
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.
Minimal complete definition
gToValue, gFromValue
Associated Types
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.
Constructors
| SomeIsoValue :: (Typeable a, IsoValue a) => a -> SomeIsoValue |
newtype AnyIsoValue Source #
Any Haskell value which can be converted to Michelson Value.
Constructors
| 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 Dict pp.
e.g.
Dict::Dict(EqInt)
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 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) # | |
| 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.
Constructors
| ContractRef | |
Fields
| |
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
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.
Methods
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 # | |