Documentation

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.

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

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

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

Typeable + SingI constraints.

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

Default layout in LIGO.

To be used with customGeneric, see this method for more info.

This is similar to leftBalanced, but

• fields are sorted alphabetically;
• always puts as large complete binary subtrees as possible at left.

Comb layout in LIGO ( [@layout:comb] ).

To be used with customGeneric.

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.

Isomorphism between Michelson stack and its Haskell reflection.

Overloaded version of ToTs to work on Haskell and T stacks.

Type function to convert a Haskell stack type to T-based one.

Whether Michelson representation of the type is derived via Generics.

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.

Any Haskell value which can be converted to Michelson Value.

Hides some Haskell value put in line with Michelson Value.

Overloaded version of ToT to work on Haskell and T types.

Isomorphism between Michelson values and plain Haskell types.

Default implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s.

Replace type argument of ContractAddr with isomorphic one.

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

Type information about single case clause.

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

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

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

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

Whether given type represents an atomic Michelson value.

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

Push field to stack, if any.

Get something as field of the given constructor.

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

Proof of AppendCtorFieldAxiom.

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

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.

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

This is symmetric to instrWrap.

Pattern-match on the given datatype.

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.

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.

Try to unwrap a constructor with the given name.

Constraint for instrConstruct.

Constraint for instrConstruct and gInstrConstructStack.

Names of all fields in a datatype.

Types of all fields in a datatype.

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.

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

Constraint for instrSetField.

Constraint for instrGetField.

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

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

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

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

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

Constraint for hsDecompose and hsCompose.

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

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

Inverse to toTaggedVal.

Representation of a field with an optional description.

Representation of a constructor with an optional description.

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.

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

Product type traversal for TypeHasDoc.

Generic traversal for automatic deriving of some methods in TypeHasDoc.

Require this type to be homomorphic.

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.

Doc element with description of contract storage type.

Doc element with description of a type.

Data hides some type implementing TypeHasDoc.

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.

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.

Description for a Haskell type appearing in documentation.