Michelson.Typed.Haskell.Value

Conversions between haskell types/values and Michelson ones.

Documentation

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 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 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 Address

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToCT Address :: CT

Methods

toCVal :: Address -> CValue (ToCT Address)

fromCVal :: CValue (ToCT Address) -> Address

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 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 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 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 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 (ContractAddr cp)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (ContractAddr cp) :: T

Methods

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

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

IsoValue r => IsoValue (VoidResult r)

Defined in Lorentz.Macro

Associated Types

type ToT (VoidResult r) :: T

Methods

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

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

IsoValue a => IsoValue (Store a)

Defined in Lorentz.Store

Associated Types

type ToT (Store a) :: T

Methods

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

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

(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 (Lambda inp out)

Defined in Lorentz.Base

Associated Types

type ToT (Lambda inp out) :: T

Methods

toVal :: Lambda inp out -> Value (ToT (Lambda inp out))

fromVal :: Value (ToT (Lambda inp out)) -> Lambda inp out

IsoValue a => IsoValue (Void_ a b)

Defined in Lorentz.Macro

Associated Types

type ToT (Void_ a b) :: T

Methods

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

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

IsoValue a => IsoValue (View a r)

Defined in Lorentz.Macro

Associated Types

type ToT (View a r) :: T

Methods

toVal :: View a r -> Value (ToT (View a r))

fromVal :: Value (ToT (View a r)) -> View a r

(IsoValue storeTemplate, IsoValue other) => IsoValue (StorageSkeleton storeTemplate other)

Defined in Lorentz.Store

Associated Types

type ToT (StorageSkeleton storeTemplate other) :: T

Methods

toVal :: StorageSkeleton storeTemplate other -> Value (ToT (StorageSkeleton storeTemplate other))

fromVal :: Value (ToT (StorageSkeleton storeTemplate other)) -> StorageSkeleton storeTemplate other

(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 v => IsoValue (k2 |-> v)

Defined in Lorentz.Store

Associated Types

type ToT (k2 |-> v) :: T

Methods

toVal :: (k2 |-> v) -> Value (ToT (k2 |-> v))

fromVal :: Value (ToT (k2 |-> v)) -> k2 |-> v

(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 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 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

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

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

A useful property which holds for all CT types.

newtype ContractAddr (cp :: Type)

Since Contract name is used to designate contract code, lets call analogy of TContract type as follows.

Constructors

ContractAddr

Fields

• unContractAddress :: Address

Instances

IsoValue (ContractAddr cp)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (ContractAddr cp) :: T

Methods

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

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

type ToT (ContractAddr cp)

Defined in Michelson.Typed.Haskell.Value

type ToT (ContractAddr cp) = TContract (ToT cp)

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

IsComparable k => GetOpHs (BigMap k v)

Defined in Lorentz.Polymorphic

Associated Types

type GetOpKeyHs (BigMap k v) :: Type

type GetOpValHs (BigMap k v) :: Type

IsComparable k => UpdOpHs (BigMap k v)

Defined in Lorentz.Polymorphic

Associated Types

type UpdOpKeyHs (BigMap k v) :: Type

type UpdOpParamsHs (BigMap k v) :: Type

IsComparable k => MemOpHs (BigMap k v)

Defined in Lorentz.Polymorphic

Associated Types

type MemOpKeyHs (BigMap k v) :: Type

type ToT (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

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

type GetOpKeyHs (BigMap k v)

Defined in Lorentz.Polymorphic

type GetOpKeyHs (BigMap k v) = k

type GetOpValHs (BigMap k v)

Defined in Lorentz.Polymorphic

type GetOpValHs (BigMap k v) = v

type UpdOpKeyHs (BigMap k v)

Defined in Lorentz.Polymorphic

type UpdOpKeyHs (BigMap k v) = k

type UpdOpParamsHs (BigMap k v)

Defined in Lorentz.Polymorphic

type UpdOpParamsHs (BigMap k v) = Maybe v

type MemOpKeyHs (BigMap k v)

Defined in Lorentz.Polymorphic

type MemOpKeyHs (BigMap k v) = k