## 5.3  Array Notation

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.