An N-tuple is a sequence of n elements, where N is a positive integer. In Opa, an N-tuple is just a record with fields f1 to fN:

x = (1,)          // a tuple of size 1, the same as {f1:1}
x = (1,"2",{a:3}) // a size 3 tuple, the same as {f1:1, f2:"2", f3:{a:3}} 
y = {x with f1:2} // we can manipulate a tuple the same way as a 
                    //record
// y = {f1:2, f2:"2", f3:{a:3}}

Note the trailing comma in the first case; it differentiates a 1-tuple from a parenthesized expression. The trailing comma is allowed for any other tuple, although, it makes no difference whether you write it or not in these cases.

In C language or Java, we use a for or a while loop to iterate through lists or arrays. They look something like this:

int[] numbers = [1,2,3,4,5]
for(int i=0; i<numbers.length; i++){ //do something }

But in Opa, it is totally different. To loop through a list, we use List.fold or List.foldi. List.fold is a powerful function that you can use to do almost anything you want on a list. Here is a simple example of getting the length of a list:

len = List.fold(function(_,i){ i+1 }, ["a","b","c"], 0)

List.fold takes three parameters. The first is a function, the second is the list, and the third is an initial value. It loops through the list and applies the function on each element. So, if we name the function f, it is executed something like this:

len = f("c", f("b", f("a",0)))

First, f("a",0) will be executed and will return 1, here 0 is the initial value and a is the first element. Then f("b",1) will return 2 and at last f("c",2) will return 3. Here is a little more complicated example:

//find the max natural number in the list
max = List.fold(function(x,a){ 
  if(x > a) x else a
},[1,4,3,2,7,8,5],0)

We have many ways to find an element in a list. List.index searches the first occurrence of an element and returns its index. List.index_p searches the first occurrence of any element matching a given function and returns its index. List.find is the same as List.index_p, but returns the element itself but not its index. For example:

l = ["a","b","c"]
r1 = List.index("b",l)                      // r1 = {some:1}
r2 = List.index("x",l)                      // r2 = {none}
r3 = List.index_p(function(x){ x == "b"},l) // r3 = {some:1}
r4 = List.find(function(x){ x == "b"},l)    // r4 = {some:"b"}

If you want to project elements to a new list, for example doubling the number in a list or selecting the odd numbers, you can do this with List.map and List.filter. Here are some examples:

l1 = [1,2,3,4,5]
l2 = List.map(function(x){ 2*x }, l1); //l2 = [2,4,6,8,10]
l3 = List.filter(function(x){mod(x,2) == 0},l1); // l3 = [2,4]

Call the function List.sort to sort a list in the usual order. The usual order means the default order, that is, numbers from small to big and strings in alphabetical order. Consider the following code:

l1 = List.sort(["by","as","of","At"]) //l1 = ["At","as","by","of"]
l2 = List.sort([1,3,4,6,2])           //l2 = [1,2,3,4,6]

List.sort_by uses the usual order, but it projects elements, for example, converting strings to lower-case before comparing them. List.sort_with allows us to use our own comparing function.

To make that clear, suppose there are three points, P1 (1, 3), P2 (3, 2), and P3 (2, 1), and we want to sort them in two different ways:

Let's see how to do that in Opa:

p = [{x:1,y:3},{x:3,y:2},{x:2,y:1}]
l1 = List.sort_with(function(p1,p2){  // sort by Y corordination
  if(p1.y >= p2.y) {gt} else {lt}
},p)
l2 = List.sort_by(function(p){        //sort by distance
  p.x*p.x + p.y*p.y    
},p)