Constructors for CVX cells and related type predicate functions.

Also constructors for a few common idioms such as creating a [[def]] form.

Code execution in the CVM, altering state, and gaining insights.

Central entities of this namespaces are contextes and they can be created using [[ctx]].

All other functions revolve around them. While the design of a context is mostly immutable, whenever an altering function
is applied (eg. [[juice-set]]) or code is handled in any way (eg. [[eval]]), old context must be discarded and only returned
one should be used.

Cheap copies can be created using [[fork]].

Actions involving code (eg. [[compile]], [[exec]], ...) return a new context which holds either a [[result]] or an [[exception]].
Those actions always consume [[juice]].

Given that a "cell" is the term reserved for CVX data and objects, execution consists of following steps:

| Step | Function | Does |
|---|---|---|
| 1 | [[expand]] | `cell` -> `canonical cell`, applies macros |
| 2 | [[compile|| | `canonical cell` -> `op`, preparing executable code |
| 3 | [[exec]] | Executes compiled code |

Any cell can be applied safely to those functions, worse that can happen is nothing (eg. providing an already compiled cell to
[[compile]]).

If fine-grained control is not needed and if source is not compiled anyways, a simpler alternative is to use [[eval]] which does
all the job.

Reading, parsing various kind of sources into CVX cells without any evaluation.

Attention, currently, functions that read only one cell fail when the input contains more than one.
In the future, behavior should be improved. For instance, consuming cells one by one from a stream.

Also see the [[convex.write]] namespace for the opposite idea.

Convex Lisp Runner.

Executes each form as a transaction, moving from transaction to transaction.

A transaction can return a request to perform operations beyond the scope of the CVM, such as file IO or
advancing time. Those requests turn Convex Lisp, a somewhat limited and fully deterministic language, into
a scripting facility.

Requests are vectors following expected conventions and implementations can be found in the [[convex.run.sreq]]
namespace.

A series of CVX libraries is embedded, building on those requests and the way the runner generally operates,
providing features such as reading CVX files, unit testing, a REPL, or time-travel. All features are self
documented in the grand tradition of Lisp languages.

Functions throughout these namespaces often refer to `env`. It is an environment map passed around containing
everything that is need by an instance: current CVM context, opened streams, current error if any, etc.

In case of error, [[convex.run.exec/fail]] must be used so that the error is reported to the CVX executing environment.

List of transactions pending for execution is accessible in the CVX execution environment under `$.trx/*list*`. This list
can be modified by the user, allowing for powerful metaprogramming. Besides above-mentioned requests, this feature is used
to implement another series of useful utilities such as exception catching.

Altering and quering informations about the CVM context attached to an env.

Errors are CVX maps, either mappified CVM exceptions or built from scratch.

Using [[convex.run.exec/fail]], they are reported back to the CVX executing environment
and can be handled from CVX.

This namespace provides functions for building recurrent error maps.

All aspects of actually executing transactions.

When an error is detected, [[fail]] is called.

Basic IO utilities and STDIO.

Text streams are meant for reading characters (`Reader` and `Writer`) while binary streams are meant to handle
raw bytes (`InputStream` and `OutputStream`).

CVX keywords used by the runner.

Implementation of requests interpreted by the runner between transactions.

A reqest is merely a CVX vector following some particular convention that the
runner follows for producing effects beyond the scope of the CVM.

Handling files and STDIO streams.

A stream is an id that represents an opened file or a STDIO streams. Those ids are kept in env.

All operations, such as closing a stream or reading one, rely on [[operation]].

Used for implementing IO requests.

CVX symbols used by the runner.

Writing, encoding CVX cells various kind of sources.

Binary is big-endian and text is UTF-8.

Also see [[convex.read]] for the opposite idea.