<ulclass="crumbs"><li><ahref="../index.html">Home</a></li><li><ahref="index.html">inter</a></li><li><ahref="index.html#M">Manual</a></li><li><b>Data Packages in Textual Inter</b></li></ul></div>
<ulclass="toc"><li><ahref="M-dpiti.html#SP1">§1. Data packages</a></li><li><ahref="M-dpiti.html#SP2">§2. Variable and values</a></li><li><ahref="M-dpiti.html#SP6">§6. Constant and extended values</a></li><li><ahref="M-dpiti.html#SP11">§11. URL notation</a></li><li><ahref="M-dpiti.html#SP12">§12. Annotations</a></li><li><ahref="M-dpiti.html#SP13">§13. Metadata constants</a></li><li><ahref="M-dpiti.html#SP14">§14. Types in Inter</a></li><li><ahref="M-dpiti.html#SP20">§20. Enumerations and instances</a></li><li><ahref="M-dpiti.html#SP21">§21. Subtypes</a></li><li><ahref="M-dpiti.html#SP22">§22. Properties</a></li><li><ahref="M-dpiti.html#SP24">§24. Insert</a></li><li><ahref="M-dpiti.html#SP26">§26. Splats</a></li></ul><hrclass="tocbar">
<pclass="commentary firstcommentary"><aid="SP1"class="paragraph-anchor"></a><b>§1. Data packages. </b>To recap from <ahref="M-ti.html"class="internal">Textual Inter</a>: an Inter program is a nested hierarchy of
packages. Some are special <spanclass="extract"><spanclass="extract-syntax">_code</span></span> packages which define functions; the rest
we will call "data packages".<supid="fnref:1"><ahref="#fn:1"rel="footnote">1</a></sup> Note that the compulsory outer <spanclass="extract"><spanclass="extract-syntax">main</span></span> package
is a data package. The instructions which can appear in data packages are the
subject of this section.
</p>
<ulclass="footnotetexts"><liclass="footnote"id="fn:1"><pclass="inwebfootnote"><supid="fnref:1"><ahref="#fn:1"rel="footnote">1</a></sup> The term "data" is used rather loosely here. "Anything else packages"
might be a fairer description.
<ahref="#fnref:1"title="return to text">↩</a></p></li></ul>
<pclass="commentary firstcommentary"><aid="SP2"class="paragraph-anchor"></a><b>§2. Variable and values. </b>The instruction <spanclass="extract"><spanclass="extract-syntax">variable</span></span> seems a good place to begin, since it creates an
<pclass="commentary">declares a new variable <spanclass="extract"><spanclass="extract-syntax">V_score</span></span>, and assigns it the initial value 10. This
is a global variable, accessible across the whole program.
</p>
<pclass="commentary firstcommentary"><aid="SP3"class="paragraph-anchor"></a><b>§3. </b>A number of different notations are allowed as numerical values:
<ulclass="items"><li>● A decimal integer, which may begin with a minus sign (and, if so, will be
stored as twos-complement signed); for example, <spanclass="extract"><spanclass="extract-syntax">-231</span></span>.
</li><li>● A hexadecimal integer prefixed with <spanclass="extract"><spanclass="extract-syntax">0x</span></span>, which can write the digits
<spanclass="extract"><spanclass="extract-syntax">A</span></span> to <spanclass="extract"><spanclass="extract-syntax">F</span></span> in either upper or lower case form, but cannot take a minus sign;
for example, <spanclass="extract"><spanclass="extract-syntax">0x21BC</span></span>.
</li><li>● A binary integer prefixed with <spanclass="extract"><spanclass="extract-syntax">0b</span></span>, which cannot take a minus sign;
for example, <spanclass="extract"><spanclass="extract-syntax">0b1001001</span></span>.
</li><li>●<spanclass="extract"><spanclass="extract-syntax">r"text"</span></span> makes a literal real number: the text is required to use the
same syntax as a literal real number in Inform 6. For example, <spanclass="extract"><spanclass="extract-syntax">r"+1.027E+5"</span></span>.
The <spanclass="extract"><spanclass="extract-syntax">E+n</span></span> or <spanclass="extract"><spanclass="extract-syntax">E-n</span></span> exponent is optional, but if it is used, a <spanclass="extract"><spanclass="extract-syntax">+</span></span> or <spanclass="extract"><spanclass="extract-syntax">-</span></span> sign
is required; similarly, a <spanclass="extract"><spanclass="extract-syntax">+</span></span> or <spanclass="extract"><spanclass="extract-syntax">-</span></span> sign is required up front. So <spanclass="extract"><spanclass="extract-syntax">r"1.0"</span></span>
and <spanclass="extract"><spanclass="extract-syntax">r"3.7E7"</span></span> are both illegal.
</li></ul>
<pclass="commentary">Note that Inter does not specify the word size, that is, the maximum range
of integers; many Inter programs are written on the assumption that this will
be 16-bit and would fail if that assumption were wrong, or vice versa, but
other Inter programs work fine whichever is the case. Real numbers, however,
can only be used in 32-bit programs, and even then only have the accuracy
of <spanclass="extract"><spanclass="extract-syntax">float</span></span>, not <spanclass="extract"><spanclass="extract-syntax">double</span></span>.
<ulclass="items"><li>● Literal text is written in double quotes, <spanclass="extract"><spanclass="extract-syntax">"like so"</span></span>. All characters
within such text must have Unicode values of 32 or above, except for tab (9),
written <spanclass="extract"><spanclass="extract-syntax">\t</span></span>, and newline (10), written <spanclass="extract"><spanclass="extract-syntax">\n</span></span>. In addition, <spanclass="extract"><spanclass="extract-syntax">\"</span></span> denotes a
literal double-quote, and <spanclass="extract"><spanclass="extract-syntax">\\</span></span> a literal backslash, but these are the only
backslash notations at present allowed.
</li><li>●<spanclass="extract"><spanclass="extract-syntax">dw"text"</span></span> is meaningful only for interactive fiction, and represents the
command parser dictionary entry for the word <spanclass="extract"><spanclass="extract-syntax">text</span></span>. This is equivalent
to the Inform 6 constant <spanclass="extract"><spanclass="extract-syntax">'text//'</span></span>.
</li><li>●<spanclass="extract"><spanclass="extract-syntax">dwp"text"</span></span> is the same, but pluralised, equivalent to Inform 6 <spanclass="extract"><spanclass="extract-syntax">'text//p'</span></span>.
</li></ul>
<pclass="commentary firstcommentary"><aid="SP5"class="paragraph-anchor"></a><b>§5. </b>There are two oddball value notations which should be used as little as possible:
<ulclass="items"><li>●<spanclass="extract"><spanclass="extract-syntax">!undef</span></span> makes a special "this is not a value" value.
</li><li>●<spanclass="extract"><spanclass="extract-syntax">glob"raw syntax"</span></span> is a feature allowing raw code for the final target
language to be smuggled into Inter, which is supposedly target-independent.
For example, <spanclass="extract"><spanclass="extract-syntax">glob"#$magic"</span></span> says that the final code-generator should just
print out <spanclass="extract"><spanclass="extract-syntax">#$magic</span></span>, in blind faith that this will mean something, when it
wants the value in question. Glob is not a respectful term, but this feature
does not deserve respect, and is not used anywhere in the Inform tool chain.
</li></ul>
<pclass="commentary firstcommentary"><aid="SP6"class="paragraph-anchor"></a><b>§6. Constant and extended values. </b>The instruction <spanclass="extract"><spanclass="extract-syntax">constant</span></span> defines a name for a given value. For example:
<pclass="commentary firstcommentary"><aid="SP7"class="paragraph-anchor"></a><b>§7. </b>Constants also allow us to write more elaborate values than are normally
allowed — so-called "extended values". In particular:
<ulclass="items"><li>● A literal <spanclass="extract"><spanclass="extract-syntax">list</span></span> is written in braces: <spanclass="extract"><spanclass="extract-syntax">{ V1, V2, ..., Vn }</span></span>, where <spanclass="extract"><spanclass="extract-syntax">V1</span></span>,
<spanclass="extract"><spanclass="extract-syntax">V2</span></span> and so on are all (unextended) values. The empty list is <spanclass="extract"><spanclass="extract-syntax">{ }</span></span>.
</li><li>● A list of bytes, rather than words, is written <spanclass="extract"><spanclass="extract-syntax">bytes{ V1, V2, ..., Vn}</span></span>,
in the same way.
</li><li>● Either sort of list can be given with an extent instead. <spanclass="extract"><spanclass="extract-syntax">list of N words</span></span>
or <spanclass="extract"><spanclass="extract-syntax">list of N bytes</span></span> constructs a list of <spanclass="extract"><spanclass="extract-syntax">N</span></span> zero entries. This is not simply
an abbreviation for typing something like <spanclass="extract"><spanclass="extract-syntax">{ 0, 0, 0, 0, 0, 0, 0, 0 }</span></span>, because <spanclass="extract"><spanclass="extract-syntax">N</span></span>
does not have to be a literal number — it can be a named symbol defined elsewhere,
or even defined in a different Inter tree to be linked in later.
</li><li>● Prefixing either sort of list with the keyword <spanclass="extract"><spanclass="extract-syntax">bounded</span></span> tells Inter that
the first entry (i.e., at index 0) should be the number of entries, not counting
that first entry. (This number is the list's "bound".) Thus <spanclass="extract"><spanclass="extract-syntax">bounded { 70, 15 }</span></span>
is equivalent to <spanclass="extract"><spanclass="extract-syntax">{ 2, 70, 15 }</span></span>, and <spanclass="extract"><spanclass="extract-syntax">bounded list of 50 bytes</span></span> produces a list
of 51 bytes, the first being 50, the next fifty all being 0.
</li><li>● A structure is written <spanclass="extract"><spanclass="extract-syntax">struct{ V1, V2, ..., Vn }</span></span>. The empty <spanclass="extract"><spanclass="extract-syntax">struct</span></span>
<pclass="commentary firstcommentary"><aid="SP8"class="paragraph-anchor"></a><b>§8. </b>Readers with experience of Inform 6 will recognise that <spanclass="extract"><spanclass="extract-syntax">{ ... }</span></span> and <spanclass="extract"><spanclass="extract-syntax">bytes{ ... }</span></span>
correspond to I6's <spanclass="extract"><spanclass="extract-syntax">Array --></span></span> and <spanclass="extract"><spanclass="extract-syntax">Array -></span></span> respectively, that <spanclass="extract"><spanclass="extract-syntax">bounded { ... }</span></span>
and <spanclass="extract"><spanclass="extract-syntax">bounded bytes{ ... }</span></span> correspond to <spanclass="extract"><spanclass="extract-syntax">Array table</span></span> and <spanclass="extract"><spanclass="extract-syntax">Array buffer</span></span>, and
that <spanclass="extract"><spanclass="extract-syntax">list of N words</span></span> and <spanclass="extract"><spanclass="extract-syntax">list of N bytes</span></span> correspond to <spanclass="extract"><spanclass="extract-syntax">Array --> N</span></span> and
<spanclass="extract"><spanclass="extract-syntax">Array -> N</span></span>. Note, however, that Inter does not suffer from the ambiguity of
Inform 6's old syntax here. The Inter list <spanclass="extract"><spanclass="extract-syntax">{ 20 }</span></span> is unambiguously a one-entry
list whose one entry is 20; it is quite different from <spanclass="extract"><spanclass="extract-syntax">list of 20 words</span></span>.
</p>
<pclass="commentary firstcommentary"><aid="SP9"class="paragraph-anchor"></a><b>§9. </b>Lists are obviously useful. Here are some examples:
<pclass="commentary">The distinction between a <spanclass="extract"><spanclass="extract-syntax">struct</span></span> and a <spanclass="extract"><spanclass="extract-syntax">list</span></span> is only visible if typechecking
is used (see below); the expectation is that a list would contain a varying
number of entries all of the same type, whereas a struct would contain a fixed
number of entries of perhaps different but predetermined types.
<pclass="commentary firstcommentary"><aid="SP10"class="paragraph-anchor"></a><b>§10. </b>Calculated values are an unusual but very useful feature of Inter. Consider:
<pclass="commentary">This effectively declares that <spanclass="extract"><spanclass="extract-syntax">SAFE_SPEED</span></span> will be 65. What makes this useful
is that when two Inter programs are linked together, <spanclass="extract"><spanclass="extract-syntax">SAFE_SPEED</span></span> might be
declared in one and <spanclass="extract"><spanclass="extract-syntax">SPEED_LIMIT</span></span> in the other, and it all works even though
the compiler of one could see the 70 but not the 5, and the compiler of the
<pclass="commentary firstcommentary"><aid="SP11"class="paragraph-anchor"></a><b>§11. URL notation. </b>All identifier names are local to their own packages. So, for example, this:
<pclass="commentary">...does not work. The variable <spanclass="extract"><spanclass="extract-syntax">V_speed</span></span> is declared in package <spanclass="extract"><spanclass="extract-syntax">two</span></span>, where
the constant <spanclass="extract"><spanclass="extract-syntax">SPEED_LIMIT</span></span> does not exist.
<pclass="commentary">Here <spanclass="extract"><spanclass="extract-syntax">/main/one/SPEED_LIMIT</span></span> is an absolute "URL" of the symbol <spanclass="extract"><spanclass="extract-syntax">SPEED_LIMIT</span></span>.
<pclass="commentary">we see that the two variables have different URLs, <spanclass="extract"><spanclass="extract-syntax">/main/one/V_speed</span></span> and
<pclass="commentary firstcommentary"><aid="SP12"class="paragraph-anchor"></a><b>§12. Annotations. </b>A few of the defined names in Inter can be "annotated".
<pclass="commentary">All annotation names begin with a double underscore, <spanclass="extract"><spanclass="extract-syntax">__</span></span>. They do not all
express a value: some are boolean flags, where no <spanclass="extract"><spanclass="extract-syntax">=...</span></span> part is written.
<pclass="commentary firstcommentary"><aid="SP13"class="paragraph-anchor"></a><b>§13. Metadata constants. </b>If constant names begin with the magic character <spanclass="extract"><spanclass="extract-syntax">^</span></span> then they represent
<pclass="commentary firstcommentary"><aid="SP14"class="paragraph-anchor"></a><b>§14. Types in Inter. </b>Inter is an exceptionally weakly typed language. It allows the user to choose
<pclass="commentary">gives <spanclass="extract"><spanclass="extract-syntax">SPEED_LIMIT</span></span> the type <spanclass="extract"><spanclass="extract-syntax">unchecked</span></span>, not (say) <spanclass="extract"><spanclass="extract-syntax">int32</span></span>. If a storage object
such as a variable has type <spanclass="extract"><spanclass="extract-syntax">unchecked</span></span>, then anything can be put into it; and
conversely an <spanclass="extract"><spanclass="extract-syntax">unchecked</span></span> value can always be used in any context.
<pclass="commentary">The "type marker" <spanclass="extract"><spanclass="extract-syntax">(int32)</span></span>, which is intended to look like the C notation for
a cast, gives an explicit type. The following, however, will be rejected:
<pclass="commentary">This is because <spanclass="extract"><spanclass="extract-syntax">WARNING</span></span> has type <spanclass="extract"><spanclass="extract-syntax">text</span></span> and cannot hold an <spanclass="extract"><spanclass="extract-syntax">int32</span></span>. This is
typechecking in action, and although you must volunteer for it, it is real.
By conscientiously applying type markers throughout your program, you can
<pclass="commentary firstcommentary"><aid="SP15"class="paragraph-anchor"></a><b>§15. </b>An intentional hole in this type system is that literals which look wrong for
<pclass="commentary">The type of a constant or variable is always either <spanclass="extract"><spanclass="extract-syntax">unchecked</span></span> or else is
exactly what is declared in brackets, regardless of what the value after the
equals sign looks as if it ought to be. However, a weaker form of checking
is actually going on under the hood: numerical data has to fit. So for example:
<pclass="commentary">allows <spanclass="extract"><spanclass="extract-syntax">true</span></span> and <spanclass="extract"><spanclass="extract-syntax">false</span></span> to be declared, but throws an error on <spanclass="extract"><spanclass="extract-syntax">dunno</span></span>,
because 2 is too large a value to be stored in an <spanclass="extract"><spanclass="extract-syntax">int2</span></span>. Even this checking
can be circumvented with a named constant of type <spanclass="extract"><spanclass="extract-syntax">unchecked</span></span>, as here:
<pclass="commentary firstcommentary"><aid="SP16"class="paragraph-anchor"></a><b>§16. </b>Types are like values in that simple ones can be used directly, but to
make more complicated ones you need to give them names. The analogous
instruction to <spanclass="extract"><spanclass="extract-syntax">constant</span></span>, which names a value, is <spanclass="extract"><spanclass="extract-syntax">typename</span></span>, which names
a type.
</p>
<pclass="commentary">The basic types are very limited: <spanclass="extract"><spanclass="extract-syntax">int2</span></span>, <spanclass="extract"><spanclass="extract-syntax">int8</span></span>, <spanclass="extract"><spanclass="extract-syntax">int16</span></span>, <spanclass="extract"><spanclass="extract-syntax">int32</span></span>, <spanclass="extract"><spanclass="extract-syntax">real</span></span>
and <spanclass="extract"><spanclass="extract-syntax">text</span></span>. These are all different from each other, except that an <spanclass="extract"><spanclass="extract-syntax">int16</span></span>
can always be used as an <spanclass="extract"><spanclass="extract-syntax">int32</span></span> without typechecking errors, but not vice
<pclass="commentary">Note that Inter takes no position on whether or not these are signed; the
literal <spanclass="extract"><spanclass="extract-syntax">-6</span></span> would be written into an <spanclass="extract"><spanclass="extract-syntax">int8</span></span>, an <spanclass="extract"><spanclass="extract-syntax">int16</span></span> or an <spanclass="extract"><spanclass="extract-syntax">int32</span></span> in
a twos-complement signed way, but Inter treats all these just as bits.
</p>
<pclass="commentary">With just five types it really seems only cosmetic to use <spanclass="extract"><spanclass="extract-syntax">typename</span></span>:
<pclass="commentary">But what brings <spanclass="extract"><spanclass="extract-syntax">typename</span></span> into its own is that it allows the writing of
<pclass="commentary"><spanclass="extract"><spanclass="extract-syntax">list of T</span></span> is allowed only for simple types <spanclass="extract"><spanclass="extract-syntax">T</span></span>, so <spanclass="extract"><spanclass="extract-syntax">list of list of int32</span></span>,
say, is not allowed: but note that a typename is itself a simple type. So:
<pclass="commentary">will create a variable whose initial contents are a list of three lists of <spanclass="extract"><spanclass="extract-syntax">int2</span></span>
<ulclass="items"><li>●<spanclass="extract"><spanclass="extract-syntax">list of T</span></span> for any simple type or typename <spanclass="extract"><spanclass="extract-syntax">T</span></span>;
</li><li>●<spanclass="extract"><spanclass="extract-syntax">function T1 T2 ... Tn -> T</span></span> for any simple types <spanclass="extract"><spanclass="extract-syntax">T1</span></span>, <spanclass="extract"><spanclass="extract-syntax">T2</span></span>, and so on.
In the special case of no arguments, or no result, the notation <spanclass="extract"><spanclass="extract-syntax">void</span></span> is
used, but <spanclass="extract"><spanclass="extract-syntax">void</span></span> is not a type.
</li><li>●<spanclass="extract"><spanclass="extract-syntax">struct T1 T2 ... Tn</span></span> for any simple types <spanclass="extract"><spanclass="extract-syntax">T1</span></span>, <spanclass="extract"><spanclass="extract-syntax">T2</span></span>, and so on. There
must be at least one of these, so <spanclass="extract"><spanclass="extract-syntax">struct void</span></span> is not allowed.
</li><li>●<spanclass="extract"><spanclass="extract-syntax">enum</span></span>, for which see below;
</li><li>● and then a raft of constructions convenient for Inform but which Inter
really knows nothing about: <spanclass="extract"><spanclass="extract-syntax">column of T</span></span>, <spanclass="extract"><spanclass="extract-syntax">table of T</span></span>, <spanclass="extract"><spanclass="extract-syntax">relation of T1 to T2</span></span>,
<spanclass="extract"><spanclass="extract-syntax">description of T</span></span>, <spanclass="extract"><spanclass="extract-syntax">rulebook of T</span></span>, and <spanclass="extract"><spanclass="extract-syntax">rule T1 -> T2</span></span>. Perhaps these ought
to work via a general way for users to create new constructors, but for now
they are hard-wired. They do nothing except to be distinct from each other,
so that Inform can label its data.
</li></ul>
<pclass="commentary">Inter applies the usual rules of covariance and contravariance when matching
these types. For example:
</p>
<ulclass="items"><li>●<spanclass="extract"><spanclass="extract-syntax">list of int2</span></span> matches <spanclass="extract"><spanclass="extract-syntax">list of int32</span></span> but not vice versa (covariance
in the entry type);
</li><li>●<spanclass="extract"><spanclass="extract-syntax">function int32 -> void</span></span> matches <spanclass="extract"><spanclass="extract-syntax">function int2 -> void</span></span> but not vice versa
(contravariance in argument types);
</li><li>●<spanclass="extract"><spanclass="extract-syntax">function text -> int2</span></span> matches <spanclass="extract"><spanclass="extract-syntax">function text -> int32</span></span> but not vice versa
<pclass="commentary firstcommentary"><aid="SP18"class="paragraph-anchor"></a><b>§18. </b>This enables us to declare the type of a function. A typed version of <spanclass="extract"><spanclass="extract-syntax">Hello</span></span>
<pclass="commentary">creates a function called <spanclass="extract"><spanclass="extract-syntax">gcd</span></span> whose type is <spanclass="extract"><spanclass="extract-syntax">int32 int32 -> int32</span></span>.
Note that only <spanclass="extract"><spanclass="extract-syntax">_code</span></span> packages are allowed to be marked with a type, because
only <spanclass="extract"><spanclass="extract-syntax">_code</span></span> package names are values.
<pclass="commentary firstcommentary"><aid="SP20"class="paragraph-anchor"></a><b>§20. Enumerations and instances. </b>That leaves enumerations, which have the enigmatically concise type <spanclass="extract"><spanclass="extract-syntax">enum</span></span>.
Only a typename can have this type: it may be concise but it is not simple. (So
<spanclass="extract"><spanclass="extract-syntax">list of enum</span></span> is not allowed.) <spanclass="extract"><spanclass="extract-syntax">enum</span></span> is special in that each different time
it is declared, it makes a different type. For example:
<pclass="commentary">Here there are two different enumerated types: <spanclass="extract"><spanclass="extract-syntax">city</span></span> and another one which
can be called either <spanclass="extract"><spanclass="extract-syntax">country</span></span> or <spanclass="extract"><spanclass="extract-syntax">nation</span></span>.
<pclass="commentary">For obvious reasons, the type marker — in this case <spanclass="extract"><spanclass="extract-syntax">(city)</span></span>— is compulsory,
not optional as it was for <spanclass="extract"><spanclass="extract-syntax">constant</span></span>, <spanclass="extract"><spanclass="extract-syntax">variable</span></span> and <spanclass="extract"><spanclass="extract-syntax">package</span></span> declarations.
</p>
<pclass="commentary">At runtime, the values representing these instances are guaranteed to be different,
but we should not assume anything else about those values. The final code-generator
may choose to number them 1, 2, 3, but it may not. (When enumerations are used by
the Inform 7 tool-chain for objects, the runtime values will be object IDs in the
Z-machine or pointers to objects in Glulx or C, for instance.)
</p>
<pclass="commentary">If we need specific numerical values (which must be non-negative), we can specify
<spanclass="plain-syntax"> typename city = </span><spanclass="reserved-syntax">enum</span>
<spanclass="plain-syntax"></span><spanclass="reserved-syntax">instance</span><spanclass="plain-syntax"> (city) Berlin = </span><spanclass="constant-syntax">1</span>
<spanclass="plain-syntax"></span><spanclass="reserved-syntax">instance</span><spanclass="plain-syntax"> (city) Madrid = </span><spanclass="constant-syntax">17</span>
<pclass="commentary firstcommentary"><aid="SP21"class="paragraph-anchor"></a><b>§21. Subtypes. </b>Enumerated types, but no others, can be "subtypes". For example:
<pclass="commentary">An instance of <spanclass="extract"><spanclass="extract-syntax">K_tractor</span></span> is now automatically also an instance of <spanclass="extract"><spanclass="extract-syntax">K_vehicle</span></span>,
but the converse is not necessarily true.
</p>
<pclass="commentary">The right-hand side of the <spanclass="extract"><spanclass="extract-syntax"><=</span></span> sign is only allowed to be an enumerated typename,
and a new typename created in this way is, for obvious reasons, also enumerated.
<pclass="commentary firstcommentary"><aid="SP22"class="paragraph-anchor"></a><b>§22. Properties. </b>Inter supports a simple model of properties and values. (An enumerated typename
<spanclass="plain-syntax"></span><spanclass="reserved-syntax">propertyvalue</span><spanclass="plain-syntax"> population </span><spanclass="reserved-syntax">of</span><spanclass="plain-syntax"> Stockholm = </span><spanclass="constant-syntax">978770</span>
<spanclass="plain-syntax"></span><spanclass="reserved-syntax">propertyvalue</span><spanclass="plain-syntax"> population </span><spanclass="reserved-syntax">of</span><spanclass="plain-syntax"> Odessa = </span><spanclass="constant-syntax">1015826</span>
<spanclass="plain-syntax"></span><spanclass="reserved-syntax">propertyvalue</span><spanclass="plain-syntax"> motto </span><spanclass="reserved-syntax">of</span><spanclass="plain-syntax"> Odessa = </span><spanclass="string-syntax">"Pearl of the Black Sea"</span>
<pclass="commentary firstcommentary"><aid="SP23"class="paragraph-anchor"></a><b>§23. </b>An optional extended form of <spanclass="extract"><spanclass="extract-syntax">permission</span></span> is allowed which enables us to say
<spanclass="plain-syntax"></span><spanclass="reserved-syntax">permission</span><spanclass="plain-syntax"> for city to have population population_storage</span>
<ulclass="footnotetexts"><liclass="footnote"id="fn:2"><pclass="inwebfootnote"><supid="fnref:2"><ahref="#fn:2"rel="footnote">2</a></sup> The feature exists in Inter because of Inform 7's ability to define kinds
with tables, so that the storage lists are the columns of the table in
question. Because I7 allows those properties to be modified or read either
qua properties or qua table entries, we cannot avoid giving Inter a similar
ability, even though we might prefer not to.
<ahref="#fnref:2"title="return to text">↩</a></p></li></ul>
<pclass="commentary firstcommentary"><aid="SP25"class="paragraph-anchor"></a><b>§25. </b>Well, okay then. This exists to implement very low-level features of Inform 7,
going back to its earliest days as a programming language, when people were
still writing strange hybrid programs partly in I6.
<pclass="commentary"><spanclass="extract"><spanclass="extract-syntax">insert</span></span> tells Inter that it needs to add this raw I6-syntax material to the
<pclass="commentary firstcommentary"><aid="SP26"class="paragraph-anchor"></a><b>§26. Splats. </b>And never use <spanclass="extract"><spanclass="extract-syntax">splat</span></span> either.
<pclass="commentary firstcommentary"><aid="SP27"class="paragraph-anchor"></a><b>§27. </b>Well, okay then. We do in fact temporarily make splats when compiling kit