To measure period jitter, this provides the period.

If the period is given it becomes possible to detect drift,
i.e, the actual times are measured relative to the expected
times for given `period`. A cumulative drift, i.e., an actual
period that is slightly longer or shorter in average, will add
up to a significant jitter.

Note that periods like `1/60` cannot be traced accurately, the
rounding error in 16666666ns (or 16666667ns) will add up over
time!

if period is `nil`, this will measure cycle jitter.

See JEDEC Standard No. 65B for definition of period and cycle
jitter.

the maximum duration that will be recorded in this histogram

if specified, the histogram will use a linear time scale from
0 up to max_recorded

if `nil`, the histogram will use a generic logarithmic time scale
from 1ns up to about 1day.

number of initial recordings that should be ignored (i.e.,
that are considered to be part of a _warm up_ phase).

number of final recordings that should be ignored. This permits
errors introduces by starting of the shutdown process to be
ignored.

record the given duration

if `ignore_first` or `ignore_last` are non-zero, this will ignore the
first or last records accordingly

record the given time instant, i.e., create the difference to the previous instant
and record that

Create a string with a graphical representation of this histogram.

Determine the average value in this histogram or 0 in case there are
no recorded values.

number of measurements in this histogram.

Create semicolon-separated CSV data for these measurments to import into Excel or
OpenOffice. First lines will be descriptions.

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:


NYI: IMPROVEMENT: #5892: If this is fixed, we could write

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.

Find the highest count recorded for this histogram, or 0 if no times were recorded.

Determine the maximum value in this histogram.

Determine the minimum value in this histogram.

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.

Determine the standard deviation from the average of the
difference of the values in this histogram to a given value m.

Determine the standard deviation of the difference of the recorded values
in this histogram to a given value m, result is 0 in case there are no
recorded values.

result is `time.duration.zero` if no measurements were made yet

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.

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

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

Construct a new empty histogram for jitter

create an empty histogram

Construct a new empty histogram for jitter on a known period using

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

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