ligo/gitlab-pages/docs/api/cheat-sheet.md

id	title
cheat-sheet	Cheat Sheet

import Syntax from '@theme/Syntax';

Strings

const name: string = "Tezos";

Characters

const t: string = "t";

Integers

const i: int = 42;

Natural numbers

const n: nat = 7n;

Unit

const u: unit = unit;

Boolean

const hasDriversLicense: bool = False;
const adult: bool = True;

Boolean Logic

const booleanLogic: bool = 
    (not True) = 
    False = 
    (False and True) = 
    (False or False);

Mutez (micro tez)

const tez: tez = 42tez;

Address

const tz1address: address = 
  ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address);
const kt1address: address = 
  ("KT1JepfBfMSqkQyf9B1ndvURghGsSB8YCLMD": address);

Addition

const add_int: int = 3 + 4;
const add_nat: nat = 3n + 4n;

Multiplication & Division

const mul_int: int = 3 + 4;
const mul_nat: nat = 3n + 4n;

const div_int: int = 10 / 5;
const div_nat: nat = 10n / 5n;

Modulo

const mod_nat: nat = 10 mod 3;

Tuples

type name is (string * string);

const winner: name = ("John", "Doe");

const firstName: string = winner.0;
const lastName: string = winner.1;

Types

type age is int;
type name is string

Includes

#include "library.ligo"

Functions (short form)

function add (const a : int ; const b : int) : int is
  a + b

Functions (long form)

function add (const a : int ; const b : int) : int is
  block {
    const result: int = a + b;
  } with result

If Statement

function if_statement (const age : int) : int is
  block {
    var id: int := -1;
    if age < 16 then {
        failwith ("Too young to drive");
    } else {
        id := 1;
    }
  } with id

Options

type middleName is option(string);
const middleName : middleName = Some("Foo");
const middleName : middleName = None;

Assignment

const age: int = 5;

Assignment on an existing variable

:::caution This feature is not supported at the top-level scope, you can use it e.g. within functions. Works for Records and Maps as well. :::

function assignment_existing (const age : int) : int is
  block {
    var x : int := 2;
    x := 3;
  } with x

Type Annotations

const someAddress: address = 
  ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address);

Variants

type action is 
| Increment of int
| Decrement of int;

Variant *(pattern)* matching

function main 
  (const action : action; const input : int) : int is
  (case action of
    Increment (n) -> input + 1
  | Decrement (n) -> input - 1
  end)

Records

type person is record
  age: int;
  name: string;
end

const john : person = record
  age = 18;
  name = "john doe";
end

const name: string = john.name;

Maps

type prices is map(nat, tez);

const prices: prices = map
    10n -> 60mutez;
    50n -> 30mutez;
    100n -> 10mutez;
end

const price: option(tez) = prices[50n];

function mutate (const u: unit) : unit is block {
    prices[200n] := 10mutez;
} with unit;

Contracts & Accounts

const destinationAddress: address = 
  ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx": address);

const contract : contract (unit) = ( 
  case (Tezos.get_contract_opt (Tezos.sender) : option(contract(unit))) of
     Some (contract) -> contract
   | None -> 
     (failwith ("No contract.") 
       : contract (unit))
  end);

Transactions

const payment: operation = 
  Tezos.transaction(unit, 100mutez, contract);

Exception/Failure

function fail (const u: unit) : unit is
  failwith("a failure message")

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)

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

Includes

#include "library.mligo"

Functions

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

If Statement

let if_statement (age : int) : int =
  if age < 16 then 
    (failwith ("Too young to drive"): int)
  else
    1

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

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 = 
    (!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)

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

Includes

#include "library.religo"

Functions (short form)

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

Functions (long form)

let add = (a: int, b: int): int => {
  let c = a;
  let d = b;
  c + d
};

If Statement

let if_statement = (age : int) : int =>
  if (age < 16) { 
    (failwith ("Too young to drive"): int)
  } else {
    1
  }

Options

type middle_name = option(string);
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 (int)
| Decrement (int)

Variant *(pattern)* matching

let a: action = Increment(5)
let result: int = switch (a) {
| 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 = map (nat, tez)

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

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

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

Contracts & Accounts

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

let contract : contract(unit) = 
  switch (Tezos.get_contract_opt(Tezos.sender) : option(contract(unit))) {
    | Some(contract) => contract
    | None => (failwith("no contract") : contract(unit))
  }

Transactions

let payment: operation = 
  Tezos.transaction(unit, 100mutez, contract);

Exception/Failure

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