Michelson.Typed.Haskell

Haskell-Michelson conversions.

Documentation

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

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)

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

A useful property which holds for all CT types.

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

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

type InstrConstructC dt = (IsoValue dt, Generic dt, GInstrConstruct (Rep dt), GValueType (Rep dt) ~ ToT dt)

Constraint for instrConstruct.

type ConstructorFieldTypes dt = GFieldTypes (Rep dt)

Types of all fields in a datatype.

newtype FieldConstructor (st :: [k]) (field :: Type)

Way to construct one of the fields in a complex datatype.

Constructors

FieldConstructor (Instr (ToTs' st) (ToT field ': ToTs' st))

type InstrSetFieldC dt name = (IsoValue dt, Generic dt, GInstrSetField name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)), GValueType (Rep dt) ~ ToT dt)

Constraint for instrSetField.

type InstrGetFieldC dt name = (IsoValue dt, Generic dt, GInstrGet name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)), GValueType (Rep dt) ~ ToT dt)

Constraint for instrGetField.

type GetFieldType dt name = LnrFieldType (GetNamed name dt)

Get type of field by datatype it is contained in and field name.

instrGetField :: forall dt name st. InstrGetFieldC dt name => Label name -> Instr (ToT dt ': st) (ToT (GetFieldType dt name) ': st)

Make an instruction which accesses given field of the given datatype.

instrSetField :: forall dt name st. InstrSetFieldC dt name => Label name -> Instr (ToT (GetFieldType dt name) ': (ToT dt ': st)) (ToT dt ': st)

For given complex type dt and its field fieldTy update the field value.

instrConstruct :: forall dt st. InstrConstructC dt => Rec (FieldConstructor st) (ConstructorFieldTypes dt) -> Instr st (ToT dt ': st)

For given complex type dt and its field fieldTy update the field value.

type InstrUnwrapC dt name = (IsoValue dt, Generic dt, GInstrUnwrap (Rep dt) (LnrBranch (GetNamed name dt)) (CtorOnlyField name dt), GValueType (Rep dt) ~ ToT dt)

type CaseClauses a = GCaseClauses (Rep a)

List of CaseClauseParams required to pattern match on the given type.

data CaseClause (inp :: [T]) (out :: [T]) (param :: CaseClauseParam) where

Type information about single case clause.

Constructors

CaseClause :: Instr (AppendCtorField x inp) out -> CaseClause inp out (CaseClauseParam ctor x)

data CaseClauseParam

In what different case branches differ - related constructor name and input stack type which the branch starts with.

Constructors

CaseClauseParam Symbol CtorField

type InstrCaseC dt inp out = (IsoValue dt, GInstrCase (Rep dt), GValueType (Rep dt) ~ ToT dt)

data MyCompoundType

Instances

Generic MyCompoundType

Defined in Michelson.Typed.Haskell.Instr.Sum

Associated Types

type Rep MyCompoundType :: Type -> Type

Methods

from :: MyCompoundType -> Rep MyCompoundType x

to :: Rep MyCompoundType x -> MyCompoundType

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

type Rep MyCompoundType

Defined in Michelson.Typed.Haskell.Instr.Sum

type Rep MyCompoundType

type ToT MyCompoundType

Defined in Michelson.Typed.Haskell.Instr.Sum

type ToT MyCompoundType = GValueType (Rep MyCompoundType)

type InstrWrapC dt name = (IsoValue dt, Generic dt, GInstrWrap (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)), GValueType (Rep dt) ~ ToT dt)

type CtorOnlyField name dt = RequireOneField name (GetCtorField dt name)

Expect referred constructor to have only one field (otherwise compile error is raised) and extract its type.

type CtorHasOnlyField ctor dt f = GetCtorField dt ctor ~ OneField f

Expect referred constructor to have only one field (in form of constraint) and extract its type.

type GetCtorField dt ctor = LnrFieldType (GetNamed ctor dt)

Get type of constructor fields (one or zero) referred by given datatype and name.

type AppendCtorFieldAxiom (cf :: CtorField) (st :: [Type]) = ToTs (AppendCtorField cf st) ~ AppendCtorField cf (ToTs st)

To use AppendCtorField not only here for T-based stacks, but also later in Lorentz with Type-based stacks we need the following property.

type family AppendCtorField (cf :: CtorField) (l :: [k]) :: [k] where ...

Push field to stack, if any.

Equations

AppendCtorField (OneField t) (l :: [T]) = ToT t ': l

AppendCtorField (OneField t) (l :: [Type]) = t ': l

AppendCtorField NoFields (l :: [T]) = l

AppendCtorField NoFields (l :: [Type]) = l

type family ExtractCtorField (cf :: CtorField) where ...

Get something as field of the given constructor.

Equations

ExtractCtorField (OneField t) = t

ExtractCtorField NoFields = ()

data CtorField

We support only two scenarious - constructor with one field and without fields. Nonetheless, it's not that sad since for sum types we can't even assign names to fields if there are many (the style guide prohibits partial records).

Constructors

OneField Type

NoFields

appendCtorFieldAxiom :: (AppendCtorFieldAxiom (OneField Word) '[Int], AppendCtorFieldAxiom NoFields '[Int]) => Dict (AppendCtorFieldAxiom cf st)

Proof of AppendCtorFieldAxiom.

instrWrap :: forall dt name st. InstrWrapC dt name => Label name -> Instr (AppendCtorField (GetCtorField dt name) st) (ToT dt ': st)

Wrap given element into a constructor with the given name.

Mentioned constructor must have only one field.

Since labels interpretable by OverloadedLabels extension cannot start with capital latter, prepend constructor name with letter "c" (see examples below).

hsWrap :: forall dt name. InstrWrapC dt name => Label name -> ExtractCtorField (GetCtorField dt name) -> dt

Wrap a haskell value into a constructor with the given name.

This is symmetric to instrWrap.

instrCase :: forall dt out inp. InstrCaseC dt inp out => Rec (CaseClause inp out) (CaseClauses dt) -> Instr (ToT dt ': inp) out

Pattern-match on the given datatype.

(//->) :: Label ("c" `AppendSymbol` ctor) -> Instr (AppendCtorField x inp) out -> CaseClause inp out (CaseClauseParam ctor x) infixr 8

Lift an instruction to case clause.

You should write out constructor name corresponding to the clause explicitly. Prefix constructor name with "c" letter, otherwise your label will not be recognized by Haskell parser. Passing constructor name can be circumvented but doing so is not recomended as mentioning contructor name improves readability and allows avoiding some mistakes.

instrUnwrapUnsafe :: forall dt name st. InstrUnwrapC dt name => Label name -> Instr (ToT dt ': st) (ToT (CtorOnlyField name dt) ': st)

Unwrap a constructor with the given name.

Rules which apply to instrWrap function work here as well. Although, unlike instrWrap, this function does not work for nullary constructors.

hsUnwrap :: forall dt name. InstrUnwrapC dt name => Label name -> dt -> Maybe (CtorOnlyField name dt)

Try to unwrap a constructor with the given name.