ligo/gitlab-pages/docs/language-basics/loops.md

id	title
loops	Loops

While Loop

The PascaLIGO while loop should look familiar to users of imperative languages. While loops are of the form while <condition clause> <block>, and evaluate their associated block until the condition evaluates to false.

⚠️ The current PascaLIGO while loop has semantics that have diverged from other LIGO syntaxes. The goal of LIGO is that the various syntaxes express the same semantics, so this will be corrected in future versions. For details on how loops will likely work after refactoring, see the CameLIGO tab of this example.

function while_sum (var n : nat) : nat is block {
  var i : nat := 0n ;
  var r : nat := 0n ;
  while i < n block {
    i := i + 1n;
    r := r + i;
  }
} with r

Loop.fold_while is a fold operation that takes an initial value of a certain type and then iterates on it until a condition is reached. The auxillary function that does the fold returns either boolean true or boolean false to indicate whether the fold should continue or not. The initial value must match the input parameter of the auxillary function, and the auxillary should return type (bool * input).

continue and stop are provided as syntactic sugar for the return values.

let aux (i: int) : bool * int =
  if i < 100 then continue (i + 1) else stop i

let counter_simple (n: int) : int =
  Loop.fold_while aux n

Loop.fold_while is a fold operation that takes an initial value of a certain type and then iterates on it until a condition is reached. The auxillary function that does the fold returns either boolean true or boolean false to indicate whether the fold should continue or not. The initial value must match the input parameter of the auxillary function, and the auxillary should return type (bool, input).

continue and stop are provided as syntactic sugar for the return values.

let aux = (i: int): (bool, int) =>
  if (i < 100) {
    continue(i + 1);
  } else {
    stop(i);
  };

let counter_simple = (n: int): int => Loop.fold_while(aux, n);```

<!--END_DOCUSAURUS_CODE_TABS-->

## For Loop

<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->

To iterate over a range of integers you use a loop of the form `for <variable assignment> to <integer> <block>`.

```pascaligo
function for_sum (var n : nat) : int is block {
  var acc : int := 0 ;
  for i := 1 to int(n)
    begin
      acc := acc + i;
    end
} with acc

PascaLIGO for loops can also iterate through the contents of a collection. This is done with a loop of the form for <element var> in <collection type> <collection var> <block>.

function for_collection_list (var nee : unit) : (int * string) is block {
  var acc : int := 0;
  var st : string := "to";
  var mylist : list(int) := list 1; 1; 1 end;
  for x in list mylist
    begin
      acc := acc + x;
      st := st ^ "to";
    end
} with (acc, st)