Array Notation

## 5.3 Array Notation

- Implementation Note

Since our language has no type declarations, there is really no difference between a structure and an array. In fact, a structure can always be used as an array, creating it with functor/3 and accessing elements with arg/3. However, this can look clumsy, especially in arithmetic expressions.
ECLiPSe therefore provides array syntax which enables the programmer to write code like

>     [eclipse 1]: Prime = a(2,3,5,7,11), X is Prime[2] + Prime[4].
>     X = 10
>     Prime = a(2, 3, 5, 7, 11)
>     yes.

Within expressions, array elements can be written as variable-indexlist or structure-indexlist sequences, e.g.

>     X[3] + M[3,4] + s(4,5,6)[3]

Indices run from 1 up to the arity of the array-structure. The number of array dimensions is not limited.
To create multi-dimensional arrays conveniently, the built-in dim/2 is provided (it can also be used backwards to access the array dimensions):

>     [eclipse]: dim(M,[3,4]), dim(M,D).
>     M = []([](_131, _132, _133, _134),
>            [](_126, _127, _128, _129),
>            [](_121, _122, _123, _124))
>     D = [3, 4]
>     yes.

Although dim/2 creates all structures with the functor [ ], this has no significance other than reminding the programmer that these structures are intended to represent arrays.
Array notation is especially useful within loops. Here is the code for a matrix multiplication routine:

>     matmult(M1, M2, M3) :-
>             dim(M1, [MaxIJ,MaxK]),
>             dim(M2, [MaxK,MaxIJ]),
>             dim(M3, [MaxIJ,MaxIJ]),
>             (
>                 for(I,1,MaxIJ),
>                 param(M1,M2,M3,MaxIJ,MaxK)
>             do
>                 (
>                     for(J,1,MaxIJ),
>                     param(M1,M2,M3,I,MaxK)
>                 do
>                     (
>                         for(K,1,MaxK),
>                         fromto(0,Sum0,Sum1,Sum),
>                         param(M1,M2,I,J)
>                     do
>                         Sum1 is Sum0 + M1[I,K] * M2[K,J]
>                     ),
>                     subscript(M3, [I,J], Sum)
>                 )
>             ).

### 5.3.1 Implementation Note

Array syntax is implemented by parsing variable-list and structure-list sequences as terms with the functor subscript/2. For example:

>     X[3]          --->      subscript(X, [3])
>     M[3,4]        --->      subscript(M, [3,4])
>     s(4,5,6)[3]   --->      subscript(s(4,5,6), [3])

If such a term is then used within an arithmetic expression, a result argument is added and the built-in predicate subscript/3 is called, which is a generalised form of arg/3 and extracts the indicated array element.
When printed, subscript/2 terms are again printed in array notation, unless the print-option to suppress operator notation ("O") is used.