Functions

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 JsLIGO, 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 can be defined in two main ways: using the keyword function or const (the keyword let is defaulted to const in this instance). The latter manner is preferred when the function body is an expression. For example, here is how you define a basic function that sums two integers:

const add = (a: int, b: int) => a + b;

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

ligo run evaluate-expr \

gitlab-pages/docs/language-basics/src/functions/add.jsligo \

'add(1,2)'

# Outputs: 3

If the body contains statements instead of a single expression, you would use a block and a return statement:

const myFun = (x: int, y: int) => {

const doubleX = x + x;

const doubleY = y + y;

return doubleX + doubleY;

};

although it is arguably more readable to use function, like so:

function myFun2 (x: int, y: int) {

const doubleX = x + x;

const 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, its name should start with _ to prevent warnings.

const k_other = (x: int, _y: 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:

const increment = (b) => ((a) => a + 1) (b);

const a = increment(1); // a == 2

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

ligo run 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.map(i => i + 1, l);

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

ligo run evaluate-call \

gitlab-pages/docs/language-basics/src/functions/incr_map.jsligo \

incr_map "list([1,2,3])"

# Outputs: CONS(2 , CONS(3 , CONS(4 , LIST_EMPTY()))), equivalent to list([ 2 , 3 , 4 ])

Nested functions (also known as closures)

It is possible to define a functions inside another function. These functions have access to variables in the same scope.

function closure_example (i) {

let closure = j => i + j;

return closure(i);

};

Recursive functions

In JsLigo, recursive functions are defined and called using the same syntax as non-recursive functions.

function sum (n: int, acc: int): int {

if (n < 1) return acc else return sum(n-1, acc + n);

};

function fibo (n: int, n_1: int, n_0: int): int {

if (n < 2) return n_1 else return fibo (n-1, n_1 + n_0, n_1);

};