Michelson.Typed.Haskell

Haskell-Michelson conversions.

Documentation

type Path = [Branch]

Path to a leaf (some field or constructor) in generic tree representation.

data Branch

Which branch to choose in generic tree representation: left, straight or right. S is used when there is one constructor with one field (something newtype-like).

The reason why we need S can be explained by this example: data A = A1 B | A2 Integer data B = B Bool Now we may search for A1 constructor or B constructor. Without S in both cases path will be the same ([L]).

Constructors

L

S

R

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)

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 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 GenericIsoValue t = (IsoValue t, Generic t, ToT t ~ GValueType (Rep t))

Whether Michelson representation of the type is derived via Generics.

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)

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

HasTypeAnn v => HasTypeAnn (BigMap k v)

Defined in Lorentz.TypeAnns

Methods

getTypeAnn :: Notes (ToT (BigMap k v))

(key ~ key', value ~ value', IsComparable key) => StoreHasSubmap (BigMap key' value') name key value

BigMap can be used as standalone key-value storage, name of submap is not accounted in this case.

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (BigMap key' value') name key value

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

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

cp ~ cp' => FromContractRef cp (ContractRef cp')

Defined in Lorentz.Value

Methods

fromContractRef :: ContractRef cp -> ContractRef cp'

cp ~ cp' => ToContractRef cp (ContractRef cp')

Defined in Lorentz.Value

Methods

toContractRef :: ContractRef cp' -> ContractRef cp

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)

ToAddress (ContractRef cp)

Defined in Lorentz.Value

Methods

toAddress :: ContractRef cp -> Address

HasTypeAnn a => HasTypeAnn (ContractRef a)

Defined in Lorentz.TypeAnns

Methods

getTypeAnn :: Notes (ToT (ContractRef a))

type ToT (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

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

type SomeEntryPointCall arg = SomeEntryPointCallT (ToT arg)

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

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

A useful property which holds for all CT types.

newtype AnyIsoValue

Any Haskell value which can be converted to Michelson Value.

Constructors

AnyIsoValue (forall a. IsoValue a => a)

data SomeIsoValue where

Hides some Haskell value put in line with Michelson Value.

Constructors

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

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

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 UnspecifiedError

Defined in Lorentz.Errors

Associated Types

type ToT UnspecifiedError :: T

Methods

toVal :: UnspecifiedError -> Value (ToT UnspecifiedError)

fromVal :: Value (ToT UnspecifiedError) -> UnspecifiedError

IsoValue Empty

Defined in Lorentz.Empty

Associated Types

type ToT Empty :: T

Methods

toVal :: Empty -> Value (ToT Empty)

fromVal :: Value (ToT Empty) -> Empty

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 a => IsoValue (ShouldHaveEntryPoints a)

Defined in Lorentz.EntryPoints.Helpers

Associated Types

type ToT (ShouldHaveEntryPoints a) :: T

Methods

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

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

IsoValue (FutureContract arg)

Defined in Lorentz.Value

Associated Types

type ToT (FutureContract arg) :: T

Methods

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

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

IsoValue (UStore a)

Defined in Lorentz.UStore.Types

Associated Types

type ToT (UStore a) :: T

Methods

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

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

(TypeError (Text "CustomError has no IsoValue instance") :: Constraint) => IsoValue (CustomError tag)

This instance cannot be implemented, use IsError instance instead.

Defined in Lorentz.Errors

Associated Types

type ToT (CustomError tag) :: T

Methods

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

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

(CustomErrorNoIsoValue (VoidResult r) :: Constraint) => 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 (UParam entries)

Defined in Lorentz.UParam

Associated Types

type ToT (UParam entries) :: T

Methods

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

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

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 (TAddress p)

Defined in Lorentz.Value

Associated Types

type ToT (TAddress p) :: T

Methods

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

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

IsoValue cp => IsoValue (ParameterWrapper deriv cp)

Defined in Lorentz.EntryPoints.Manual

Associated Types

type ToT (ParameterWrapper deriv cp) :: T

Methods

toVal :: ParameterWrapper deriv cp -> Value (ToT (ParameterWrapper deriv cp))

fromVal :: Value (ToT (ParameterWrapper deriv cp)) -> ParameterWrapper deriv cp

(ZipInstr inp, ZipInstr out) => IsoValue (inp :-> out)

Defined in Lorentz.Zip

Associated Types

type ToT (inp :-> out) :: T

Methods

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

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

IsoValue (Extensible x)

Defined in Lorentz.Extensible

Associated Types

type ToT (Extensible x) :: T

Methods

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

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

IsoValue (MigrationScript oldStore newStore)

Defined in Lorentz.UStore.Migration.Base

Associated Types

type ToT (MigrationScript oldStore newStore) :: T

Methods

toVal :: MigrationScript oldStore newStore -> Value (ToT (MigrationScript oldStore newStore))

fromVal :: Value (ToT (MigrationScript oldStore newStore)) -> MigrationScript oldStore newStore

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 (MUStore oldTemplate newTemplate remDiff touched)

Defined in Lorentz.UStore.Migration.Base

Associated Types

type ToT (MUStore oldTemplate newTemplate remDiff touched) :: T

Methods

toVal :: MUStore oldTemplate newTemplate remDiff touched -> Value (ToT (MUStore oldTemplate newTemplate remDiff touched))

fromVal :: Value (ToT (MUStore oldTemplate newTemplate remDiff touched)) -> MUStore oldTemplate newTemplate remDiff touched

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

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

Replace type argument of ContractAddr with isomorphic one.

contractRefToAddr :: ContractRef cp -> EpAddress

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

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

type InstrUnwrapC dt name = (GenericIsoValue dt, GInstrUnwrap (Rep dt) (LnrBranch (GetNamed name dt)) (CtorOnlyField name dt))

type family GCaseBranchInput ctor x :: CaseClauseParam

Instances

type GCaseBranchInput ctor (U1 :: Type -> Type)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseBranchInput ctor (U1 :: Type -> Type) = CaseClauseParam ctor NoFields

type GCaseBranchInput ctor (Rec0 a)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseBranchInput ctor (Rec0 a) = CaseClauseParam ctor (OneField a)

type GCaseBranchInput ctor (S1 i x)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseBranchInput ctor (S1 i x) = GCaseBranchInput ctor x

type GCaseBranchInput ctor (x :*: y)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseBranchInput ctor (x :*: y) = CaseClauseParam ctor NoFields

type family GCaseClauses x :: [CaseClauseParam]

Instances

type GCaseClauses (x :+: y)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseClauses (x :+: y) = GCaseClauses x ++ GCaseClauses y

type GCaseClauses (D1 i x)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseClauses (D1 i x) = GCaseClauses x

type GCaseClauses (C1 (MetaCons ctor _1 _2) x)

Defined in Michelson.Typed.Haskell.Instr.Sum

type GCaseClauses (C1 (MetaCons ctor _1 _2) x) = GCaseBranchInput ctor x ': ([] :: [CaseClauseParam])

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 :: RemFail 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 = (GenericIsoValue dt, GInstrCase (Rep 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 = (GenericIsoValue dt, GInstrWrap (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name 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 family IsPrimitiveValue (x :: Type) :: Bool where ...

Whether given type represents an atomic Michelson value.

Equations

IsPrimitiveValue (Maybe _) = True

IsPrimitiveValue (NamedF _ _ _) = True

IsPrimitiveValue Integer = True

IsPrimitiveValue Natural = True

IsPrimitiveValue Text = True

IsPrimitiveValue MText = True

IsPrimitiveValue Bool = True

IsPrimitiveValue ByteString = True

IsPrimitiveValue Mutez = True

IsPrimitiveValue Address = True

IsPrimitiveValue EpAddress = True

IsPrimitiveValue KeyHash = True

IsPrimitiveValue Timestamp = True

IsPrimitiveValue PublicKey = True

IsPrimitiveValue Signature = True

IsPrimitiveValue (ContractRef _) = True

IsPrimitiveValue (BigMap _ _) = True

IsPrimitiveValue (Map _ _) = True

IsPrimitiveValue (Set _) = True

IsPrimitiveValue [_] = True

IsPrimitiveValue (Operation' _) = True

IsPrimitiveValue _ = False

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) -> RemFail Instr (ToT dt ': inp) out

Pattern-match on the given datatype.

(//->) :: Label ("c" `AppendSymbol` ctor) -> RemFail 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.

type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep 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 = (GenericIsoValue dt, GInstrSetField name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name dt)))

Constraint for instrSetField.

type InstrGetFieldC dt name = (GenericIsoValue dt, GInstrGet name (Rep dt) (LnrBranch (GetNamed name dt)) (LnrFieldType (GetNamed name 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 LooseSumC dt = (Generic dt, GLooseSum (Rep dt))

Constraint for hsDecompose and hsCompose.

data ComposeResult a

Possible outcomes of an attempt to construct a Haskell ADT value from constructor name and relevant data.

Constructors

ComposeOk a

Composed fine.

ComposeCtorNotFound

No constructor with such name.

ComposeFieldTypeMismatch TypeRep TypeRep

Found required constructor, but type of data does not correspond to provided one.

Instances

Functor ComposeResult

Defined in Michelson.Typed.Haskell.LooseSum

Methods

fmap :: (a -> b) -> ComposeResult a -> ComposeResult b

(<$) :: a -> ComposeResult b -> ComposeResult a

Semigroup (ComposeResult a)

Defined in Michelson.Typed.Haskell.LooseSum

Methods

(<>) :: ComposeResult a -> ComposeResult a -> ComposeResult a

sconcat :: NonEmpty (ComposeResult a) -> ComposeResult a

stimes :: Integral b => b -> ComposeResult a -> ComposeResult a

Monoid (ComposeResult a)

Defined in Michelson.Typed.Haskell.LooseSum

Methods

mempty :: ComposeResult a

mappend :: ComposeResult a -> ComposeResult a -> ComposeResult a

mconcat :: [ComposeResult a] -> ComposeResult a

toTaggedVal :: LooseSumC dt => dt -> (Text, SomeValue)

Decompose Haskell type into constructor name and data it carries, converting the latter into Michelson Value.

fromTaggedVal :: LooseSumC dt => (Text, SomeValue) -> ComposeResult dt

Inverse to toTaggedVal.

type PolyTypeHasDocC ts = Each '[TypeHasDoc] ts

Constraint, required when deriving TypeHasDoc for polymorphic type with the least possible number of methods defined manually.

class GTypeHasDoc (x :: Type -> Type)

Generic traversal for automatic deriving of some methods in TypeHasDoc.

Minimal complete definition

gTypeDocHaskellRep

Instances

(TypeError (Text "Cannot derive documentation for void-like type") :: Constraint) => GTypeHasDoc (V1 :: Type -> Type)

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: ADTRep SomeTypeWithDoc

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

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: ADTRep SomeTypeWithDoc

GTypeHasDoc x => GTypeHasDoc (D1 i x)

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: ADTRep SomeTypeWithDoc

(GProductHasDoc x, KnownSymbol ctor) => GTypeHasDoc (C1 (MetaCons ctor _1 _2) x)

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: ADTRep SomeTypeWithDoc

class IsHomomorphic a

Require this type to be homomorphic.

Instances

IsHomomorphic (a :: k)

Defined in Michelson.Typed.Haskell.Doc

(TypeError (Text "Type is not homomorphic: " :<>: ShowType (a b)) :: Constraint) => IsHomomorphic (a b :: k2)

Defined in Michelson.Typed.Haskell.Doc

class HaveCommonTypeCtor a b

Require two types to be built from the same type constructor.

E.g. HaveCommonTypeCtor (Maybe Integer) (Maybe Natural) is defined, while HaveCmmonTypeCtor (Maybe Integer) [Integer] is not.

Instances

HaveCommonTypeCtor (a :: k) (a :: k)

Defined in Michelson.Typed.Haskell.Doc

HaveCommonTypeCtor ac bc => HaveCommonTypeCtor (ac a :: k4) (bc b :: k2)

Defined in Michelson.Typed.Haskell.Doc

newtype DStorageType

Doc element with description of contract storage type.

Constructors

DStorageType DType

Instances

DocItem DStorageType

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type DocItemPosition DStorageType = (pos :: Nat)

type DocItemPlacement DStorageType :: DocItemPlacementKind

Methods

docItemSectionName :: Maybe Text

docItemSectionDescription :: Maybe Markdown

docItemSectionNameStyle :: DocSectionNameStyle

docItemRef :: DStorageType -> DocItemRef (DocItemPlacement DStorageType)

docItemToMarkdown :: HeaderLevel -> DStorageType -> Markdown

docItemDependencies :: DStorageType -> [SomeDocDefinitionItem]

docItemsOrder :: [DStorageType] -> [DStorageType]

type DocItemPosition DStorageType

Defined in Michelson.Typed.Haskell.Doc

type DocItemPosition DStorageType = 2035

type DocItemPlacement DStorageType

Defined in Michelson.Typed.Haskell.Doc

type DocItemPlacement DStorageType = DocItemInlined

data DType where

Doc element with description of a type.

Constructors

DType :: TypeHasDoc a => Proxy a -> DType

Instances

Eq DType

Defined in Michelson.Typed.Haskell.Doc

Methods

(==) :: DType -> DType -> Bool

(/=) :: DType -> DType -> Bool

Ord DType

Defined in Michelson.Typed.Haskell.Doc

Methods

compare :: DType -> DType -> Ordering

(<) :: DType -> DType -> Bool

(<=) :: DType -> DType -> Bool

(>) :: DType -> DType -> Bool

(>=) :: DType -> DType -> Bool

max :: DType -> DType -> DType

min :: DType -> DType -> DType

Show DType

Defined in Michelson.Typed.Haskell.Doc

Methods

showsPrec :: Int -> DType -> ShowS

show :: DType -> String

showList :: [DType] -> ShowS

DocItem DType

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type DocItemPosition DType = (pos :: Nat)

type DocItemPlacement DType :: DocItemPlacementKind

Methods

docItemSectionName :: Maybe Text

docItemSectionDescription :: Maybe Markdown

docItemSectionNameStyle :: DocSectionNameStyle

docItemRef :: DType -> DocItemRef (DocItemPlacement DType)

docItemToMarkdown :: HeaderLevel -> DType -> Markdown

docItemDependencies :: DType -> [SomeDocDefinitionItem]

docItemsOrder :: [DType] -> [DType]

type DocItemPosition DType

Defined in Michelson.Typed.Haskell.Doc

type DocItemPosition DType = 5000

type DocItemPlacement DType

Defined in Michelson.Typed.Haskell.Doc

type DocItemPlacement DType = DocItemInDefinitions

data SomeTypeWithDoc where

Data hides some type implementing TypeHasDoc.

Constructors

SomeTypeWithDoc :: TypeHasDoc td => Proxy td -> SomeTypeWithDoc

type TypeDocMichelsonRep a = Proxy a -> (Maybe DocTypeRepLHS, T)

Signature of typeDocMichelsonRep function.

As in TypeDocHaskellRep, set the first element of the pair to Nothing for primitive types, otherwise it stands as some instantiation of a type, and its Michelson representation is given in the second element of the pair.

Examples of rendered representation: * pair int nat - for homomorphic type. * MyError Integer = pair string int - concrete sample for polymorhpic type.

type TypeDocHaskellRep a = Proxy a -> Maybe (Maybe DocTypeRepLHS, ADTRep SomeTypeWithDoc)

Signature of typeDocHaskellRep function.

When value is Just, it contains types which this type is built from.

First element of provided pair may contain name a concrete type which has the same type constructor as a (or just a for homomorphic types), and the second element of the pair - its unfolding in Haskell.

For example, for some newtype MyNewtype = MyNewtype (Integer, Natural) we would not specify the first element in the pair because MyNewtype is already a concrete type, and second element would contain (Integer, Natural). For polymorhpic types like newtype MyPolyNewtype a = MyPolyNewtype (Text, a), we want to describe its representation on some example of a, because working with type variables is too non-trivial; so the first element of the pair may be e.g. "MyPolyNewType Integer", and the second one shows that it unfolds to (Text, Integer).

When rendered, values of this type look like: * (Integer, Natural) - for homomorphic type. * MyError Integer = (Text, Integer) - concrete sample for polymorhpic type.

class Typeable a => TypeHasDoc a where

Description for a Haskell type appearing in documentation.

Minimal complete definition

typeDocMdDescription

Methods

typeDocName :: Proxy a -> Text

Name of type as it appears in definitions section.

Each type must have its own unique name because it will be used in identifier for references.

Default definition derives name from Generics. If it does not fit, consider defining this function manually. (We tried using Data for this, but it produces names including module names which is not do we want).

typeDocName :: (Generic a, KnownSymbol (GenericTypeName a)) => Proxy a -> Text

Name of type as it appears in definitions section.

Each type must have its own unique name because it will be used in identifier for references.

Default definition derives name from Generics. If it does not fit, consider defining this function manually. (We tried using Data for this, but it produces names including module names which is not do we want).

typeDocMdDescription :: Markdown

Explanation of a type. Markdown formatting is allowed.

typeDocMdReference :: Proxy a -> WithinParens -> Markdown

How reference to this type is rendered, in Markdown.

Examples: * Integer, * Maybe ().

Consider using one of the following functions as default implementation; which one to use depends on number of type arguments in your type: * homomorphicTypeDocMdReference * poly1TypeDocMdReference * poly2TypeDocMdReference

If none of them fits your purposes precisely, consider using customTypeDocMdReference.

typeDocMdReference :: (Typeable a, IsHomomorphic a) => Proxy a -> WithinParens -> Markdown

How reference to this type is rendered, in Markdown.

Examples: * Integer, * Maybe ().

Consider using one of the following functions as default implementation; which one to use depends on number of type arguments in your type: * homomorphicTypeDocMdReference * poly1TypeDocMdReference * poly2TypeDocMdReference

If none of them fits your purposes precisely, consider using customTypeDocMdReference.

typeDocDependencies :: Proxy a -> [SomeTypeWithDoc]

All types which this type directly contains.

Used in automatic types discovery.

typeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeTypeWithDoc]

All types which this type directly contains.

Used in automatic types discovery.

typeDocHaskellRep :: TypeDocHaskellRep a

For complex types - their immediate Haskell representation.

For primitive types set this to Nothing.

For homomorphic types use homomorphicTypeDocHaskellRep implementation.

For polymorhpic types consider using concreteTypeDocHaskellRep as implementation.

Modifier haskellRepNoFields can be used to hide names of fields, beneficial for newtypes.

Another modifier called haskellRepStripFieldPrefix can be used for datatypes to leave only meaningful part of name in every field.

typeDocHaskellRep :: (Generic a, GTypeHasDoc (Rep a), IsHomomorphic a) => TypeDocHaskellRep a

For complex types - their immediate Haskell representation.

For primitive types set this to Nothing.

For homomorphic types use homomorphicTypeDocHaskellRep implementation.

For polymorhpic types consider using concreteTypeDocHaskellRep as implementation.

Modifier haskellRepNoFields can be used to hide names of fields, beneficial for newtypes.

Another modifier called haskellRepStripFieldPrefix can be used for datatypes to leave only meaningful part of name in every field.

typeDocMichelsonRep :: TypeDocMichelsonRep a

Final michelson representation of a type.

For homomorphic types use homomorphicTypeDocMichelsonRep implementation.

For polymorhpic types consider using concreteTypeDocMichelsonRep as implementation.

typeDocMichelsonRep :: (SingI (ToT a), IsHomomorphic a) => TypeDocMichelsonRep a

Final michelson representation of a type.

For homomorphic types use homomorphicTypeDocMichelsonRep implementation.

For polymorhpic types consider using concreteTypeDocMichelsonRep as implementation.

Instances

TypeHasDoc Bool

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Bool -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Bool -> WithinParens -> Markdown

typeDocDependencies :: Proxy Bool -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Bool

typeDocMichelsonRep :: TypeDocMichelsonRep Bool

TypeHasDoc Integer

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Integer -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Integer -> WithinParens -> Markdown

typeDocDependencies :: Proxy Integer -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Integer

typeDocMichelsonRep :: TypeDocMichelsonRep Integer

TypeHasDoc Natural

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Natural -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Natural -> WithinParens -> Markdown

typeDocDependencies :: Proxy Natural -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Natural

typeDocMichelsonRep :: TypeDocMichelsonRep Natural

TypeHasDoc ()

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy () -> Text

typeDocMdDescription :: Markdown

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

typeDocDependencies :: Proxy () -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep ()

typeDocMichelsonRep :: TypeDocMichelsonRep ()

TypeHasDoc ByteString

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy ByteString -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy ByteString -> WithinParens -> Markdown

typeDocDependencies :: Proxy ByteString -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep ByteString

typeDocMichelsonRep :: TypeDocMichelsonRep ByteString

TypeHasDoc MText

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy MText -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy MText -> WithinParens -> Markdown

typeDocDependencies :: Proxy MText -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep MText

typeDocMichelsonRep :: TypeDocMichelsonRep MText

TypeHasDoc KeyHash

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy KeyHash -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy KeyHash -> WithinParens -> Markdown

typeDocDependencies :: Proxy KeyHash -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep KeyHash

typeDocMichelsonRep :: TypeDocMichelsonRep KeyHash

TypeHasDoc Signature

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Signature -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Signature -> WithinParens -> Markdown

typeDocDependencies :: Proxy Signature -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Signature

typeDocMichelsonRep :: TypeDocMichelsonRep Signature

TypeHasDoc PublicKey

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy PublicKey -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy PublicKey -> WithinParens -> Markdown

typeDocDependencies :: Proxy PublicKey -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep PublicKey

typeDocMichelsonRep :: TypeDocMichelsonRep PublicKey

TypeHasDoc Timestamp

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Timestamp -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Timestamp -> WithinParens -> Markdown

typeDocDependencies :: Proxy Timestamp -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Timestamp

typeDocMichelsonRep :: TypeDocMichelsonRep Timestamp

TypeHasDoc Mutez

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Mutez -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Mutez -> WithinParens -> Markdown

typeDocDependencies :: Proxy Mutez -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Mutez

typeDocMichelsonRep :: TypeDocMichelsonRep Mutez

TypeHasDoc Address

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Address -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Address -> WithinParens -> Markdown

typeDocDependencies :: Proxy Address -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Address

typeDocMichelsonRep :: TypeDocMichelsonRep Address

TypeHasDoc EpAddress

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy EpAddress -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown

typeDocDependencies :: Proxy EpAddress -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep EpAddress

typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress

TypeHasDoc Operation

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy Operation -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown

typeDocDependencies :: Proxy Operation -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Operation

typeDocMichelsonRep :: TypeDocMichelsonRep Operation

TypeHasDoc Empty

Defined in Lorentz.Empty

Methods

typeDocName :: Proxy Empty -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Empty -> WithinParens -> Markdown

typeDocDependencies :: Proxy Empty -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep Empty

typeDocMichelsonRep :: TypeDocMichelsonRep Empty

PolyTypeHasDocC (a ': ([] :: [Type])) => TypeHasDoc [a]

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy [a] -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy [a] -> WithinParens -> Markdown

typeDocDependencies :: Proxy [a] -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep [a]

typeDocMichelsonRep :: TypeDocMichelsonRep [a]

PolyTypeHasDocC (a ': ([] :: [Type])) => TypeHasDoc (Maybe a)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (Maybe a) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (Maybe a) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (Maybe a) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (Maybe a)

typeDocMichelsonRep :: TypeDocMichelsonRep (Maybe a)

PolyCTypeHasDocC (a ': ([] :: [Type])) => TypeHasDoc (Set a)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (Set a) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (Set a) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (Set a) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (Set a)

typeDocMichelsonRep :: TypeDocMichelsonRep (Set a)

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)

Typeable template => TypeHasDoc (UStore template)

Defined in Lorentz.UStore.Types

Methods

typeDocName :: Proxy (UStore template) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (UStore template) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (UStore template) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (UStore template)

typeDocMichelsonRep :: TypeDocMichelsonRep (UStore template)

(TypeHasDoc r, IsError (VoidResult r)) => TypeHasDoc (VoidResult r)

Defined in Lorentz.Macro

Methods

typeDocName :: Proxy (VoidResult r) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (VoidResult r) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (VoidResult r) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (VoidResult r)

typeDocMichelsonRep :: TypeDocMichelsonRep (VoidResult r)

Typeable interface => TypeHasDoc (UParam interface)

Defined in Lorentz.UParam

Methods

typeDocName :: Proxy (UParam interface) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (UParam interface) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (UParam interface) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (UParam interface)

typeDocMichelsonRep :: TypeDocMichelsonRep (UParam interface)

PolyTypeHasDocC (l ': (r ': ([] :: [Type]))) => TypeHasDoc (Either l r)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (Either l r) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (Either l r) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (Either l r) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (Either l r)

typeDocMichelsonRep :: TypeDocMichelsonRep (Either l r)

PolyTypeHasDocC (a ': (b ': ([] :: [Type]))) => TypeHasDoc (a, b)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (a, b) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (a, b) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (a, b) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (a, b)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b)

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

Defined in Michelson.Typed.Haskell.Doc

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (Map k v)

typeDocMichelsonRep :: TypeDocMichelsonRep (Map 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)

Each ((Typeable :: [Type] -> Constraint) ': (ReifyList TypeHasDoc ': ([] :: [[Type] -> Constraint]))) (i ': (o ': ([] :: [[Type]]))) => TypeHasDoc (i :-> o)

Defined in Lorentz.Doc

Methods

typeDocName :: Proxy (i :-> o) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (i :-> o) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (i :-> o) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (i :-> o)

typeDocMichelsonRep :: TypeDocMichelsonRep (i :-> o)

(ExtensibleHasDoc x, ReifyList DocumentCtor (EnumerateCtors (GetCtors x))) => TypeHasDoc (Extensible x)

Defined in Lorentz.Extensible

Methods

typeDocName :: Proxy (Extensible x) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (Extensible x) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (Extensible x) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (Extensible x)

typeDocMichelsonRep :: TypeDocMichelsonRep (Extensible x)

(Typeable oldStore, Typeable newStore) => TypeHasDoc (MigrationScript oldStore newStore)

Defined in Lorentz.UStore.Migration.Base

Methods

typeDocName :: Proxy (MigrationScript oldStore newStore) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (MigrationScript oldStore newStore) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (MigrationScript oldStore newStore) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (MigrationScript oldStore newStore)

typeDocMichelsonRep :: TypeDocMichelsonRep (MigrationScript oldStore newStore)

Each ((Typeable :: Type -> Constraint) ': (TypeHasDoc ': ([] :: [Type -> Constraint]))) (a ': (r ': ([] :: [Type]))) => TypeHasDoc (Void_ a r)

Defined in Lorentz.Macro

Methods

typeDocName :: Proxy (Void_ a r) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (Void_ a r) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (Void_ a r) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (Void_ a r)

typeDocMichelsonRep :: TypeDocMichelsonRep (Void_ a r)

Each ((Typeable :: Type -> Constraint) ': (TypeHasDoc ': ([] :: [Type -> Constraint]))) (a ': (r ': ([] :: [Type]))) => TypeHasDoc (View a r)

Defined in Lorentz.Macro

Methods

typeDocName :: Proxy (View a r) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (View a r) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (View a r) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (View a r)

typeDocMichelsonRep :: TypeDocMichelsonRep (View a r)

PolyTypeHasDocC (a ': (b ': (c ': ([] :: [Type])))) => TypeHasDoc (a, b, c)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (a, b, c) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (a, b, c) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (a, b, c) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (a, b, c)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c)

(TypeHasDoc (ApplyNamedFunctor f a), KnownSymbol n, SingI (ToT (ApplyNamedFunctor f Integer)), Typeable f, Typeable a) => TypeHasDoc (NamedF f a n)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (NamedF f a n) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (NamedF f a n) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (NamedF f a n) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (NamedF f a n)

typeDocMichelsonRep :: TypeDocMichelsonRep (NamedF f a n)

PolyTypeHasDocC (a ': (b ': (c ': (d ': ([] :: [Type]))))) => TypeHasDoc (a, b, c, d)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (a, b, c, d) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (a, b, c, d) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (a, b, c, d) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d)

PolyTypeHasDocC (a ': (b ': (c ': (d ': (e ': ([] :: [Type])))))) => TypeHasDoc (a, b, c, d, e)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (a, b, c, d, e) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (a, b, c, d, e) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (a, b, c, d, e) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e)

PolyTypeHasDocC (a ': (b ': (c ': (d ': (e ': (f ': ([] :: [Type]))))))) => TypeHasDoc (a, b, c, d, e, f)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (a, b, c, d, e, f) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (a, b, c, d, e, f) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (a, b, c, d, e, f) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e, f)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e, f)

PolyTypeHasDocC (a ': (b ': (c ': (d ': (e ': (f ': (g ': ([] :: [Type])))))))) => TypeHasDoc (a, b, c, d, e, f, g)

Defined in Michelson.Typed.Haskell.Doc

Methods

typeDocName :: Proxy (a, b, c, d, e, f, g) -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy (a, b, c, d, e, f, g) -> WithinParens -> Markdown

typeDocDependencies :: Proxy (a, b, c, d, e, f, g) -> [SomeTypeWithDoc]

typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e, f, g)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e, f, g)

newtype WithinParens

Whether given text should be rendered grouped in parentheses (if they make sense).

Constructors

WithinParens Bool

type ADTRep a = NonEmpty (Text, [(Maybe Text, a)])

Stands for representation of some Haskell ADT corresponding to Michelson value. Type parameter a is what you put in place of each field of the datatype, e.g. information about field type.

Outer list layer corresponds to union, and the inner one corresponds to products within constructors. Constructors and fields names are present.

buildADTRep :: forall a. (WithinParens -> a -> Markdown) -> ADTRep a -> Markdown

Show given ADTRep in a neat way.

applyWithinParens :: WithinParens -> Markdown -> Markdown

typeDocDependencies' :: TypeHasDoc a => Proxy a -> [SomeDocDefinitionItem]

Like typeDocDependencies but returns values of more common type which is used in docItemDependencies.

customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown

Render a reference to a type which consists of type constructor (you have to provide name of this type constructor and documentation for the whole type) and zero or more type arguments.

homomorphicTypeDocMdReference :: forall (t :: Type). (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown

Derive typeDocMdReference, for homomorphic types only.

poly1TypeDocMdReference :: forall t (r :: Type) (a :: Type). (r ~ t a, Typeable t, Each '[TypeHasDoc] [r, a], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown

Derive typeDocMdReference, for polymorphic type with one type argument, like Maybe Integer.

poly2TypeDocMdReference :: forall t (r :: Type) (a :: Type) (b :: Type). (r ~ t a b, Typeable t, Each '[TypeHasDoc] [r, a, b], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown

Derive typeDocMdReference, for polymorphic type with two type arguments, like Lambda Integer Natural.

genericTypeDocDependencies :: forall a. (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeTypeWithDoc]

Implement typeDocDependencies via getting all immediate fields of a datatype.

Note: this will not include phantom types, I'm not sure yet how this scenario should be handled (@martoon).

homomorphicTypeDocHaskellRep :: forall a. (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a

Implement typeDocHaskellRep for a homomorphic type.

Note that it does not require your type to be of IsHomomorphic instance, which can be useful for some polymorhpic types which, for documentation purposes, we want to consider homomorphic. Example: Operation is in fact polymorhpic, but we don't want this fact to be reflected in the documentation.

concreteTypeDocHaskellRep :: forall a b. (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b

Implement typeDocHaskellRep on example of given concrete type.

This is a best effort attempt to implement typeDocHaskellRep for polymorhpic types, as soon as there is no simple way to preserve type variables when automatically deriving Haskell representation of a type.

concreteTypeDocHaskellRepUnsafe :: forall a b. (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b

Version of concreteTypeDocHaskellRep which does not ensure whether the type for which representation is built is any similar to the original type which you implement a TypeHasDoc instance for.

haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a

Erase fields from Haskell datatype representation.

Use this when rendering fields names is undesired.

haskellRepStripFieldPrefix :: HasCallStack => TypeDocHaskellRep a -> TypeDocHaskellRep a

Cut fields prefixes which we use according to the style guide.

E.g. cmMyField field will be transformed to myField.

homomorphicTypeDocMichelsonRep :: forall a. SingI (ToT a) => TypeDocMichelsonRep a

Implement typeDocMichelsonRep for homomorphic type.

concreteTypeDocMichelsonRep :: forall a b. (Typeable a, SingI (ToT a), HaveCommonTypeCtor b a) => TypeDocMichelsonRep b

Implement typeDocMichelsonRep on example of given concrete type.

This function exists for the same reason as concreteTypeDocHaskellRep.

concreteTypeDocMichelsonRepUnsafe :: forall a b. (Typeable a, SingI (ToT a)) => TypeDocMichelsonRep b

Version of concreteTypeDocHaskellRepUnsafe which does not ensure whether the type for which representation is built is any similar to the original type which you implement a TypeHasDoc instance for.