Mutable Single-Field Access

[ghost]

Consider the following C snippet:

struct my_table *tab = make_table( /* ... */ );
mutate_field(&tab->field);

The procedure mutate_field takes a reference to a particular struct field to mutate. It cannot (within C best practices) touch the rest of the struct. This is basic encapsulation.

How would we do the same in Janet? The closest thing we have to references are mutable structure bindings, and they can only touch the whole table at once:

# Bad: passed value is immutable
(mutate-field (tab :field))

# Bad: function can mutate entire table
(mutate-field tab)

A vague Janesque solution I can think of is (ref {tab :field}) (name open to bikeshedding), which acts like standard field access/index except the original field reflects mutations in the yielded value:

(defn mutate-field [@f]
  (set f 2))

(mutate-field (ref {tab :field}))

Though of course this quickly runs into edge cases. I'm curious to hear what others think.

[bakpakin]

An idiom that is used internally for "refs" as you describe them is a 1 element array. This is how global variables are implemented, and while technically there is a little overhead, Janet isn't that kind of language. Basically, exploit that some types in Janet are passed by value, and others by reference.

[ghost]

Interesting. That is also how OCaml implements refcells.

I wasn't thinking about efficiency, but rather about effective encapsulation. Upon reflection though, the only case I can imagine where the mutating function would need direct access to the field is that of a table shared across multiple threads, in which case Janet itself would run into problems with scale before a single per-table mutex would.