In Argentum, associative reference (also known as weak) is one of fundamental built-in types. Such reference is easily created, copied, passed, and stored. It is not a pointer, it is rather a Schrodinger box that may or may not have a pointer inside:
class MyClass {
i = 42;
field = &MyClass; // field; weak reference; "empty"
}
a = &MyClass; // local variable; weak; "empty"
realObject = MyClass; // temporary pointer to a freshly created instance of `MyClass`
a := &realObject; // now `a` holds a pointer to the `realObject`
realObject.field := a; // now the object's field points to itself (which is ok for weaks)The process of &-weak dereferencing includes:
- checking that &-weak actually has pointer to something,
- that its target still exists,
- and that it resides in the same thread.
The result of these checks is a temporary reference to the object, wrapped in an optional (?T) , which not only signals the availability of the object through this reference but also prevents its deletion.
The above-described dereferencing has no explicit syntax. It is performed automatically wherever &T is transformed into ?T. For example, in the "?" or ":"-operators:
// If `a` points to an object, print its field `i`
a ? log("This object exists and has i={_.i}");Here, the ?-operator expects to get ?T on the left, so the &weak variable a will be locked, and on success, it will be passed to the right operand as "_" variable of type MyClass where _.i extracts its field.
As a result:
- In Argentum, it is impossible to access lost weak references.
- This check has lightweight syntax.
- It generates a temporary value ("
_" or a name defined by the programmer through?`name), and this temporary name has a lifetime limited by the right operand of the ? operator.