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.

A limited group
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.


Most user variables will be alterable. This is the normal state of a variable.
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.
The value volatile indicates that this value can be changed by others than the current process/thread: no caching or reordering is allowed.
A read_volatile value is a volatile value that only can be read. Just like const, but it can change at will.
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:


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.