# Cheat Sheet

Strings

let name: string = "Tezos";

Characters

let t: string = "t";

Integers

let i: int = 42;

Natural numbers

let n: nat = 7 as nat;

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 = 42 as tez

let tez2: tez = 7 as mutez

Address

let tz1address: address =

"tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" as address;

let kt1address: address =

"KT1JepfBfMSqkQyf9B1ndvURghGsSB8YCLMD" as address;

Addition

let add_int: int = 3 + 4;

let add_nat: nat = (3 as nat) + (4 as nat);

Multiplication & Division

let mul_int: int = 3 * 4;

let mul_nat: nat = (3 as nat) * (4 as nat);

let div_int: int = 10 / 5;

let div_nat: nat = (10 as nat) / (5 as nat);

Modulo

let mod_nat: nat = 10 % 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.jsligo"`

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;

return c + d

};

If Statement

let if_statement = (age : nat): string => {

if (age >= (16 as nat)) { return "yes"; } else { return "no"; }

}

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" as address;

Variants

type action =

["Increment", int]

| ["Decrement", int];

Variant *(pattern)* matching

let a: action = Increment(5)

let result: int = match(a, {

Increment: (n: int) => n + 1,

Decrement: (n: int) => 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(list([

[10 as nat, 60 as mutez],

[50 as nat, 30 as mutez],

[100 as nat, 10 as mutez]

]));

let price: option<tez> = Map.find_opt(50 as nat, prices)

let prices2: prices = Map.update(200 as nat, (Some (5 as mutez)), prices)

Contracts & Accounts

let destinationAddress: address =

"tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" as address;

let contract : contract<unit> =

match (Tezos.get_contract_opt(Tezos.get_sender()) as option<contract<unit>>, {

Some: (contract: contract<unit>) => contract,

None: () => (failwith("no contract") as contract<unit>)

})

Transactions

let payment: operation =

Tezos.transaction(unit, 100 as mutez, contract);

Exception/Failure

let fail = (u: unit) : unit =>

failwith("a failure message")

contract_of and parameter_of

namespace C {

type storage = int;

// @entry

const increment = (action: int, store: storage) : [list <operation>, storage] => [list([]), store + action];

// @entry

const decrement = (action: int, store: storage) : [list <operation>, storage] => [list([]), store - action];

};

const testC = () => {

let initial_storage = 42;

let [taddr, _contract, _size] = Test.originate_module(contract_of(C), initial_storage, 0 as tez);

let contr : contract<parameter_of C> = Test.to_contract(taddr);

let p : parameter_of C = Increment(1);

let _ = Test.transfer_to_contract_exn(contr, p, 1 as mutez);

return assert(Test.get_storage(taddr) == initial_storage + 1);

}