LIGO

LIGO is a friendly smart-contract language for Tezos

Michelson was never so easy

PascaLIGO

CameLIGO

ReasonLIGO (coming soon)

// variant defining pseudo multi-entrypoint 
// actions
type action is
| Increment of int
| Decrement of int

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

function subtract 
  (const a: int; const b: int): int 
  is block { skip } with a - b

// real entrypoint that re-routes the flow 
// based on the action provided
function main 
  (const p: action; const s: int): 
  (list(operation) * int) is
 block { skip } 
  with ((nil : list(operation)),
    case p of
    | Increment(n) -> add(s, n)
    | Decrement(n) -> subtract(s, n)
  end)

// variant defining pseudo multi-entrypoint actions
type action is
| Increment of int
| Decrement of int

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

function subtract (const a : int ; const b : int) : int is
 block { skip } with a - b

// real entrypoint that re-routes the flow based 
// on the action provided
function main (const p : action ; const s : int) : 
  (list(operation) * int) is
 block { skip } with ((nil : list(operation)),
  case p of
  | Increment(n) -> add(s, n)
  | Decrement(n) -> subtract(s, n)
 end)

type storage = int

(* variant defining pseudo multi-entrypoint 
  actions *)
type action =
  | Increment of int
  | Decrement of int

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

let subtract (a: int) (b: int): int = a - b

(* real entrypoint that re-routes the flow 
   based on the action provided *)
let%entry main(p : action) storage =
  let storage =
    match p with
    | Increment n -> add storage n
    | Decrement n -> subtract storage n
  in (([] : operation list), storage)

type storage = int

(* variant defining pseudo multi-entrypoint actions *)
type action =
  | Increment of int
  | Decrement of int

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

let subtract (a: int) (b: int): int = a - b

(* real entrypoint that re-routes the flow based on 
   the action provided *)
let%entry main(p : action) storage =
  let storage =
    match p with
    | Increment n -> add storage n
    | Decrement n -> subtract storage n
  in (([] : operation list), storage)