Directives

There are a couple of compiler directives like #line or _pragma_ that affect the way the compilation is done. A full list is here.

Standard and strict typing mode

Mix is a typed language, but with a various degree of strictness. By default it is non-strict:

• the compiler inserts runtime type assertions to fix up typing problems
• the compiler tends to make types larger than specified if this allows it to continue (e.g. if (flag) 1 else [1] is permitted)
• the compiler often falls back to the quite broad type data when no other type would be possible
• compound literals like arrays or maps are assumed to be of type data unless overridden
• however, this doesn’t mean that everything is allowed - there are also non-data types (e.g. functions, streams) and it is not allowed to mix them with data

In strict mode (since PR#892):

• the compiler never inserts runtime type assertions automatically
• the compiler never inserts conversions automatically
• types are kept as small as possible
• data still exists but must be explicitly hinted by the programmer
• compound literals get the type of the corresponding compound type (e.g. tuple literals have tuple types)

You can select strict mode with

_pragma_ {strictTyping:true}

at the beginning of a module.

Meta data

Modules, functions and cells can be annotated with meta data. The key word _meta_ is followed by a constant JSON expression - which is by convention always an object:

module M _meta_ { ... }        // module with meta data
def f : t _meta_ { ... }       // function signature with meta data
cell c : t _meta_ { ... }      // cell signature with meta data

Deprecation

The form is:

_meta_ { deprecated:true, expires: "yyyy-mm-dd", alternatives: [ "alt1", "alt2", ... ] }

Renaming

The form is:

_meta_ { renamed:true, expires: "yyyy-mm-dd", replacement: "newname" }

Module type