Clojure for Tezos

Note.md

Clojure for Tezos

• Endpoints are declared by adding an :entrypoint metadata at the function declaration, which could further extended to a defentrypoint macro.
• Due to the typed nature of Michelson, the code must be typed to properly be translated to code:
  • Type declarations should use the type function (or macro?) to declare types for namespace defined variables.
  • Extra type annotation could be done by using metadata.
  • Need for a type checker, which I don't know how to implement (I don't know to how to build a backend also, but don't tell anyone).
  • Michelson types need a correspondence for Clojure literals, while some are possible, conjunction and disjunction types are not available for Clojure.
• Some types have an extra challenge, like option and or, because Clojure doesn't have the proper idioms to deal with it, I should define a few patterns to describe how to interpret them, mainly option.
• To descrease the overhead for type inference, some literals are going to be used for naturals and mutez, like 1n and 1mutez.

Just like domain specific stuff are exposed on the Tezos module for LIGO, I'm going to expose those on the tezos namespace.

Advantages

• Macros
• Emulate some of the dynamic features of Clojure and other Lisps

Examples

Counter contract

(type storage nat)
(type return (pair (list operation) storage))

(type increment (-> unit storage return))
(defn ^:entrypoint increment
  [_ storage]
  (tezos/pair :unit (inc storage))

(type decrement (-> unit storage return))
(defn ^:entrypoint decrement
  [_ storage]
  (tezos/pair :unit (dec storage)))
 
(type decrement (-> unit storage return))
(defn ^:entrypoint reset
  [_ _]
  (tezos/pair :unit 0))

Symbols and repetitions

One of the problems I've encountered is that I can't have random access to memory, so accessing symbols becomes difficult because I need to duplicate and reorder things on the stack so the operations are valid. I still have no clear mental model of doing this and I've come to a simple way but without not proofs that it actually works.

1. Build the AST
2. Create a DAG from the AST
3. Sort the items of the DAG based on the order they would be on the stack
4. Duplicate the nodes of the symbols removing nodes with order greater than one and adding the distance between the top of the stack and the symbol (0 for a0)
5. Push the items (they should be already) and create the number of duplicates needed, when reorder is needed use the distance from the stop of the stack to know how many items you'll have to swap (you can use the DUG instruction if that's larger than a 1)

The on the right is wrong, it should be actually:

PUSH a ;
DUP ;
PUSH 3 ;
MUL ;
SWAP ;
PUSH 2 ;
SWAP ;
SUB ;
ADD ;

Another example

Some references I've found that may be helpful

• http://www.complang.tuwien.ac.at/anton/euroforth/ef00/bailey00.pdf
• http://www.complang.tuwien.ac.at/anton/euroforth2006/papers/shannon.pdf
• https://users.ece.cmu.edu/~koopman/stack_compiler/stack_co.pdf
• https://dl.acm.org/doi/pdf/10.1145/321892.321901
• https://ieeexplore.ieee.org/document/1646483