It seeks to be easy to use, extensible and safe.
// 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)
Write types, then code, and benefit from the safety coming from type systems.
Write in PascaLIGO (pascal-like syntax) or CameLIGO (caml-like syntax). If you know OCaml, you can also add your own syntax.
With Granary, you can use LIGO as a lib from NodeJS.
