“Hello, World!” Explained
Let’s examine the program
Use namespace 'Console' @Main ( Print "Hello, World!" nl )
When compiled the program above produces a module with (case insensitive) name
Hello World. A module is a top-level object containing all other objects
declared in the same program.
The statements are organized in sentences. Sentences may end with periods. But the period is optional at the end of line.
The names are case-insensitive. The capital letters are used only at the sentence beginnings, like in natural text. This is grammatically correct, but is not required.
“Use Namespace” Directive
The first line
Use namespace 'Console'
contains a directive, which makes objects declared in the module
available in the file this directive appears in.
Console is a built-in module containing
Use namespace is a directive, which doesn’t mean it is some sort of a
keyword. Directives are regular objects interpreted by compiler rather than
executed at run time.
Note that the name
Use namespace consists of two words separated by space.
Names in o42a may consist of multiple words, numbers and hyphens separated
The whole statement is a phrase, which is an advanced syntax construct. Programmers may define custom rules for phrase syntax. This may improve readability, but is not required, as any phrase can be written in a canonical form. For example, the statement above can be rewritten as following:
Use namespace ( Module = "Console" )
Note that in contrast to canonical form, where double quotes are used
Console string, the phrase itself uses single quotes. The difference
is in their interpretation: a double quoted string is always an expression of
string type, while a single quoted string is always a part of the phrase
and is interpreted accordingly to the rules of that phrase. In the above
situation, there is no difference between the two forms. But there is
a difference between the following expressions:
float '1234.5' ~~ This is a floating-point number definition. float "1234.5" ~~ This is an error, as there is no obvious connection ~~ between strings and floats.
The following construct
@Main ( ~~ Declarations )
declares a field. A commercial at (
@) sign means that
Main is not a field
name. Instead, it is an object reference, which is used as a field identifier.
Any field in o42a can be declared with either textual name or object as its
identifier. In the latter case the field is called adapter. Adapter declares
an interface for enclosing object in addition to inherited one.
Adapters are useful in many situations, such as automatic type casts.
Main is an object defined in
Console module and is treated specially.
When a module has a
Main interface, either inherited or declared as adapter,
this interface is used as a main function of the program. When the program is
executed it evaluates the value of this interface. I.e. either inherited
object’s value, or adapter’s value respectively.
The syntax above is a shorter way of writing the following:
@Main := * ( ~~ Declarations )
:= sign here means a new field declaration.
An asterisk (
*) is an implied reference. This means the field is derived
from some object, that can be determined automatically. In this case the
automatically determined ascending object is
Main, as every adapter implicitly
derives its identifier object.
(..)) here enclose a block of declarative code. Such code may
contain field declarations and simple statements evaluating to the object value.
In contrast, an imperative code blocks are enclosed in braces (
They may contain a more advanced value evaluation logic, such as loops,
but cannot declare fields.
Note that the module definition itself is declarative.
Now to the
@Main adapter definition.
Print "Hello, World!" nl
Console module and does what expected:
prints a message to console.
The whole expression is a phrase and can be rewritten roughly as following:
Print (Text = "Hello, World!") ~~ Message Print (Text = "\n") ~~ New line