Documentation

Gathers information about single entrypoint.

We assume that entry points might be of different kinds, which is designated by phantom type parameter. For instance, you may want to have several groups of entry points corresponding to various parts of a contract - specifying different kind type argument for each of those groups will allow you defining different DocItem instances with appropriate custom descriptions for them.

Pattern that checks whether given SomeDocItem hides DEntrypoint inside (of any entrypoint kind).

In case a specific kind is necessary, use plain (cast -> Just DEntrypoint{..}) construction instead.

Describes location of entrypoints of the given kind.

All such entrypoints will be placed under the same "entrypoints" section, and this instance defines characteristics of this section.

Mark code as part of entrypoint with given name.

This is automatically called at most of the appropriate situations, like entryCase calls.

Inserts a reference to an existing entrypoint.

This helps to avoid duplication in the generated documentation, in order not to overwhelm the reader.

Provides arror for convenient entrypoint documentation

Default value for DEntrypoint type argument.

A convenience type synonym for FlattenedEntrypointsKindHiding not hiding any entrypoitns.

Special entrypoint kind that flattens one level of recursive entrypoints.

With EpdRecursive, intermediary nodes are hidden from documentation.

With EpdDelegate, intermediary nodes will still be shown.

Any entrypoints can be omitted from docs by listing those in the type parameter (which is especially helpful with EpdDelegate).

For other entrypoint derivation strategies (e.g. EpdPlain), behaves like PlainEntrypointsKind (with the exception of hiding entrypoints from docs)

If you have several levels of recursion, each level will need to have this kind.

Note that list of entrypoints to be hidden is not checked by default. Use entryCaseFlattenedHiding to have a static check that entrypoints to be hidden do indeed exist.

Describes the behaviour common for all entrypoints.

For instance, if your contract runs some checks before calling any entrypoint, you probably want to wrap those checks into entrypointSection "Prior checks" (Proxy @CommonContractBehaviourKind).

Describes the behaviour common for entrypoints of given kind.

This has very special use cases, like contracts with mix of upgradeable and permanent entrypoints.

Default implementation of docItemToMarkdown for entrypoints.

Entrypoint argument type in typed representation.

Describes argument of an entrypoint.

Pick a type documentation from CtorField.

When describing the way of parameter construction - piece of incremental builder for this description.

Describes a parameter building step.

This can be wrapping into (Haskell) constructor, or a more complex transformation.

Make a ParamBuildingStep that tells about wrapping an argument into a constructor with given name and uses given ParamBuilder as description of Michelson part.

Go over contract code and update every occurrence of DEntrypointArg documentation item, adding the given step to its "how to build parameter" description.

Constraint for documentEntrypoints.

Wrapper for documenting single entrypoint which parameter isn't going to be unwrapped from some datatype.

entryCase unwraps a datatype, however, sometimes we want to have entrypoint parameter to be not wrapped into some datatype.

Version of entryCase_ for tuples.

Like case_, to be used for pattern-matching on a parameter or its part.

Modifies documentation accordingly. Including description of entrypoints' arguments, thus for them you will need to supply TypeHasDoc instance.

Version of 'finalizeParamCallingDoc'' more convenient for manual call in a contract.

Modify param building steps with respect to entrypoints that given parameter declares.

Each contract with entrypoints should eventually call this function, otherwise, in case if contract uses built-in entrypoints feature, the resulting parameter building steps in the generated documentation will not consider entrypoints and thus may be incorrect.

Calling this twice over the same code is also prohibited.

This method is for internal use, if you want to apply it to a contract manually, use finalizeParamCallingDoc.

Whether finalizeParamCallingDoc has already been applied to these steps.

Version of entryCase_ for contracts with flat parameter.

Version of entryCase for contracts with flat parameter.

Version of entryCase_ for contracts with recursive parameter that needs to be flattened. Use it with EpdRecursive when you don't need intermediary nodes in autodoc.

Version of entryCase for contracts with recursive parameter that needs to be flattened. Use it with EpdRecursive when you don't need intermediary nodes in autodoc.

Version of entryCase_ for contracts with recursive delegate parameter that needs to be flattened. Use it with EpdDelegate when you don't need hierarchical entrypoints in autodoc. You can also hide particular entrypoints with the type parameter. Consider using entryCaseFlattened_ if you don't want to hide any entrypoints.

Version of entryCase for contracts with recursive delegate parameter that needs to be flattened. Use it with EpdDelegate when you don't need hierarchical entrypoints in autodoc. You can also hide particular entrypoints with the first type parameter. Consider using entryCaseFlattened if you don't want to hide any entrypoints.

 entryCaseFlattenedHiding @'[Ep1, Ep2] ...