Michelson.Typed.Haskell.Value

Conversions between haskell types/values and Michelson ones.

Value conversions

class IsoCValue a where

Isomorphism between Michelson primitive values and plain Haskell types.

Associated Types

type ToCT a :: CT

Type function that converts a regular Haskell type into a comparable type (which has kind CT).

Methods

toCVal :: a -> CValue (ToCT a)

Converts a single Haskell value into CVal representation.

fromCVal :: CValue (ToCT a) -> a

Converts a CVal value into a single Haskell value.

Instances

IsoCValue Bool

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Bool :: CT

Methods

toCVal :: Bool -> CValue (ToCT Bool)

fromCVal :: CValue (ToCT Bool) -> Bool

IsoCValue Integer

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Integer :: CT

Methods

toCVal :: Integer -> CValue (ToCT Integer)

fromCVal :: CValue (ToCT Integer) -> Integer

IsoCValue Natural

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Natural :: CT

Methods

toCVal :: Natural -> CValue (ToCT Natural)

fromCVal :: CValue (ToCT Natural) -> Natural

IsoCValue ByteString

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT ByteString :: CT

Methods

toCVal :: ByteString -> CValue (ToCT ByteString)

fromCVal :: CValue (ToCT ByteString) -> ByteString

(DoNotUseTextError :: Constraint) => IsoCValue Text

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Text :: CT

Methods

toCVal :: Text -> CValue (ToCT Text)

fromCVal :: CValue (ToCT Text) -> Text

IsoCValue MText

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT MText :: CT

Methods

toCVal :: MText -> CValue (ToCT MText)

fromCVal :: CValue (ToCT MText) -> MText

IsoCValue KeyHash

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT KeyHash :: CT

Methods

toCVal :: KeyHash -> CValue (ToCT KeyHash)

fromCVal :: CValue (ToCT KeyHash) -> KeyHash

IsoCValue Timestamp

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Timestamp :: CT

Methods

toCVal :: Timestamp -> CValue (ToCT Timestamp)

fromCVal :: CValue (ToCT Timestamp) -> Timestamp

IsoCValue Mutez

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Mutez :: CT

Methods

toCVal :: Mutez -> CValue (ToCT Mutez)

fromCVal :: CValue (ToCT Mutez) -> Mutez

IsoCValue Address

This instance erases reference to contract entrypoint! If this is an issue, use EpAddress instead.

Applications which use addresses just as participants identifiers should not experience problems with using plain Address.

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Address :: CT

Methods

toCVal :: Address -> CValue (ToCT Address)

fromCVal :: CValue (ToCT Address) -> Address

IsoCValue EpAddress

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT EpAddress :: CT

Methods

toCVal :: EpAddress -> CValue (ToCT EpAddress)

fromCVal :: CValue (ToCT EpAddress) -> EpAddress

class IsoValue a where

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 ToT a :: T

Type function that converts a regular Haskell type into a T type.

Methods

toVal :: a -> Value (ToT a)

Converts a Haskell structure into Value representation.

toVal :: (Generic a, GIsoValue (Rep a), ToT a ~ GValueType (Rep a)) => a -> Value (ToT a)

Converts a Haskell structure into Value representation.

fromVal :: Value (ToT a) -> a

Converts a Value into Haskell type.

fromVal :: (Generic a, GIsoValue (Rep a), ToT a ~ GValueType (Rep a)) => Value (ToT a) -> a

Converts a Value into Haskell type.

Instances

IsoValue Bool

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Bool :: T

Methods

toVal :: Bool -> Value (ToT Bool)

fromVal :: Value (ToT Bool) -> Bool

IsoValue Integer

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Integer :: T

Methods

toVal :: Integer -> Value (ToT Integer)

fromVal :: Value (ToT Integer) -> Integer

IsoValue Natural

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Natural :: T

Methods

toVal :: Natural -> Value (ToT Natural)

fromVal :: Value (ToT Natural) -> Natural

IsoValue ()

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT () :: T

Methods

toVal :: () -> Value (ToT ())

fromVal :: Value (ToT ()) -> ()

IsoValue ByteString

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT ByteString :: T

Methods

toVal :: ByteString -> Value (ToT ByteString)

fromVal :: Value (ToT ByteString) -> ByteString

(DoNotUseTextError :: Constraint) => IsoValue Text

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Text :: T

Methods

toVal :: Text -> Value (ToT Text)

fromVal :: Value (ToT Text) -> Text

IsoValue MText

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT MText :: T

Methods

toVal :: MText -> Value (ToT MText)

fromVal :: Value (ToT MText) -> MText

IsoValue KeyHash

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT KeyHash :: T

Methods

toVal :: KeyHash -> Value (ToT KeyHash)

fromVal :: Value (ToT KeyHash) -> KeyHash

IsoValue Signature

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Signature :: T

Methods

toVal :: Signature -> Value (ToT Signature)

fromVal :: Value (ToT Signature) -> Signature

IsoValue PublicKey

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT PublicKey :: T

Methods

toVal :: PublicKey -> Value (ToT PublicKey)

fromVal :: Value (ToT PublicKey) -> PublicKey

IsoValue ChainId

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT ChainId :: T

Methods

toVal :: ChainId -> Value (ToT ChainId)

fromVal :: Value (ToT ChainId) -> ChainId

IsoValue Timestamp

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Timestamp :: T

Methods

toVal :: Timestamp -> Value (ToT Timestamp)

fromVal :: Value (ToT Timestamp) -> Timestamp

IsoValue Mutez

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Mutez :: T

Methods

toVal :: Mutez -> Value (ToT Mutez)

fromVal :: Value (ToT Mutez) -> Mutez

IsoValue Address

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Address :: T

Methods

toVal :: Address -> Value (ToT Address)

fromVal :: Value (ToT Address) -> Address

IsoValue EpAddress

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT EpAddress :: T

Methods

toVal :: EpAddress -> Value (ToT EpAddress)

fromVal :: Value (ToT EpAddress) -> EpAddress

IsoValue Operation

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Operation :: T

Methods

toVal :: Operation -> Value (ToT Operation)

fromVal :: Value (ToT Operation) -> Operation

IsoValue MyCompoundType

Defined in Michelson.Typed.Haskell.Instr.Sum

Associated Types

type ToT MyCompoundType :: T

Methods

toVal :: MyCompoundType -> Value (ToT MyCompoundType)

fromVal :: Value (ToT MyCompoundType) -> MyCompoundType

IsoValue a => IsoValue [a]

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT [a] :: T

Methods

toVal :: [a] -> Value (ToT [a])

fromVal :: Value (ToT [a]) -> [a]

IsoValue a => IsoValue (Maybe a)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Maybe a) :: T

Methods

toVal :: Maybe a -> Value (ToT (Maybe a))

fromVal :: Value (ToT (Maybe a)) -> Maybe a

IsoValue a => IsoValue (Identity a)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Identity a) :: T

Methods

toVal :: Identity a -> Value (ToT (Identity a))

fromVal :: Value (ToT (Identity a)) -> Identity a

(Ord c, IsoCValue c) => IsoValue (Set c)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Set c) :: T

Methods

toVal :: Set c -> Value (ToT (Set c))

fromVal :: Value (ToT (Set c)) -> Set c

IsoValue (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (ContractRef arg) :: T

Methods

toVal :: ContractRef arg -> Value (ToT (ContractRef arg))

fromVal :: Value (ToT (ContractRef arg)) -> ContractRef arg

(IsoValue l, IsoValue r) => IsoValue (Either l r)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Either l r) :: T

Methods

toVal :: Either l r -> Value (ToT (Either l r))

fromVal :: Value (ToT (Either l r)) -> Either l r

(IsoValue a, IsoValue b) => IsoValue (a, b)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b) :: T

Methods

toVal :: (a, b) -> Value (ToT (a, b))

fromVal :: Value (ToT (a, b)) -> (a, b)

(Ord k, IsoCValue k, IsoValue v) => IsoValue (Map k v)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Map k v) :: T

Methods

toVal :: Map k v -> Value (ToT (Map k v))

fromVal :: Value (ToT (Map k v)) -> Map k v

(Ord k, IsoCValue k, IsoValue v) => IsoValue (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (BigMap k v) :: T

Methods

toVal :: BigMap k v -> Value (ToT (BigMap k v))

fromVal :: Value (ToT (BigMap k v)) -> BigMap k v

(IsoValue a, IsoValue b, IsoValue c) => IsoValue (a, b, c)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b, c) :: T

Methods

toVal :: (a, b, c) -> Value (ToT (a, b, c))

fromVal :: Value (ToT (a, b, c)) -> (a, b, c)

IsoValue a => IsoValue (NamedF Maybe a name)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (NamedF Maybe a name) :: T

Methods

toVal :: NamedF Maybe a name -> Value (ToT (NamedF Maybe a name))

fromVal :: Value (ToT (NamedF Maybe a name)) -> NamedF Maybe a name

IsoValue a => IsoValue (NamedF Identity a name)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (NamedF Identity a name) :: T

Methods

toVal :: NamedF Identity a name -> Value (ToT (NamedF Identity a name))

fromVal :: Value (ToT (NamedF Identity a name)) -> NamedF Identity a name

(IsoValue a, IsoValue b, IsoValue c, IsoValue d) => IsoValue (a, b, c, d)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b, c, d) :: T

Methods

toVal :: (a, b, c, d) -> Value (ToT (a, b, c, d))

fromVal :: Value (ToT (a, b, c, d)) -> (a, b, c, d)

(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e) => IsoValue (a, b, c, d, e)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b, c, d, e) :: T

Methods

toVal :: (a, b, c, d, e) -> Value (ToT (a, b, c, d, e))

fromVal :: Value (ToT (a, b, c, d, e)) -> (a, b, c, d, e)

(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e, IsoValue f) => IsoValue (a, b, c, d, e, f)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b, c, d, e, f) :: T

Methods

toVal :: (a, b, c, d, e, f) -> Value (ToT (a, b, c, d, e, f))

fromVal :: Value (ToT (a, b, c, d, e, f)) -> (a, b, c, d, e, f)

(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e, IsoValue f, IsoValue g) => IsoValue (a, b, c, d, e, f, g)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b, c, d, e, f, g) :: T

Methods

toVal :: (a, b, c, d, e, f, g) -> Value (ToT (a, b, c, d, e, f, g))

fromVal :: Value (ToT (a, b, c, d, e, f, g)) -> (a, b, c, d, e, f, g)

class GIsoValue (x :: Type -> Type)

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

Instances

GIsoValue (U1 :: Type -> Type)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type GValueType U1 :: T

Methods

gToValue :: U1 p -> Value (GValueType U1)

gFromValue :: Value (GValueType U1) -> U1 p

IsoValue a => GIsoValue (Rec0 a)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type GValueType (Rec0 a) :: T

Methods

gToValue :: Rec0 a p -> Value (GValueType (Rec0 a))

gFromValue :: Value (GValueType (Rec0 a)) -> Rec0 a p

(GIsoValue x, GIsoValue y) => GIsoValue (x :+: y)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type GValueType (x :+: y) :: T

Methods

gToValue :: (x :+: y) p -> Value (GValueType (x :+: y))

gFromValue :: Value (GValueType (x :+: y)) -> (x :+: y) p

(GIsoValue x, GIsoValue y) => GIsoValue (x :*: y)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type GValueType (x :*: y) :: T

Methods

gToValue :: (x :*: y) p -> Value (GValueType (x :*: y))

gFromValue :: Value (GValueType (x :*: y)) -> (x :*: y) p

GIsoValue x => GIsoValue (M1 t i x)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type GValueType (M1 t i x) :: T

Methods

gToValue :: M1 t i x p -> Value (GValueType (M1 t i x))

gFromValue :: Value (GValueType (M1 t i x)) -> M1 t i x p

type family ToT' (t :: k) :: T where ...

Overloaded version of ToT to work on Haskell and T types.

Equations

ToT' (t :: T) = t

ToT' (t :: Type) = ToT t

data SomeIsoValue where

Hides some Haskell value put in line with Michelson Value.

Constructors

SomeIsoValue :: (Typeable a, IsoValue a) => a -> SomeIsoValue

newtype AnyIsoValue

Any Haskell value which can be converted to Michelson Value.

Constructors

AnyIsoValue (forall a. IsoValue a => a)

type IsComparable c = ToT c ~ Tc (ToCT c)

A useful property which holds for all CT types.

type GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t))

Whether Michelson representation of the type is derived via Generics.

Missing Haskell analogies to Michelson values

type EntryPointCall param arg = EntryPointCallT (ToT param) (ToT arg)

type SomeEntryPointCall arg = SomeEntryPointCallT (ToT arg)

data ContractRef (arg :: Type)

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

• crAddress :: Address
• crEntryPoint :: SomeEntryPointCall arg

Instances

Eq (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Methods

(==) :: ContractRef arg -> ContractRef arg -> Bool

(/=) :: ContractRef arg -> ContractRef arg -> Bool

Show (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Methods

showsPrec :: Int -> ContractRef arg -> ShowS

show :: ContractRef arg -> String

showList :: [ContractRef arg] -> ShowS

Buildable (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Methods

build :: ContractRef arg -> Builder

IsoValue (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (ContractRef arg) :: T

Methods

toVal :: ContractRef arg -> Value (ToT (ContractRef arg))

fromVal :: Value (ToT (ContractRef arg)) -> ContractRef arg

PolyTypeHasDocC (cp ': ([] :: [Type])) => TypeHasDoc (ContractRef cp)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (ContractRef cp) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (ContractRef cp) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (ContractRef cp) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp)

typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp)

type ToT (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

type ToT (ContractRef arg) = TContract (ToT arg)

coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b

Replace type argument of ContractAddr with isomorphic one.

contractRefToAddr :: ContractRef cp -> EpAddress

newtype BigMap k v

Constructors

BigMap

Fields

• unBigMap :: Map k v

Instances

(Eq k, Eq v) => Eq (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

(==) :: BigMap k v -> BigMap k v -> Bool

(/=) :: BigMap k v -> BigMap k v -> Bool

(Show k, Show v) => Show (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

showsPrec :: Int -> BigMap k v -> ShowS

show :: BigMap k v -> String

showList :: [BigMap k v] -> ShowS

Ord k => Semigroup (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

(<>) :: BigMap k v -> BigMap k v -> BigMap k v

sconcat :: NonEmpty (BigMap k v) -> BigMap k v

stimes :: Integral b => b -> BigMap k v -> BigMap k v

Ord k => Monoid (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

mempty :: BigMap k v

mappend :: BigMap k v -> BigMap k v -> BigMap k v

mconcat :: [BigMap k v] -> BigMap k v

Default (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

def :: BigMap k v

(Ord k, IsoCValue k, IsoValue v) => IsoValue (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (BigMap k v) :: T

Methods

toVal :: BigMap k v -> Value (ToT (BigMap k v))

fromVal :: Value (ToT (BigMap k v)) -> BigMap k v

(PolyCTypeHasDocC (k ': ([] :: [Type])), PolyTypeHasDocC (v ': ([] :: [Type])), Ord k) => TypeHasDoc (BigMap k v)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (BigMap k v) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (BigMap k v) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (BigMap k v) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v)

typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v)

type ToT (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

type ToT (BigMap k v) = TBigMap (ToCT k) (ToT v)

Stack conversion

type family ToTs (ts :: [Type]) :: [T] where ...

Type function to convert a Haskell stack type to T-based one.

Equations

ToTs '[] = '[]

ToTs (x ': xs) = ToT x ': ToTs xs

type family ToTs' (t :: [k]) :: [T] where ...

Overloaded version of ToTs to work on Haskell and T stacks.

Equations

ToTs' (t :: [T]) = t

ToTs' (a :: [Type]) = ToTs a

class IsoValuesStack (ts :: [Type]) where

Isomorphism between Michelson stack and its Haskell reflection.

Methods

toValStack :: Rec Identity ts -> Rec Value (ToTs ts)

fromValStack :: Rec Value (ToTs ts) -> Rec Identity ts

Instances

IsoValuesStack ([] :: [Type])

Defined in Michelson.Typed.Haskell.Value

Methods

toValStack :: Rec Identity [] -> Rec Value (ToTs [])

fromValStack :: Rec Value (ToTs []) -> Rec Identity []

(IsoValue t, IsoValuesStack st) => IsoValuesStack (t ': st)

Defined in Michelson.Typed.Haskell.Value

Methods

toValStack :: Rec Identity (t ': st) -> Rec Value (ToTs (t ': st))

fromValStack :: Rec Value (ToTs (t ': st)) -> Rec Identity (t ': st)

totsKnownLemma :: forall s. KnownList s :- KnownList (ToTs s)

totsAppendLemma :: forall a b. KnownList a => Dict (ToTs (a ++ b) ~ (ToTs a ++ ToTs b))