Michelson.Typed.Haskell

Haskell-Michelson conversions.

Documentation

data Dict a where

Values of type Dict p capture a dictionary for a constraint of type p.

e.g.

Dict :: Dict (Eq Int)

captures a dictionary that proves we have an:

instance Eq 'Int

Pattern matching on the Dict constructor will bring this instance into scope.

Constructors

Dict :: forall a. a => Dict a

Instances

HasDict a (Dict a)

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

a => Bounded (Dict a)

Defined in Data.Constraint

Methods

minBound :: Dict a

maxBound :: Dict a

a => Enum (Dict a)

Defined in Data.Constraint

Methods

succ :: Dict a -> Dict a

pred :: Dict a -> Dict a

toEnum :: Int -> Dict a

fromEnum :: Dict a -> Int

enumFrom :: Dict a -> [Dict a]

enumFromThen :: Dict a -> Dict a -> [Dict a]

enumFromTo :: Dict a -> Dict a -> [Dict a]

enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a]

Eq (Dict a)

Defined in Data.Constraint

Methods

(==) :: Dict a -> Dict a -> Bool

(/=) :: Dict a -> Dict a -> Bool

(Typeable p, p) => Data (Dict p)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dict p -> c (Dict p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dict p)

toConstr :: Dict p -> Constr

dataTypeOf :: Dict p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dict p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dict p))

gmapT :: (forall b. Data b => b -> b) -> Dict p -> Dict p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQ :: (forall d. Data d => d -> u) -> Dict p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dict p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

Ord (Dict a)

Defined in Data.Constraint

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

(<=) :: Dict a -> Dict a -> Bool

(>) :: Dict a -> Dict a -> Bool

(>=) :: Dict a -> Dict a -> Bool

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

a => Read (Dict a)

Defined in Data.Constraint

Methods

readsPrec :: Int -> ReadS (Dict a)

readList :: ReadS [Dict a]

readPrec :: ReadPrec (Dict a)

readListPrec :: ReadPrec [Dict a]

Show (Dict a)

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS

show :: Dict a -> String

showList :: [Dict a] -> ShowS

Semigroup (Dict a)

Defined in Data.Constraint

Methods

(<>) :: Dict a -> Dict a -> Dict a

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

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

a => Monoid (Dict a)

Defined in Data.Constraint

Methods

mempty :: Dict a

mappend :: Dict a -> Dict a -> Dict a

mconcat :: [Dict a] -> Dict a

NFData (Dict c)

Defined in Data.Constraint

Methods

rnf :: Dict c -> ()

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

type FieldDescriptions = [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

Description of constructors and fields of some datatype.

This type is just two nested maps represented as associative lists. It is supposed to be interpreted like this:

[(Constructor name, (Maybe constructor description, [(Field name, Field description)]))]

Example with a concrete data type:

data Foo
  = Foo
      { fFoo :: Int
      }
  | Bar
      { fBar :: Text
      }
  deriving (Generic)

type FooDescriptions =
  '[ '( "Foo", '( 'Just "foo constructor",
      , '[ '("fFoo", "some number")
         ])
      )
   , '( "Bar", '( 'Nothing,
      , '[ '("fBar", "some string")
         ])
      )
   ]

class (Typeable t, SingI t) => KnownT (t :: T)

Typeable + SingI constraints.

This restricts a type to be a constructible type of T kind.

Instances

(Typeable t, SingI t) => KnownT t

Defined in Michelson.Typed.Sing

KnownT t => CheckScope (StorageScope t)

Defined in Michelson.Typed.Scope

Methods

checkScope :: Either BadTypeForScope (Dict (StorageScope t))

KnownT t => CheckScope (ParameterScope t)

Defined in Michelson.Typed.Scope

Methods

checkScope :: Either BadTypeForScope (Dict (ParameterScope t))

KnownT t => CheckScope (ComparabilityScope t)

Defined in Michelson.Typed.Value

Methods

checkScope :: Either BadTypeForScope (Dict (ComparabilityScope t))

class KnownT t => WellTyped (t :: T)

This class encodes Michelson rules w.r.t where it requires comparable types. Earlier we had a dedicated type for representing comparable types CT. But then we integreated those types into T. This meant that some of the types that could be formed with various combinations of T would be illegal as per Michelson typing rule. Using this class, we inductively enforce that a type and all types it contains are well typed as per Michelson's rules.

Instances

WellTyped 'TKey

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TUnit

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TSignature

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TChainId

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TOperation

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TInt

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TNat

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TString

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TBytes

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TMutez

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TBool

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TKeyHash

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TTimestamp

Defined in Michelson.Typed.Haskell.Value

WellTyped 'TAddress

Defined in Michelson.Typed.Haskell.Value

WellTyped t => WellTyped ('TOption t)

Defined in Michelson.Typed.Haskell.Value

WellTyped t => WellTyped ('TList t)

Defined in Michelson.Typed.Haskell.Value

(Comparable t, WellTyped t) => WellTyped ('TSet t)

Defined in Michelson.Typed.Haskell.Value

WellTyped t => WellTyped ('TContract t)

Defined in Michelson.Typed.Haskell.Value

(WellTyped t1, WellTyped t2) => WellTyped ('TPair t1 t2)

Defined in Michelson.Typed.Haskell.Value

(WellTyped t1, WellTyped t2) => WellTyped ('TOr t1 t2)

Defined in Michelson.Typed.Haskell.Value

(WellTyped t1, WellTyped t2) => WellTyped ('TLambda t1 t2)

Defined in Michelson.Typed.Haskell.Value

(Comparable k, WellTyped k, WellTyped v) => WellTyped ('TMap k v)

Defined in Michelson.Typed.Haskell.Value

(Comparable k, WellTyped k, WellTyped v) => WellTyped ('TBigMap k v)

Defined in Michelson.Typed.Haskell.Value

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

(WellTypedToT k, WellTypedToT v, Comparable (ToT k), Arbitrary k, Arbitrary v, Ord k) => Arbitrary (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

arbitrary :: Gen (BigMap k v)

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

Default (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Methods

def :: BigMap k v

(WellTypedToT k, WellTypedToT v, Comparable (ToT k), Ord k, IsoValue 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], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (BigMap k v)

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (BigMap k v) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v)

typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v)

type ToT (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

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

type TypeDocFieldDescriptions (BigMap k v)

Defined in Michelson.Typed.Haskell.Doc

type TypeDocFieldDescriptions (BigMap k v) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

data ContractRef (arg :: Type)

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

Note that type argument always designates an argument of entrypoint. If a contract has explicit default entrypoint (and no root entrypoint), ContractRef referring to it can never have the entire parameter as its type argument.

Constructors

ContractRef

Fields

• crAddress :: Address
• crEntrypoint :: SomeEntrypointCall arg

Instances

Eq (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Methods

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

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

Show (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Methods

showsPrec :: Int -> ContractRef arg -> ShowS

show :: ContractRef arg -> String

showList :: [ContractRef arg] -> ShowS

WellTypedToT arg => Buildable (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Methods

build :: ContractRef arg -> Builder

WellTypedToT arg => 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] => TypeHasDoc (ContractRef cp)

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (ContractRef cp) :: FieldDescriptions

Methods

typeDocName :: Proxy (ContractRef cp) -> Text

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp)

typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp)

type ToT (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

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

type TypeDocFieldDescriptions (ContractRef cp)

Defined in Michelson.Typed.Haskell.Doc

type TypeDocFieldDescriptions (ContractRef cp) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

type WellTypedIsoValue a = (WellTyped (ToT a), IsoValue a)

type WellTypedToT a = WellTyped (ToT a)

type SomeEntrypointCall arg = SomeEntrypointCallT (ToT arg)

type EntrypointCall param arg = EntrypointCallT (ToT param) (ToT arg)

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 :: KnownIsoT 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 WellTypedToT a => 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.

type ToT a = GValueType (Rep a)

Methods

toVal :: a -> Value (ToT a)

Converts a Haskell structure into Value representation.

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

fromVal :: Value (ToT a) -> a

Converts a Value into Haskell type.

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

Instances

IsoValue Bool

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Bool :: T

Methods

toVal :: Bool -> Value (ToT Bool)

fromVal :: Value (ToT Bool) -> Bool

IsoValue Integer

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Integer :: T

Methods

toVal :: Integer -> Value (ToT Integer)

fromVal :: Value (ToT Integer) -> Integer

IsoValue Natural

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Natural :: T

Methods

toVal :: Natural -> Value (ToT Natural)

fromVal :: Value (ToT Natural) -> Natural

IsoValue ()

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT () :: T

Methods

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

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

IsoValue ByteString

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT ByteString :: T

Methods

toVal :: ByteString -> Value (ToT ByteString)

fromVal :: Value (ToT ByteString) -> ByteString

(DoNotUseTextError :: Constraint) => IsoValue Text

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Text :: T

Methods

toVal :: Text -> Value (ToT Text)

fromVal :: Value (ToT Text) -> Text

IsoValue MText

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT MText :: T

Methods

toVal :: MText -> Value (ToT MText)

fromVal :: Value (ToT MText) -> MText

IsoValue KeyHash

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT KeyHash :: T

Methods

toVal :: KeyHash -> Value (ToT KeyHash)

fromVal :: Value (ToT KeyHash) -> KeyHash

IsoValue Signature

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Signature :: T

Methods

toVal :: Signature -> Value (ToT Signature)

fromVal :: Value (ToT Signature) -> Signature

IsoValue PublicKey

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT PublicKey :: T

Methods

toVal :: PublicKey -> Value (ToT PublicKey)

fromVal :: Value (ToT PublicKey) -> PublicKey

IsoValue ChainId

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT ChainId :: T

Methods

toVal :: ChainId -> Value (ToT ChainId)

fromVal :: Value (ToT ChainId) -> ChainId

IsoValue Timestamp

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Timestamp :: T

Methods

toVal :: Timestamp -> Value (ToT Timestamp)

fromVal :: Value (ToT Timestamp) -> Timestamp

IsoValue Mutez

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Mutez :: T

Methods

toVal :: Mutez -> Value (ToT Mutez)

fromVal :: Value (ToT Mutez) -> Mutez

IsoValue Address

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Address :: T

Methods

toVal :: Address -> Value (ToT Address)

fromVal :: Value (ToT Address) -> Address

IsoValue EpAddress

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT EpAddress :: T

Methods

toVal :: EpAddress -> Value (ToT EpAddress)

fromVal :: Value (ToT EpAddress) -> EpAddress

IsoValue Operation

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT Operation :: T

Methods

toVal :: Operation -> Value (ToT Operation)

fromVal :: Value (ToT Operation) -> Operation

IsoValue MyCompoundType

Defined in Michelson.Typed.Haskell.Instr.Sum

Associated Types

type ToT MyCompoundType :: T

Methods

toVal :: MyCompoundType -> Value (ToT MyCompoundType)

fromVal :: Value (ToT MyCompoundType) -> MyCompoundType

IsoValue a => IsoValue [a]

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT [a] :: T

Methods

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

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

IsoValue a => IsoValue (Maybe a)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Maybe a) :: T

Methods

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

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

IsoValue a => IsoValue (Identity a)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Identity a) :: T

Methods

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

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

(Comparable (ToT c), Ord c, IsoValue 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

WellTypedToT arg => IsoValue (ContractRef arg)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (ContractRef arg) :: T

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (Either l r) :: T

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (a, b) :: T

Methods

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

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

(Comparable (ToT k), Ord k, IsoValue 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

(WellTypedToT k, WellTypedToT v, Comparable (ToT k), Ord k, IsoValue k, IsoValue v) => IsoValue (BigMap k v)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (BigMap k v) :: T

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

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

Methods

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

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

IsoValue a => IsoValue (NamedF Maybe a name)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (NamedF Maybe a name) :: T

Methods

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

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

IsoValue a => IsoValue (NamedF Identity a name)

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT (NamedF Identity a name) :: T

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

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

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

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

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

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

Methods

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

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

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

Defined in Michelson.Typed.Haskell.Value

Associated Types

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

Methods

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

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

type KnownIsoT a = KnownT (ToT a)

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

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]

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 = (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 InstrWrapOneC dt name = (InstrWrapC dt name, GetCtorField dt name ~ 'OneField (CtorOnlyField name dt))

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 ChainId = '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).

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

Like instrWrap but only works for contructors with a single field. Results in a type error if a constructor with no field is used instead.

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 => 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 InstrDeconstructC dt = (GenericIsoValue dt, GInstrDeconstruct (Rep dt))

Constraint for instrConstruct.

type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep dt))

Constraint for instrConstruct and gInstrConstructStack.

type ConstructorFieldNames dt = GFieldNames (Rep dt)

Names of all fields in a datatype.

type ConstructorFieldTypes dt = GFieldTypes (Rep dt)

Types of all fields in a datatype.

class ToTs xs ~ ToTs ys => CastFieldConstructors xs ys where

Ability to pass list of fields with the same ToTs. It may be useful if you don't want to work with NamedF in ConstructorFieldTypes.

Methods

castFieldConstructorsImpl :: Rec (FieldConstructor st) xs -> Rec (FieldConstructor st) ys

Instances

CastFieldConstructors ('[] :: [Type]) ('[] :: [Type])

Defined in Michelson.Typed.Haskell.Instr.Product

Methods

castFieldConstructorsImpl :: forall k (st :: [k]). Rec (FieldConstructor st) '[] -> Rec (FieldConstructor st) '[]

(CastFieldConstructors xs ys, ToTs xs ~ ToTs ys, ToT x ~ ToT y) => CastFieldConstructors (x ': xs) (y ': ys)

Defined in Michelson.Typed.Haskell.Instr.Product

Methods

castFieldConstructorsImpl :: forall k (st :: [k]). Rec (FieldConstructor st) (x ': xs) -> Rec (FieldConstructor st) (y ': ys)

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.

instrConstructStack :: forall dt stack st. (InstrConstructC dt, stack ~ ToTs (ConstructorFieldTypes dt), KnownList stack) => Instr (stack ++ st) (ToT dt ': st)

instrDeconstruct :: forall dt stack st. (InstrDeconstructC dt, stack ~ ToTs (ConstructorFieldTypes dt), KnownList stack) => Instr (ToT dt ': st) (stack ++ st)

For given complex type dt deconstruct it to its field types.

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.

data FieldRep a

Representation of a field with an optional description.

Constructors

FieldRep

Fields

• frName :: Maybe Text
• frDescription :: Maybe Text
• frTypeRep :: a

data ConstructorRep a

Representation of a constructor with an optional description.

Constructors

ConstructorRep

Fields

• crName :: Text
• crDescription :: Maybe Text
• crFields :: [FieldRep a]

type ADTRep a = NonEmpty (ConstructorRep 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.

This representation also includes descriptions of constructors and fields.

crDescriptionL :: forall a. Lens' (ConstructorRep a) (Maybe Text)

crFieldsL :: forall a a. Lens (ConstructorRep a) (ConstructorRep a) [FieldRep a] [FieldRep a]

crNameL :: forall a. Lens' (ConstructorRep a) Text

type PolyTypeHasDocC ts = Each '[TypeHasDoc] ts

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

class GProductHasDoc (x :: Type -> Type)

Product type traversal for TypeHasDoc.

Minimal complete definition

gProductDocHaskellRep

Instances

GProductHasDoc (U1 :: Type -> Type)

Defined in Michelson.Typed.Haskell.Doc

Methods

gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]

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

Defined in Michelson.Typed.Haskell.Doc

Methods

gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]

TypeHasDoc a => GProductHasDoc (S1 ('MetaSel ('Nothing :: Maybe Symbol) _1 _2 _3) (Rec0 a))

Defined in Michelson.Typed.Haskell.Doc

Methods

gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]

(TypeHasDoc a, KnownSymbol field) => GProductHasDoc (S1 ('MetaSel ('Just field) _1 _2 _3) (Rec0 a))

Defined in Michelson.Typed.Haskell.Doc

Methods

gProductDocHaskellRep :: [(Text, Text)] -> [FieldRep SomeTypeWithDoc]

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 :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc

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

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc

GTypeHasDoc x => GTypeHasDoc (D1 ('MetaData _a _b _c 'True) x)

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc

GTypeHasDoc x => GTypeHasDoc (D1 ('MetaData _a _b _c 'False) x)

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: FieldDescriptionsV -> ADTRep SomeTypeWithDoc

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

Defined in Michelson.Typed.Haskell.Doc

Methods

gTypeDocHaskellRep :: FieldDescriptionsV -> 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 :: k2) (bc b :: k4)

Defined in Michelson.Typed.Haskell.Doc

newtype DStorageType

Doc element with description of contract storage type.

Constructors

DStorageType DType

Instances

Eq DStorageType

Defined in Michelson.Typed.Haskell.Doc

Methods

(==) :: DStorageType -> DStorageType -> Bool

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

Ord DStorageType

Defined in Michelson.Typed.Haskell.Doc

Methods

compare :: DStorageType -> DStorageType -> Ordering

(<) :: DStorageType -> DStorageType -> Bool

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

(>) :: DStorageType -> DStorageType -> Bool

(>=) :: DStorageType -> DStorageType -> Bool

max :: DStorageType -> DStorageType -> DStorageType

min :: DStorageType -> DStorageType -> DStorageType

Generic DStorageType

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type Rep DStorageType :: Type -> Type

Methods

from :: DStorageType -> Rep DStorageType x

to :: Rep DStorageType x -> DStorageType

DocItem DStorageType

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type DocItemPlacement DStorageType :: DocItemPlacementKind

type DocItemReferenced DStorageType :: DocItemReferencedKind

Methods

docItemPos :: Natural

docItemSectionName :: Maybe Text

docItemSectionDescription :: Maybe Markdown

docItemSectionNameStyle :: DocSectionNameStyle

docItemRef :: DStorageType -> DocItemRef (DocItemPlacement DStorageType) (DocItemReferenced DStorageType)

docItemToMarkdown :: HeaderLevel -> DStorageType -> Markdown

docItemToToc :: HeaderLevel -> DStorageType -> Markdown

docItemDependencies :: DStorageType -> [SomeDocDefinitionItem]

docItemsOrder :: [DStorageType] -> [DStorageType]

type Rep DStorageType

Defined in Michelson.Typed.Haskell.Doc

type Rep DStorageType = D1 ('MetaData "DStorageType" "Michelson.Typed.Haskell.Doc" "morley-1.7.0-inplace" 'True) (C1 ('MetaCons "DStorageType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DType)))

type DocItemPlacement DStorageType

Defined in Michelson.Typed.Haskell.Doc

type DocItemPlacement DStorageType = 'DocItemInlined

type DocItemReferenced DStorageType

Defined in Michelson.Typed.Haskell.Doc

type DocItemReferenced DStorageType = 'True

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 DocItemPlacement DType :: DocItemPlacementKind

type DocItemReferenced DType :: DocItemReferencedKind

Methods

docItemPos :: Natural

docItemSectionName :: Maybe Text

docItemSectionDescription :: Maybe Markdown

docItemSectionNameStyle :: DocSectionNameStyle

docItemRef :: DType -> DocItemRef (DocItemPlacement DType) (DocItemReferenced DType)

docItemToMarkdown :: HeaderLevel -> DType -> Markdown

docItemToToc :: HeaderLevel -> DType -> Markdown

docItemDependencies :: DType -> [SomeDocDefinitionItem]

docItemsOrder :: [DType] -> [DType]

type DocItemPlacement DType

Defined in Michelson.Typed.Haskell.Doc

type DocItemPlacement DType = 'DocItemInDefinitions

type DocItemReferenced DType

Defined in Michelson.Typed.Haskell.Doc

type DocItemReferenced DType = 'True

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 -> FieldDescriptionsV -> Maybe (Maybe DocTypeRepLHS, ADTRep SomeTypeWithDoc)

Signature of typeDocHaskellRep function.

A value of FieldDescriptionsV is provided by the library to make sure that instances won't replace it with an unchecked value.

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, SingI (TypeDocFieldDescriptions a), FieldDescriptionsValid (TypeDocFieldDescriptions a) a) => TypeHasDoc a where

Description for a Haskell type appearing in documentation.

Minimal complete definition

typeDocMdDescription

Associated Types

type TypeDocFieldDescriptions a :: FieldDescriptions

Description of constructors and fields of a.

See FieldDescriptions documentation for an example of usage.

Descriptions will be checked at compile time to make sure that only existing constructors and fields are referenced.

For that check to work instance Generic a is required whenever TypeDocFieldDescriptions is not empty.

For implementation of the check see FieldDescriptionsValid type family.

type TypeDocFieldDescriptions a = '[]

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

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

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](#type-integer),
• [Maybe](#type-Maybe) [()](#type-unit).

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.

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

typeDocDependencies :: Proxy a -> [SomeDocDefinitionItem]

All types which this type directly contains.

Used in automatic types discovery.

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

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.

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

typeDocMichelsonRep :: TypeDocMichelsonRep a

Final michelson representation of a type.

For homomorphic types use homomorphicTypeDocMichelsonRep implementation.

For polymorhpic types consider using concreteTypeDocMichelsonRep as implementation.

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

Instances

TypeHasDoc Bool

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Bool :: FieldDescriptions

Methods

typeDocName :: Proxy Bool -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Bool -> WithinParens -> Markdown

typeDocDependencies :: Proxy Bool -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Bool

typeDocMichelsonRep :: TypeDocMichelsonRep Bool

TypeHasDoc Integer

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Integer :: FieldDescriptions

Methods

typeDocName :: Proxy Integer -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Integer -> WithinParens -> Markdown

typeDocDependencies :: Proxy Integer -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Integer

typeDocMichelsonRep :: TypeDocMichelsonRep Integer

TypeHasDoc Natural

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Natural :: FieldDescriptions

Methods

typeDocName :: Proxy Natural -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Natural -> WithinParens -> Markdown

typeDocDependencies :: Proxy Natural -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Natural

typeDocMichelsonRep :: TypeDocMichelsonRep Natural

TypeHasDoc ()

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions () :: FieldDescriptions

Methods

typeDocName :: Proxy () -> Text

typeDocMdDescription :: Markdown

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

typeDocDependencies :: Proxy () -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep ()

typeDocMichelsonRep :: TypeDocMichelsonRep ()

TypeHasDoc ByteString

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions ByteString :: FieldDescriptions

Methods

typeDocName :: Proxy ByteString -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy ByteString -> WithinParens -> Markdown

typeDocDependencies :: Proxy ByteString -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep ByteString

typeDocMichelsonRep :: TypeDocMichelsonRep ByteString

TypeHasDoc MText

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions MText :: FieldDescriptions

Methods

typeDocName :: Proxy MText -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy MText -> WithinParens -> Markdown

typeDocDependencies :: Proxy MText -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep MText

typeDocMichelsonRep :: TypeDocMichelsonRep MText

TypeHasDoc KeyHash

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions KeyHash :: FieldDescriptions

Methods

typeDocName :: Proxy KeyHash -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy KeyHash -> WithinParens -> Markdown

typeDocDependencies :: Proxy KeyHash -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep KeyHash

typeDocMichelsonRep :: TypeDocMichelsonRep KeyHash

TypeHasDoc Signature

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Signature :: FieldDescriptions

Methods

typeDocName :: Proxy Signature -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Signature -> WithinParens -> Markdown

typeDocDependencies :: Proxy Signature -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Signature

typeDocMichelsonRep :: TypeDocMichelsonRep Signature

TypeHasDoc PublicKey

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions PublicKey :: FieldDescriptions

Methods

typeDocName :: Proxy PublicKey -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy PublicKey -> WithinParens -> Markdown

typeDocDependencies :: Proxy PublicKey -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep PublicKey

typeDocMichelsonRep :: TypeDocMichelsonRep PublicKey

TypeHasDoc Timestamp

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Timestamp :: FieldDescriptions

Methods

typeDocName :: Proxy Timestamp -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Timestamp -> WithinParens -> Markdown

typeDocDependencies :: Proxy Timestamp -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Timestamp

typeDocMichelsonRep :: TypeDocMichelsonRep Timestamp

TypeHasDoc Mutez

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Mutez :: FieldDescriptions

Methods

typeDocName :: Proxy Mutez -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Mutez -> WithinParens -> Markdown

typeDocDependencies :: Proxy Mutez -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Mutez

typeDocMichelsonRep :: TypeDocMichelsonRep Mutez

TypeHasDoc Address

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Address :: FieldDescriptions

Methods

typeDocName :: Proxy Address -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Address -> WithinParens -> Markdown

typeDocDependencies :: Proxy Address -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Address

typeDocMichelsonRep :: TypeDocMichelsonRep Address

TypeHasDoc EpAddress

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions EpAddress :: FieldDescriptions

Methods

typeDocName :: Proxy EpAddress -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown

typeDocDependencies :: Proxy EpAddress -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep EpAddress

typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress

TypeHasDoc Operation

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Operation :: FieldDescriptions

Methods

typeDocName :: Proxy Operation -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown

typeDocDependencies :: Proxy Operation -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Operation

typeDocMichelsonRep :: TypeDocMichelsonRep Operation

PolyTypeHasDocC '[a] => TypeHasDoc [a]

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions [a] :: FieldDescriptions

Methods

typeDocName :: Proxy [a] -> Text

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep [a]

typeDocMichelsonRep :: TypeDocMichelsonRep [a]

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (Maybe a) :: FieldDescriptions

Methods

typeDocName :: Proxy (Maybe a) -> Text

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (Maybe a)

typeDocMichelsonRep :: TypeDocMichelsonRep (Maybe a)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (Set a) :: FieldDescriptions

Methods

typeDocName :: Proxy (Set a) -> Text

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (Set a)

typeDocMichelsonRep :: TypeDocMichelsonRep (Set a)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (ContractRef cp) :: FieldDescriptions

Methods

typeDocName :: Proxy (ContractRef cp) -> Text

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp)

typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (Either l r) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (Either l r)

typeDocMichelsonRep :: TypeDocMichelsonRep (Either l r)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (a, b) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (a, b)

typeDocMichelsonRep :: TypeDocMichelsonRep (a, b)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (Map k v) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (Map k v)

typeDocMichelsonRep :: TypeDocMichelsonRep (Map k v)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (BigMap k v) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v)

typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (a, b, c) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

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

Associated Types

type TypeDocFieldDescriptions (NamedF f a n) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

typeDocHaskellRep :: TypeDocHaskellRep (NamedF f a n)

typeDocMichelsonRep :: TypeDocMichelsonRep (NamedF f a n)

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (a, b, c, d) :: FieldDescriptions

Methods

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

typeDocMdDescription :: Markdown

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

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

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

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

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (a, b, c, d, e) :: FieldDescriptions

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) -> [SomeDocDefinitionItem]

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

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

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (a, b, c, d, e, f) :: FieldDescriptions

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) -> [SomeDocDefinitionItem]

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

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

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

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions (a, b, c, d, e, f, g) :: FieldDescriptions

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) -> [SomeDocDefinitionItem]

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

frDescriptionL :: forall a. Lens' (FieldRep a) (Maybe Text)

frNameL :: forall a. Lens' (FieldRep a) (Maybe Text)

frTypeRepL :: forall a a. Lens (FieldRep a) (FieldRep a) a a

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

Show given ADTRep in a neat way.

applyWithinParens :: WithinParens -> Markdown -> Markdown

dTypeDep :: forall (t :: Type). TypeHasDoc t => SomeDocDefinitionItem

Create a DType in form suitable for putting to typeDocDependencies.

dTypeDepP :: forall (t :: Type). TypeHasDoc t => Proxy t -> SomeDocDefinitionItem

Proxy version of dTypeDep.

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 -> [SomeDocDefinitionItem]

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.

haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a

Add field name for newtype.

Since newtype field is automatically erased. Use this function to add the desired field name.

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.