Documentation

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.

Representation of a constructor with an optional description.

Representation of a field with an optional description.

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

Description for a Haskell type appearing in documentation.

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.

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.

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

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

Data hides some type implementing TypeHasDoc.

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.

Require this type to be homomorphic.

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

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.

Derive typeDocMdReference, for homomorphic types only.

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

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

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.

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.

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.

Add field name for newtype.

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

Erase fields from Haskell datatype representation.

Use this when rendering fields names is undesired.

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

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

Implement typeDocMichelsonRep for homomorphic type.

Implement typeDocMichelsonRep on example of given concrete type.

This function exists for the same reason as concreteTypeDocHaskellRep.

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.

Doc element with description of a type.

Doc element with description of contract storage type.

Generic traversal for automatic deriving of some methods in TypeHasDoc.

Product type traversal for TypeHasDoc.

Create a DType in form suitable for putting to typeDocDependencies.

Proxy version of dTypeDep.

Show given ADTRep in a neat way.