[the__alchemist]

After pondering, my single favorite capability of rust is this:

  fn modify(val: &mut u8) {
      // ...
  }

No other language appears to have this seemingly trivial capability; their canonical alternatives are all, IMO, clumsier. In light of the article, is this due to Rust's memory model, or an unrelated language insight?

[constantcrying]

How is a mutable reference as an argument to a function in any way unique? C++ has mutable references as arguments to functions.

[pornel]

Because it's not merely mutable, it's exclusive. You get a static guarantee that, for as long as you can use this reference, this is the only reference in the entire program that can mutate this memory.

This is automatically thread-safe, without any locks. It's guaranteed that there can't be any side effects that could affect this memory, no matter what code you call. You don't need any defensive coding copying the memory just in case. It optimizes well, because it's certain that it won't overlap with any other region.

C++ doesn't have that kind of strong no-alias guarantee. Even memory behind const pointers can be mutated by something else at distance. The closest equivalent is C's restrict pointers, but they're more coarse-grained, and aren't checked by the compiler.

[the__alchemist]

You're right; you can do this in C++, although the patterns I've seen usually involve pointers.

There is no equivalent in Python, Javascript, Typescript, Java, or Kotlin.

[constantcrying]

>I've seen usually involve pointers.

If only C++ had a thing called "references", which conveniently also used the "&" symbol and are a way to do exactly this without pointers.

https://en.cppreference.com/w/cpp/language/reference

[the__alchemist]

I stand corrected on C++. Can you think of any other languages? Of the ones I listed, I use all of, and am continuously frustrated by this limitation.

[diath]

Most low-level languages support this, references in C++, pointers in C, ref keyword in C# and Dlang, and so on. It's mostly higher-level languages that do not support such things because it's in the VM semantics that dictate how objects are passed (i.e. in Lua tables are passed by reference, non-table values are passed by copy).

[the__alchemist]

Great point. I, was mistaken; the languages I've used are of the higher-level variety that don't have this feature (And C, which doesn't really have this feature; I don't think that pointers are nearly as nice).

[constantcrying]

>Can you think of any other languages?

Yes. E.g. every language where you can pass pointers can do this. Reference are a construct around pointers.

>Of the ones I listed, I use all of, and am continuously frustrated by this limitation.

Why? This is only a limitation for a few basic types. All the language you mention allow you to modify objects passed to a function.

If it ever were any issue though you can always return the modified object and overwrite the original.

a = modify(a)

works even if you can only pass a value.

In practice this should never be a limitation, certainly I have never encountered it as one.

[the__alchemist]

I challenge you to write the function signature I posted in Python, Javascript, or Kotlin; I'm confident you will not be able to, and the alternatives will be more provincial and unergonomic.

Hint: Python and Javascript will use the type passed to determine mutability. Kotlin will let you pass a mutableStateFlow etc that can be used for, e.g., top-level data structure, but not an arbitrary variable. (e.g. a data structure field, or free variable).

The most popular languages, outside of C and C++, cannot pass pointers. And, raw pointers are not ideal; they lose type safety, memory safety etc.

There are always canonical patterns for a given language to write a function like I did. I find them to be universally more complicated and less explicit/versatile than what I posted; they require code to permeate beyond the function signature.

[the__alchemist]

You're correct re the class wrapper (HN nesting limit). Can you see why that solution is complicated, and not versatile? (hint: This limitation will cause ripples of complication throughout your data structures)

[renox]

Ada has inout parameters.