Reference:Array - Revision history

Jr: fix wording

2025-05-09T11:09:23Z

fix wording

Maurice: Precision about 40 char limited version number

2021-07-02T20:49:42Z

Precision about 40 char limited version number

Jholsenback: relocate example

2018-12-08T11:14:28Z

relocate example

Jholsenback: technical correction

2018-12-06T08:35:39Z

technical correction

Jholsenback: clarity

2018-10-07T08:45:43Z

clarity

Jholsenback: missed a key point

2018-10-04T11:08:42Z

missed a key point

Jholsenback: mixed array additions

2018-10-04T10:55:08Z

mixed array additions

Jholsenback: version changes

2017-06-26T10:07:16Z

version changes

Clipka: Indexentries fix

2016-12-16T15:14:57Z

Indexentries fix

Jholsenback: merged changes from talk page

2016-12-13T18:52:24Z

merged changes from talk page

Show changes

@@ Line 49: / Line 49: @@
 </pre>
-<p>It declares an uninitialized array of ten elements. The elements are referenced as <code>MyArray[0]</code> through <code>MyArray[9]</code>. As yet, the type of the elements are undetermined. Once you have initialized any element of the array, all other elements can only be defined as that type. {{New}} in version 3.8 this behavior can be over-ridden by using the <code>mixed</code> keyword in the array declaration allowing mixed-type elements. Irregardless of whether the array elements have mixed-types or not, any attempt to reference an uninitialized element results in an error. More below:</p>
+<p>It declares an uninitialized array of ten elements. The elements are referenced as <code>MyArray[0]</code> through <code>MyArray[9]</code>. As yet, the type of the elements are undetermined. Once you have initialized any element of the array, all other elements can only be defined as that type. {{New}} in version 3.8 this behavior can be over-ridden by using the <code>mixed</code> keyword in the array declaration allowing mixed-type elements. Regardless of whether the array elements have mixed-types or not, any attempt to reference an uninitialized element results in an error. More below:</p>
 <pre>

@@ Line 39: / Line 39: @@
 <p>Where IDENTIFIER is the name of the identifier and INT is a valid float expression, internally truncated to an integer, and used to specify the size of the array.</p>
-<p class="Note"><strong>Note:</strong> In previous versions IDENTIFIER names <em>were</em> limited to 40 characters. There has been a {{Change}} removing that restriction.</p>
+<p class="Note"><strong>Note:</strong> In versions prior to 3.6.2, IDENTIFIER names <em>were</em> limited to 40 characters. There has been a {{Change}} removing that restriction.</p>
 <p>See [[Reference:Array#Array Initializers|Array Initializers]] for more about the optional <em>ARRAY_INITIALIZER</em> parameter.</p>

@@ Line 57: / Line 57: @@
 #declare MyArray[2] = normal{bumps 0.2}  //generates an error
 #declare Thing = MyArray[4]              //error: uninitialized array element
 </pre>
@@ Line 137: / Line 143: @@
 #declare local.Foo = 4711;
 #undef global.Foo
 </pre>

@@ Line 132: / Line 132: @@
 // remove a key from a dictionary
-#undef Fnord["Foo"];
+#undef Fnord["Foo"]
 // declare a local and un-define any global variable of same name
 #declare local.Foo = 4711;
-#undef global.Foo;
+#undef global.Foo
 // mixed-type array declaration

@@ Line 19: / Line 19: @@
 <pre>
 ARRAY_DECLARATION:
-   #declare IDENTIFIER = array[ mixed ][ INT ][[ INT ]]..[ARRAY_INITIALIZER] |
+   #declare IDENTIFIER = array [mixed] [[ INT ]]..[ARRAY_INITIALIZER] |
-   #local IDENTIFIER = array[ mixed ][ INT ][[ INT ]]..[ARRAY_INITIALIZER]
+   #local IDENTIFIER = array [mixed] [[ INT ]]..[ARRAY_INITIALIZER]
 ARRAY_INITIALIZER:
    {ARRAY_ITEM, [ARRAY_ITEM, ]... }
@@ Line 32: / Line 32: @@
    {DICTIONARY_ITEM, [DICTIONARY_ITEM, ]... }
 DICTIONARY_ITEM:
-   ["STRING"]: DICTIONARY_ENTRY | .STRING_IDENTIFIER: DICTIONARY_ENTRY
+   [ STRING ] : DICTIONARY_ENTRY | .STRING_IDENTIFIER: DICTIONARY_ENTRY
 DICTIONARY_ENTRY:
    Any valid array entry
@@ Line 49: / Line 49: @@
 </pre>
-<p>It declares an uninitialized array of ten elements. The elements are referenced as <code>MyArray[0]</code> through <code>MyArray[9]</code>. As yet, the type of the elements are undetermined. Once you have initialized any element of the array, all other elements can only be defined as that type. {{New}} in version 3.8 this behavior can be over-ridden by using the <code>mixed</code> keyword in the array declaration allowing mixed-type elements. Any attempt to reference an uninitialized element results in an error. More below:</p>
+<p>It declares an uninitialized array of ten elements. The elements are referenced as <code>MyArray[0]</code> through <code>MyArray[9]</code>. As yet, the type of the elements are undetermined. Once you have initialized any element of the array, all other elements can only be defined as that type. {{New}} in version 3.8 this behavior can be over-ridden by using the <code>mixed</code> keyword in the array declaration allowing mixed-type elements. Irregardless of whether the array elements have mixed-types or not, any attempt to reference an uninitialized element results in an error. More below:</p>
 <pre>

@@ Line 3: / Line 3: @@
 {{#indexentry:array, dictionary}}
 {{#indexentry:dictionary, array}}
 {{#indexentry:array}}
 {{#indexentry:keyword, global, dictionary}}
@@ Line 8: / Line 10: @@
 {{#indexentry:global, dictionary}}
 {{#indexentry:local, dictionary}}
-<p>You may declare arrays of identifiers with up to five dimensions. Any item that can be declared as an identifier can be declared in an array. Consequential to the improvements with the classic <code>array</code> container topology, a {{New}} feature in version 3.8 extended functionality to allow the creation of <code>dictionary</code> container types. Dictionaries can be used for mapping string keys to arbitrary-type values.</p>
+<p>You may declare arrays of identifiers with up to five dimensions. Any item that can be declared as an identifier can be declared in an array. Consequential to the improvements with the classic <code>array</code> container topology, two {{New}} features in version 3.8 extended functionality to allow the creation of <code>dictionary</code> container types. Additionally arrays now support a mixed-type declaration. Dictionaries can be used for mapping string keys to arbitrary-type values. The mixed-type declaration allows the array to hold elements of different types.</p>
 ==Declaring Arrays==
@@ Line 17: / Line 19: @@
 <pre>
 ARRAY_DECLARATION:
-   #declare IDENTIFIER = array[ INT ][[ INT ]]..[ARRAY_INITIALIZER] |
+   #declare IDENTIFIER = array[ mixed ][ INT ][[ INT ]]..[ARRAY_INITIALIZER] |
-   #local IDENTIFIER = array[ INT ][[ INT ]]..[ARRAY_INITIALIZER]
+   #local IDENTIFIER = array[ mixed ][ INT ][[ INT ]]..[ARRAY_INITIALIZER]
 ARRAY_INITIALIZER:
    {ARRAY_ITEM, [ARRAY_ITEM, ]... }
@@ Line 135: / Line 137: @@
 #declare local.Foo = 4711;
 #undef global.Foo;
 </pre>

@@ Line 8: / Line 8: @@
 {{#indexentry:global, dictionary}}
 {{#indexentry:local, dictionary}}
-<p>You may declare arrays of identifiers with up to five dimensions. Any item that can be declared as an identifier can be declared in an array. Consequential to the improvements with the classic <code>array</code> container topology, a {{New}} feature in version 3.7.1 extended functionality to allow the creation of <code>dictionary</code> container types. Dictionaries can be used for mapping string keys to arbitrary-type values.</p>
+<p>You may declare arrays of identifiers with up to five dimensions. Any item that can be declared as an identifier can be declared in an array. Consequential to the improvements with the classic <code>array</code> container topology, a {{New}} feature in version 3.8 extended functionality to allow the creation of <code>dictionary</code> container types. Dictionaries can be used for mapping string keys to arbitrary-type values.</p>
 ==Declaring Arrays==
@@ Line 84: / Line 84: @@
 <p>Any legitimate use of the <code>#declare</code> directive can also be put into an array. In other words, you can also create multidimensional arrays by making an array of arrays.</p>
-<p>{{New}} to version 3.7.1 points to also consider:</p>
+<p>{{New}} to version 3.8 points to also consider:</p>
 <ul>
    <li>Array elements no longer have to be all of the same type. However, be aware that mixing elements of different types will increase memory consumption. That increased memory footprint will not revert even if the array is later set to elements all of the same type.</li>

@@ Line 10: / Line 10: @@
 <p>You may declare arrays of identifiers with up to five dimensions. Any item that can be declared as an identifier can be declared in an array. Consequential to the improvements with the classic <code>array</code> container topology, a {{New}} feature in version 3.7.1 extended functionality to allow the creation of <code>dictionary</code> container types. Dictionaries can be used for mapping string keys to arbitrary-type values.</p>
 {{#indexentry:Array, declaring}}
 {{#indexentry:Declaring, arrays}}
 <p>The syntax is as follows:</p>
@@ Line 137: / Line 137: @@
 </pre>
 {{#indexentry:Array, initialization}}
 {{#indexentry:Initialization, arrays}}
 <p>Because it can be cumbersome to individually initialize the elements of an array, you may initialize it as it is created using <code>array</code> initializer syntax.</p>
 <pre>