Distinguish constant references

[ByteEater-pl]

I propose that there be an easy way to test if a given Reference instance is constant or mutable. Perhaps a boolean property, a static method or a subclass.

[hax]

Not sure what constant/mutable mean, I guess you mean:

const o = {x: 1}
const ref x = o.x
x.value // 1
x.mutable // true
++x.value
o.x // 2

Object.defineProperty(o, 'x', {writable: false})
x.mutable // false?
++x.value // throw!

[ByteEater-pl]

No, I mean:

let x = 1
const ref y = ref x
function update(ref r) { r++ }
update(ref x)
update(ref y) // throws

The function update has no ability without involving throwing to tell if it's been passed a mutable or constant reference.

[rbuckton]

I suppose we could add a writable property to the Reference instance, or a static Reference.isWritable(x) method, but I doubt it would infer more than whether the reference itself was mutable/immutable, not the reference location in the case of an element access.

In general though, it might be better to also force this to be declarative, preventing a let ref from ever being taken from a const ref:

let a = 1;
let ref a_mut = ref a;
const ref a_immut = ref a;

// going from immutable to mutable is an error
let ref a_mut2 = a_immut; // Error, cannot assign a const ref to a mutable ref

// going from mutable to immutable is ok
const ref a_immut2 = a_mut; // ok

function acceptsMutable(ref x) { }
acceptsMutable(a_mut); // ok
acceptsMutable(a_immut); // Error, cannot assign a const ref to a mutable ref

function acceptsImmutable(const ref x) {}
acceptsImmutable(a_mut); // ok
acceptsImmutable(a_immut); // ok

const b = 1;
let ref b_mut = ref b; // Error, cannot assign a const ref to a mutable ref
const ref b_immut = ref b; // ok

The only time you would need to know whether the ref is immutable is if you are working with a Reference object itself. Its also possible that we could define a Reference instance that is immutable as one that does not have a setter:

let a = 1;
const ref a_immut = ref a; // capture mutable reference but assign it to immutable reference
const b = ref a_immut; // get `Reference` value of immutable reference
Object.getOwnPropertyDescriptor(b, "value").set === undefined; // true

[rbuckton]

Plus I'm beginning to think I need a const ref expression in addition to a ref expression, or a ref x const (putting the const at the end so as not to collide with a const declaration).