create a mutable array.

create a mutable array with two dimensions.

create a mutable array with three dimensions.

common type for mutable data

create a var mutable value with the given initial value and update the
'mutate' effect in the current environment

does this effect support abort?

Helps detecting unexpected calls to
`abort` at runtime and ensure that the static analysis finds that the
code executed with this effect will always return normally and produce
a result. This is used, e.g, in `mutate` to avoid static analysis
reporting `panic` as an effect of the use of a local mutate instance.

fluent interface for using multiple effects together

this effect reinterpreted as a Functional
which allows composition of effects

create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`

Does the current system permit atomic accesses to values of type T?

This is typically true for ref values and for small primitive types
such as `i32`, `f64`, etc. while this is typically not the case for
more complex types such as `point(x,y i64)`.

For mutable fields created by heirs of `concur.atomic_mutate`, it will
not be possible to use `get_racy` or `put_racy` unless they are
performed on a type where these accesses are atomic.

dynamic_apply -- apply `f.call` to `Any.this`'s dynamic type and value

This can be used to perform operation on values depending on their dynamic
type.

Here is an example that takes a `Sequence Any` that may contain boxed values
of types `i32` and `f64`. We can now write a feature `get_f64` that extracts
these values converted to `f64` and build a function `sum` that sums them up
as follows:

Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.

There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.

perform given code with exclusive access to the mutable values created with
this instance of `mutate`.

is instance `mutate.this` instated for type `mutate.this` and, if `mutate.this` does
not support use in several threads, check we are running in the thread `mutate.this`
was created in.

This is used a pre-condition for `exclusive` and `exclusive_when`.

Note that this is redefined in `blocking_mutate_using_clock` since it does not
require exclusivity there, but it is sufficient if that is instated.

exclusively wait for the given condition to hold and then perform given code with
exclusive access to the mutable values created with this instance of `mutate`.

feature that will be called on the final instance of this effect
after it has been de-instated.

This happens either on a normal return form the code passed to
`instate`, on an abort performed on this effect or on an abort
performed on an effect instated prior to this effect's instation.

This can be used to perform actions when leaving an effect such
a cleanup up resources that were created or opened by operations
of this effect.

infix variant instate_self

use it like this:

convenience version of `instate` for effect values whose type is
exactly the effect type (i.e., the value type does not inherit
from the effect type).

Execute 'code' in a context where this effect instance has been
instated for effect type `effect.this`.

In case `f` returns normally, this will return `f`'s result.

In case `f` aborts this effect, this will panic.

check if the current mutate is a child of 'conur.atomic_mutate'

check if the current thread is permitted to access mutable state managed by mutate.this
exclusively.

For a single-thread mutate, this is usually the case for the same thread this mutate was
created in. Furthermore, multi-thread mutate implementations may ensure exclusive
access to other threads via redefining the `exclusive` features.

convenience feature for creating a new array,
in some cases even with type inference

convenience feature for creating a new array2,
in some cases even with type inference

convenience feature for creating a new array3,
in some cases even with type inference

convenience prefix operator to create a string from a value.

This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.

Perform a read fence, i.e., enforce ordering between the previous and the next
read operations: make sure that no previous read will be swapped with the any
following read operation.

When no other synchronization mechanism is used, this is required between reads
of fields that are accessed by concurrent threads to ensure that the order seen
by the reading thread corresponds to the syntactical order the reads are
performed in.

replace existing effect of type `effect.this` by the new effect value `effect.this`.

This is a convenience feature for value type effects for which the type of
the effect instance equals the effect type. `ref` type effects typically have
values that may be children of the effect type that are of a different type, so
`effect_type.replace new_value` must be used.

replace may only be called during the execution of an operation of a currently instated
effect of the same effect type.

wait for the given condition to become true by a mutation of the underlying data.

In case this mutate is not a multi-thread implementation and `condition()` is `false`,
this will `panic`.

Perform a write fence, i.e., enforce ordering between the previous and the next
write operations: make sure that no previous write will be swapped with the any
following write operation.

When no other synchronization mechanism is used, this is required between writes
of fields that are accessed by concurrent threads to ensure that the order seen
by the reading thread corresponds to the syntactical order the writes were
performed in.

Abort code execution for the instated effect.this.env and return to the point
where the effect was instated.

replace existing effect for type `effect.this` by the new effect value `e`
and abort code execution to return to the point where the effect was instated.

string representation of this type to be used for debugging.

result has the form "<name>", but this might change in the future

If this effect may be instated automatically at application start (during the
effect big bang singularity), this should be redefined to return the
corresponding effect value

There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.

Note: Typechecking is undecidable when 'type' is a type, Mark B. Reinhold, 1989
see: https://dspace.mit.edu/bitstream/handle/1721.1/149366/MIT-LCS-TR-458.pdf?sequence=6

get this effect from env

has an effect of the given type been instated?

Is this type assignable to a type parameter with constraint `T`?

The result of this is a compile-time constant that can be used to specialize
code for a particular type.


it is most useful in conjunction with preconditions or `if` statements as in


or

execute 'code' in a context where the effect instance `e` has been
installed for effect type `effect.this`.

In case `f` returns normally, this will return `f`'s result.

In case `f` aborts this effect, this will panic.

execute 'code' in a context where the effect instance `e` has been
installed for effect type `effect.this`.

In case `f` returns normally, this will return `f`'s result.

In case `f` aborts this effect, return `def()`.

has an effect of this type been instated?

name of this type, including type parameters, e.g. 'option (list i32)'.

convenience prefix operator to create a string from a value.

This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.

NYI: Redefinition allows the type feature to be distinguished from its normal counterpart, see #3913

replace existing effect for type `effect.this` by the new effect value `e`.

For effects that model the outside world (e.g., i/o, time, sensors and actuators, etc.),
the effect might be a unit type, so the replace is effectively a no-operation. However,
the call to `replace` is used to model the change of the outside world and must be
included for analysis tools to appreciate this.

replace may only be called during the execution of an operation of a currently instated
effect of the same effect type.

NYI: BUG: It is currently not enforced that replace is only called during the execution
of an operation of a currently instated effect of the same effect type.

Get a type as a value.

This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.

`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.