LIGO can work together with other smart contract languages on Tezos. However, data structures might have different representations in Michelson and not correctly match the standard LIGO types.
Michelson types and annotations
Michelson types consist of
pair's, combined with field
annotations. Field annotations add constraints on a Michelson type,
for example a pair of
(pair (int %foo) (string %bar)) will only work
with the exact equivalence or the same type without the field
works not with
works not with
In the case of annotated entrypoints --- the annotated
parameter in a contract --- you should use
annotations, as otherwise it's unclear which entrypoint you are
Default LIGO output
By default LIGO translates its datatypes into a alphabetically left balanced tree. So, for example:
will translate to:
Right-combed tree output
If you want to change the data representation in Michelson to a location retaining right combed tree, like this:
You can use the decorator
@layout("comb"), like so:
Different Michelson annotations
If the Michelson annotation should be different from the LIGO attribute, give it as an argument to the LIGO attribute. For example:
will result into:
@annot("<name>") can also be used on object field
If the decorators
@annot("<name>") are not
adequate enough for your use-case, LIGO has more advanced advanced
interoperability features, which we will we discuss next.
Advanced interoperability with Michelson
To interoperate with existing Michelson code or to be compatible with
certain development tooling, LIGO has two special interoperation
michelson_pair. These types give the
flexibility to model the exact Michelson output, including field
Take for example the following Michelson type that we want to interoperate with:
To reproduce this type we can use the following LIGO code:
If you do not want to inject a Michelson annotation, the you simply provide an empty string.
Alternatively, if annotations are not important you can also use plain tuples for pair's instead. Plain tuples don't have any annotations.
To use variables of type
michelson_or you have to use
M_left picks the left
or case while
or case. For
michelson_pair you need to use tuples.
Manual data structure conversion
If you want to get your hands dirty, it is also possible to do manual data structure conversion. The following code can be used as inspiration:
Entrypoints and annotations
It's possible for a contract to have multiple entrypoints, which is implicitly translated in
LIGO to a
parameter with a variant type as shown below. The following contract:
is tranlated internally to a contract similar to this one:
This contract can be called by another contract, like this one:
Notice how we directly use the
%left entrypoint without mentioning the
%right entrypoint. This is done with the help of annotations. Without
annotations it wouldn't be clear what our
int would be referring to.
This currently only works for
or's or variant types in LIGO.
With the upcoming 007 amendment to Tezos this will change though, and also
pair's can be ordered differently.