Version: 0.21.0


LIGO functions are the basic building block of contracts. For example, entrypoints are functions and each smart contract needs a main function that dispatches control to the entrypoints (it is not already the default entrypoint).

The semantics of function calls in LIGO is that of a copy of the arguments but also of the environment. In the case of PascaLIGO, this means that any mutation (assignment) on variables outside the scope of the function will be lost when the function returns, just as the mutations inside the functions will be.

Declaring Functions#

Functions in JsLIGO are defined using the let or const keyword, like other values. The difference is that parameters are provided after the value name, with its type, then followed by the return type.

Here is how you define a basic function that sums two integers:

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

You can call the function add defined above using the LIGO compiler like this:

ligo evaluate-call gitlab-pages/docs/language-basics/src/functions/blockless.jsligo add '(1,2)'
# Outputs: 3

As in CameLIGO and with blockless functions in PascaLIGO, the function body is a single expression, whose value is returned.

If the body contains more than a single expression, you use block between braces:

let myFun = ([x, y]: [int, int]): int => {
let doubleX = x + x;
let doubleY = y + y;
return doubleX + doubleY;

Note that JsLIGO, like JavaScript, requires the return keyword to indicate what is being returned. If return is not used, it will be the same as return unit.

By default, LIGO will warn about unused arguments inside functions. In case we do not use an argument, we can use the wildcard _ to prevent warnings. Either use _ instead of the argument identifier:

let k = ([x, _] : [int, int]) : int => x;

or use an identifier starting with wildcard:

let k = ([x, _y] : [int, int]) : int => x;

Anonymous functions (a.k.a. lambdas)#

It is possible to define functions without assigning them a name. They are useful when you want to pass them as arguments, or assign them to a key in a record or a map.

Here is how to define an anonymous function:

let increment = (b: int): int => ((a: int): int => a + 1) (b);
let a: int = increment(1); // a == 2

You can check the value of a defined above using the LIGO compiler like this:

ligo evaluate-expr gitlab-pages/docs/language-basics/src/functions/anon.jsligo a
# Outputs: 2

If the example above seems contrived, here is a more common design pattern for lambdas: to be used as parameters to functions. Consider the use case of having a list of integers and mapping the increment function to all its elements.

let incr_map = (l: list<int>): list<int> => int) => i + 1, l);

You can call the function incr_map defined above using the LIGO compiler like so:

ligo evaluate-call
gitlab-pages/docs/language-basics/src/functions/incr_map.jsligo incr_map
"list [1;2;3]"
# Outputs: [ 2 ; 3 ; 4 ]

Nested functions (also known as closures)#

It's possible to place functions inside other functions. These functions have access to variables in the same scope.

let closure_example = (i: int): int => {
let closure = (j: int): int => i + j;
return closure(i);