INPUT / OUTPUT / LANGUAGE
INPUT / OUTPUT / LANGUAGE
A field that contains reusable code in the form of ioL tags and values, which can be reused each time an event is triggered. Event fields such as onClick are code fields, as are fields such as do and then.
The element of an array that the array's primary field currently points to, reached with .* after the array's name.
The single tag in the * field of an array or class, from which each element or instance is created.
The live, structured content that makes up the interface presented to the user in the console, including the tags and fields that define it, and all content presented to the user, constructed from the program's output.
The hierarchy of tags and fields that make up the document. Each tag instance exists within this tree, and fields may contain values, other tags, or code.
A single item in a list of values, such as one value in a vector field. Elements are numbered from 1, and can be counted with the .# operator and accessed with the .@ operator. (The tags created by an array tag are also called array elements.)
Something that happens while a program runs, such as a click, a key press or a timer going off. Code fields such as onClick hold code to be carried out each time their event happens.
A property of a tag that may contain values, tags, or code. Fields are used to define behaviour and structure within a tag. Each field is one of: a scalar field, a vector field, a code field, or a presentation container field. A tag instance has the fields it was given when it was created, and gains any other field the first time it is used through a path such as greeting.color.
Some tags generate a value or values as the result of carrying out an operation. The generated value(s) then become part of the surrounding document or expression. In some cases multiple values may be generated while a tag is being evaluated. For example, a "for" loop generates the contents of the loop repeatedly. Generated values are analogous (but not identical in all cases) to "return values" found in procedural programming languages.
A name attached to a tag when it is created, so the tag instance can be referred to later. The instance name is written in front of the tag type, followed by a colon: in <userName:input>, the instance name is userName.
The environment that runs a program, interprets the program's output as ioL, and presents the resulting document to the user. Input generated in the console (for example by a putLn tag) is sent back to the program as standard input. An ioL console may be provided by an operating system such as Proxima, or by the iol command on other systems.
A tag that creates a tag instance which remains in the document but has no visible presentation of its own, such as a vector, scalar or timer.
A field that allows deeper document structure within a presentation container tag.
A presentation tag that can contain nested presentation tags and persistent logic tags inside it.
A tag that creates visible or interactive content in the document and remains in the document as part of its structure.
The main field of a tag, which has no name of its own. It is the field that usually carries the tag's main content (i.e. value(s) assigned directly to the tag itself) when no field name within the tag is specified. Different tags use the primary field in different ways. (Older documentation calls this the default field.)
The tag inside a class instance that its primary field belongs to: the tag the class's _ field points to, or the outer tag of the class definition. Fields given to an instance that the class doesn't expose go to its primary tag.
A computing system whose user interface is built on ioL. In Proxima, the ioL console is provided by the operating system's VUI layer.
An unclosed .push: everything the program prints goes into the field being pushed into, until the push is closed with }>.
Data sent to the console in the form [n{...}], where n is the exact number of bytes. Raw data is never read as markup, so it's used for files such as pictures, and for text that might contain special characters.
A value that points to a tag instance or field, obtained with the .& operator and followed with the .* operator.
A field that contains a single value.
The part of the document where a name can be used without a path. Code can use names from the tags around it; names inside a tag are reached with a dot, as in card.job.
Any field of a tag other than its primary field. Secondary fields have names, and are assigned using the name=value form inside a tag.
Tags are instructions in ioL that may create tag instances, perform actions, or generate values. Tags are generally enclosed in angle brackets < > to differentiate them from regular output. The angle brackets may also enclose field initialisers, primary field values, and an instance name if present. In some syntactic cases where there is no ambiguity, the angle brackets are not required. Each tag falls into one of four categories: presentation tags, presentation container tags, persistent logic tags, and transient logic tags.
The lasting result of creating a presentation tag or persistent logic tag: an entry in the document tree that can be referred to, changed or removed afterwards (usually by its instance name). Transient logic tags do not create tag instances.
A shorthand for nesting tags: <a | b ...> means the same as <a <b ...>>.
A tag that performs an operation but does not remain in the document after it is evaluated. It may still generate one or more values corresponding to the result of the operation.
A piece of data. A value may be a single number, a piece of text (zero or more characters), a reference to a tag instance or field, or one of the following special values: null, true, false, inf, invalid.
A field that contains a list of values, separated by commas. An empty item in the list, as in 1,,2, means null.
Versatile User Interface: the layer of the Proxima operating system that acts as its ioL console.