| 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
- type KnownIsoT a = KnownT (ToT a)
- class (Typeable t, SingI t) => KnownT (t :: T)
- class KnownT (GValueType x) => GIsoValue (x :: Type -> Type) where
- type GValueType x :: T
- type family ToT' (t :: k) :: T where ...
- data SomeIsoValue where
- SomeIsoValue :: KnownIsoT a => a -> SomeIsoValue
- newtype AnyIsoValue = AnyIsoValue (forall a. IsoValue a => a)
- type GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t))
- class KnownT t => 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 (Typeable t, SingI t) => KnownT (t :: T) Source #
Instances
| (Typeable t, SingI t) => KnownT t Source # | |
Defined in Michelson.Typed.Sing | |
| KnownT t => CheckScope (StorageScope t) Source # | |
Defined in Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (StorageScope t)) Source # | |
| KnownT t => CheckScope (ParameterScope t) Source # | |
Defined in Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ParameterScope t)) Source # | |
| KnownT t => CheckScope (ComparabilityScope t) Source # | |
Defined in Michelson.Typed.Value Methods checkScope :: Either BadTypeForScope (Dict (ComparabilityScope t)) Source # | |
class KnownT (GValueType x) => 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.
In case an unbalanced tree is needed, the Generic instance can be derived by
using the utilities in the Generics module.
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 :: KnownIsoT 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 KnownT t => 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 # | |