mutable_tree_map

returns a string representation of the map

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.

freeze the map, such that it is no longer mutable afterwards

get the value stored in this map at key k, nil if k is not
contained in this map

check if key k is present in the set of keys

get the value k is mapped to, or nil if none.

get a sequence of all key/value pairs in this map

get a sequence of all keys in this map

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.

add the mapping k -> v as a new entry to this map

returns the value that k previously mapped to, or nil if
k was not yet contained in this map

remove the mapping from k to some value from this map

returns the value that k previously mapped to, or nil if
no mapping was actually removed

returns the size of the map, i.e. the number of elements it contains

get a sequence of all values in this map

string representation of this type to be used for debugging.

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

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.

returns an empty tree of elements of type A.

initialize a map from an array of key value tuples

initialize a map from an array of key value tuples

if the freeze argument is true, then the map is frozen
after being populated with the entries from the array.

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.

is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false

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

pair(a,b T) is

=>

or

val(n T) is

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

returns a tree of elements of type A that contains just the element a.

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`.