Access

Visibility access constraint is one of the most basic forms of constraints: if you do not (and can not) know something exists, you can not use it. Almost all programming languages support this type of constraint, but most only know two stages: public or private.

public

Everybody

restricted

A limited group

private

Only the thing itself

The exact meaning of access depends on the context where it is used, usually private indicates the file, restricted indicates the module, and public well.... The default value is private.

You can not force access. Period. It is the most basic form of protection.

alterable

Most user variables will be alterable. This is the normal state of a variable.

constant

If it is constant, it can not be written, nor is it expected to change. Code variables (aka functions) are allways constant. Note that some user const structures may have ! alterable parts: this means that that part is mutable, see below (TODO) for an explanation.

volatile

The value volatile indicates that this value can be changed by others than the current process/thread: no caching or reordering is allowed.

read_volatile

A read_volatile value is a volatile value that only can be read. Just like const, but it can change at will.

write_volatile

A write_volatile value is a volatile value that only can be written. Normally only used for hardware registers.

Declares additional restrictions to external variables used in the code block. This is equivalent to calling a function with, say, an alterable variable, whilst the function expects a constant.

It is allways allowed to limit access further:

• alterable variables may be limited to constant
• volatile variable may be limited to read or write

You do not need force if you just want to limit the access, and you can not force a constant variable to become alterable.

What use, then, is force on access?

You can force part of a constant type to be alterable during definition: so you can have an immutable type which can still cache expensive computations.