This is going to take some serious reading.

I've been struggling with a related problem over at [1]. Feel free to read this, but it's nowhere near finished. I'm trying to figure out how to do back references cleanly and safely. The basic approach I'm taking is

- We can do just about everything useful with Rc, Weak, RefCell, borrow(), borrow_mut(), upgrade, and downgrade. But it's really wordy and there's a lot of run time overhead. Can we fix the ergonomics, for at least the single-owner case? Probably. The general idea is to be able to write a field access to a weak link as

    sometype.name

when what's happening under the hood is

    sometype.upgrade().unwrap().borrow().name

- After fixing the ergonomics, can we fix the performance by hoisting some of the checking? Probably. It's possible to check at the drop of sometype whether anybody is using it, strongly or weakly. That allows removing some of the per-reference checking. With compiler support, we can do even more.

What I've discovered so far is that the way to write about this is to come up with real-word use cases, then work on the machinery. Otherwise you get lost in type theory. The "Why" has to precede the "How" to get buy-in.

I notice this paper is (2024). Any progress?

[1] https://github.com/John-Nagle/technotes/blob/main/docs/rust/...

▲ zozbot234 12 minutes ago | parent | next [-]

> The general idea is to be able to write a field access to a weak link as

  sometype.name

> when what's happening under the hood is

  sometype.upgrade().unwrap().borrow().name

You could easily implement this with no language-level changes as an auto-fixable compiler diagnostic. The compiler would error out when it sees the type-mismatched .name, but it would give you an easy way of changing it to its proper form. You just avoid making the .name form permanent syntactic sugar (which is way too opaque for a low-level language like Rust), it gets replaced in development.

▲ kurante 4 hours ago | parent | prev | next [-]

Have you seen GhostCell[1]? Seems like this could be a solution to your problem.

[1]: https://plv.mpi-sws.org/rustbelt/ghostcell/

	▲	zozbot234 19 minutes ago \| parent \| next [-]
		The qcell crate is perhaps the most popular implementation of GhostCell-like patterns. But the ergonomics is a bit of a challenge still.
	▲	Animats 4 hours ago \| parent \| prev [-]
		Yes. There's an implementation at https://github.com/matthieu-m/ghost-cell Not clear why it never caught on. There have been many attempts to solve the Rust back reference problem, but nothing has become popular.

▲ mustache_kimono 4 hours ago | parent | prev [-]

> But it's really wordy and there's a lot of run time overhead.

I'm curious: what do the benchmarks say about this?