The language described

The language described states what a Mica program is made of and what each of its constructs means, chapter by chapter. Where the grammar gives the rules a program is read by, a chapter here gives each rule its meaning: what the construct does, what it may and may not be combined with, and the words the compiler answers a source with when it breaks the rule, quoted as the compiler prints them.

Every example in a chapter is a complete program or library that the compiler’s own test suite compiles and runs on AMD64 and AArch64, or that the website’s gate compiles as the chapter marks it, and the output shown beneath it is the output the program prints; an example that needs a GPU to run, or that is built as a library, says so beside it. Chapter 8 is still to come, and the table names it without a link until it is written.

Chapter	Covers
1. Characters, names and literals	the text a source is, its comments and its first line, names and the words the language reserves, the operators, and every literal: integers, reals, characters, strings and regular expressions
2. Programs, libraries and imports	the program, the library and the object unit, the sections, routines and body of a block, the start value of every variable, exports and a library’s version, imports from every kind of source, how an imported name is found, and the project file
3. Declarations and scopes	constants with and without a type, the types a block declares, variables and their initial values, procedures, functions and their parameters, nested routines, what each declaration may refer to, and the scopes every name is looked up in
4. Types	the kinds of type and how each is written, the ordinal, real and structured types and their values, the types an operation takes and gives, promotion and conversions, when two types are one and what an assignment admits, and types with parameters
5. Expressions	operands and primaries, the operators by precedence and the types they take, integer arithmetic in its width and what the checked build traps, comparisons and the case test, the boolean, set and string operators, conversions with `as`, constant expressions, and calls
6. Statements	statements and their sequence, assignment and calls, `if` and `case` with every kind of label and the rule that a case covers its domain, the `while`, `repeat`, counted `for` and `for ... in` loops, named loops with `leave` and `next`, deferred statements and disposal
7. Routines	the kinds of routine and their headings, what a call evaluates and hands over, copies, `const`, pointers, conformant arrays and spans as parameters, what a function answers, recursion and nested routines
8. Generics, to come	generic routines and types, the capability words, inference and instantiation
9. Failures	the two kinds of failure, error domains and the routines that fail with `fails` and `fail`, the clauses a caller answers a failure with, what reaches the caller and the program, traps and their exit status, the checked tier, and failure in tasks, streams and worker processes
10. Memory	values and the copies an assignment and a call make, cells on the heap and their one owner, the hand-over, the read-out and the release of a container, borrowed pointers and the four rules that keep them valid, the stack, static storage and the heap, the hosted heap and the fixed arena, and what the checked tier stops at run time
11. Tasks, generators and processes	tasks and the task tree, the `concurrent` block, `schedule` and placement on carriers and on processes, generators and streams with pull chains, rings, stages, `into` and `select`, failure in a block and across a stream, cancellation and deadlines, lost workers, what the checked build traps and what the compiler refuses
12. Tensors and the tape	vectors, matrices and tensors with static and dynamic extents, the elementwise operations and the products, tracked values, tape windows, `Backward` and `Gradient`, tensors placed on the GPU with `ToDevice` and `ToHost`, and the floating-point flags of the optimizing build
13. The C boundary	imports from the C library, POSIX, Linux and a library’s contract, the types that cross and their C spelling, who releases a cell that crosses, exports with the contract and the header a library build writes, callbacks at contract slots, and what a C program sees

Characters, names and literals

Chapter 1 of the language described: the text a Mica source is, its comments and its first line, the names it declares and the words it reserves, its operators, and every literal it writes, each with its rule, its meaning and the compiler's refusals.

Programs, libraries and imports

Chapter 2 of the language described: the three kinds of unit a source is, the sections, routines and body of a block, the value every variable starts at, what a library exports and where its version comes from, imports from every kind of source, how an imported name is found, and the project file a build reads.

Declarations and scopes

Chapter 3 of the language described: the constants, types, variables, procedures and functions a block declares, the routines nested in them, what each declaration may refer to, and the scopes every name is looked up in, each with its rule, its meaning and the compiler's refusals.

Types

Chapter 4 of the language described: the kinds of type a value has, the ordinal, real and structured types and their values, the types an operation takes and gives, conversions, when two types are one and what an assignment admits, and types with parameters, each with its rule, its meaning and the compiler's refusals.

Expressions

Chapter 5 of the language described: how a Mica program computes a value, its operands, the operators by precedence and the types they take, integer arithmetic in its width and what the checked build traps, comparisons, the boolean, set and string operators, conversions, constant expressions and calls, each with its rule, its meaning and the compiler's refusals.

Statements

Chapter 6 of the language described: what a Mica statement does, assignment and calls, the choices 'if' and 'case', the loops 'while', 'repeat', 'for' and 'for ... in', named loops with 'leave' and 'next', deferred statements and disposal, each with its rule, its meaning and the compiler's refusals.

Routines

Chapter 7 of the language described: the kinds of routine and their headings, what a call evaluates and hands over, the parameter modes, what a function answers, recursion and nested routines, each with its rule, its meaning and the compiler's refusals.

Failures

Chapter 9 of the language described: the two kinds of failure, error domains and the routines that fail, what a caller does with a failure, what reaches the caller and the program, traps and their exit status, the checked tier, and failure in tasks, streams and worker processes, each with its rule, its meaning and the compiler's refusals.

Memory

Chapter 10 of the language described: values and copies, cells on the heap with one owner each, borrowed pointers and the rule that keeps them valid, where a program's memory lives, the hosted heap and the fixed arena, and what the checked tier stops at run time, each with its rule, its meaning and the compiler's refusals.

Tasks, generators and processes

Chapter 11 of the language described: tasks and the task tree, the concurrent block, schedule and placement on carriers and on processes, generators and streams with pull chains, rings, stages, into and select, failure in a block and across a stream, cancellation and deadlines, lost workers, what the checked build traps and what the compiler refuses.