Fuzion Logo
fuzion-lang.dev — The Fuzion Language Portal
JavaScript seems to be disabled. Functionality is limited.

memoize

memoize

memoize the results of a function.

example:

say you have a function `fib` that performs poorly because it lacks
memoization:


you can now memoize this as follows


there are two things required: first, the function has to inherit from
`memoize`. Second, the body has to be wrapped into a call to `keep`
with the key and a lambda to calculate the corresponding result, which
would usually just wrap the original code.

Apart from the speedup, the memoization shows up when you analyse the
effects:


It might be desired not to keep memoized results forever. To do so, we have
to instate a local instance of the `memoize.memoized` effect. This can be
done as follows:


Since memoization is used locally only, the effect does not show up when
effects are analysed.


NOTE: Currently, memoization requires keys to be orderable. Would be great
to support hashable as well

NOTE: Memoization is currently not thread safe. In case we want memoization
to be used among threads, we will need a thread safe variant. However,
this should currently be usable in multiple threads as long as each
thread has its own instance of memoized. We just do not profit from
values memoized in another thread.

Constructors

(K 
type
:
Type, V 
type
:
Type)
:
effect
 is
effect wrapped around map of memoized keys and corresponding values

Functions

 => 
String
[Inherited from  Any]
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
 => 
Type
[Inherited from  Any]
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.
(K 
type
:
Type, V 
type
:
Type, k K, f Unary V K)
 => 
V
use global memoized effect to retrieve the value for a given key or,
if that value was not calculated yet, to return it
 => 
String
[Inherited from  Any]
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.

Type Functions

 => 
String
[Inherited from  Type]
string representation of this type to be used for debugging.

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

redefines:

 => 
Type
[Inherited from  Type]
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.

redefines:

(T 
type
:
Type)
 => 
bool
[Inherited from  Type]
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

 => 
String
[Inherited from  Type]
name of this type, including type parameters, e.g. 'option (list i32)'.
 => 
String
[Inherited from  Type]
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

redefines:

 => 
Type
[Inherited from  Any]
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`.
0.095dev (2025-08-15 12:02:22 GIT hash 301b5b75e77076d091b38f555473f9f0e31e5b5c built by fridi@fzen)