Cheat Sheet

Contract, view and test

module C = struct
  type storage = int

  [@entry]
  let increment (action: int) (store: storage) : operation list * storage =
    [], store + action

  [@entry]
  let decrement (action: int) (store: storage) : operation list * storage =
    [], store - action

  [@view]
  let get_storage (must_be_positive: bool) (storage: int) : int =
    if must_be_positive && storage < 0 then
      failwith "Negative value in storage"
    else
      storage
end

let testC =
    let initial_storage = 42 in
    let originated = Test.originate (contract_of C) initial_storage 0tez in
    let p : C parameter_of = Increment 1 in
    let _ = Test.transfer_exn originated.addr p 1mutez in
    assert (Test.get_storage originated.addr = initial_storage + 1)

Strings

let name : string = "Tezos"

Characters

let t : string = "t"

Integers

let i : int = 42

Natural numbers

let n : nat = 7n

Unit

let u : unit = unit

Boolean

let has_drivers_license : bool = false
let adult : bool = true

Boolean Logic

let booleanLogic : bool =
    (not true) =
    false =
    (false && true) =
    (false || false)

Mutez (micro tez)

let tez : tez = 42tez
let tez : tez = 7mutez

Address

let tz1address : address =
  ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address)
let kt1address : address =
  ("KT1JepfBfMSqkQyf9B1ndvURghGsSB8YCLMD" : address)

String

let my_str : string = "Hello World!"

Verbatim string

let verbatim_str : string = {|verbatim string|}

Addition

let add_int : int = 3 + 4
let add_nat : nat = 3n + 4n

Multiplication & Division

let mul_int : int = 3 * 4
let mul_nat : nat = 3n * 4n

let div_int : int = 10 / 5
let div_nat : nat = 10n / 5n

Modulo

let mod_nat : nat = 10 mod 3

Tuples

type name = string * string

let winner : name = "John", "Doe"

let firstName : string = winner.0
let lastName : string = winner.1

Types

type age = int
type name = string

Include (prefer import)

#include "library.mligo"

Import (better)

#import "library.mligo" "MyLibrary"
let foo = MyLibrary.bar

Functions

let add (a : int) (b : int) : int =
  a + b

If Statement

let can_drive (age : nat) : string =
  if age >= 16n then "yes" else "no"

Options

type middle_name = string option
let middle_name : middle_name = Some "Foo"
let middle_name : middle_name = None

Variable Binding

let age : int = 5

Type Annotations

let someAddress : address =
  ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address)

Variants

type action =
  Increment of int
| Decrement of int

Variant (pattern) matching

let a : action = Increment 5

let result : int =
  match a with
    Increment n -> n + 1
  | Decrement n -> n - 1

Records

type person = {
  age  : int;
  name : string
}

let john : person = {
  age  = 18;
  name = "john doe"
}

let name : string = john.name

Maps

type prices = (nat, tez) map

let prices : prices =
  Map.literal [
    (10n, 60mutez);
    (50n, 30mutez);
    (100n, 10mutez);
  ]

let price : tez option = Map.find_opt 50n prices

let prices : prices = Map.update 200n (Some 5mutez) prices

Contracts & Accounts

let destinationAddress : address =
  ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address)

let contract : unit contract =
  match (Tezos.get_contract_opt (Tezos.get_sender ()) : unit contract option) with
    Some contract -> contract
    | None -> (failwith "no contract" : unit contract)

Transactions

let payment : operation =
  Tezos.transaction unit 100mutez contract

Exception/Failure

let fail (u : unit) : unit =
  failwith "a failure message"

Comb layout (default)

type animal =
[@layout comb]
| Elephant
| Dog
| Cat

Tree layout

type animal =
[@layout tree]
| Elephant
| Dog
| Cat

Module definition (auto-inferred type)

module FA0_inferred = struct
  type t = unit
  [@entry] let transfer (_ : unit) (_ : t) : operation list * t = [], ()
end

Module Type

module type FA0_SIG = sig
  type t
  [@entry] val transfer : unit -> t -> operation list * t
end

Extending Module Type

module type FA0Ext_SIG = sig
  include FA0_SIG
  [@entry] val transfer2 : unit -> t -> operation list * t
end

Module definition

module FA0 : FA0_SIG = struct
  type t = unit
  [@entry] let transfer (_ : unit) (_ : t) : operation list * t = [], ()
end

Extending module definition

module FA0Ext : FA0Ext_SIG = struct
  include FA0
  [@entry] let transfer2 (a : unit) (b : t) = transfer a b
end