always excited to read these release notes, if only to be reminded there are teams who really care about software quality still putting stuff out. great work!

score 1 · canonical

If someone has a reference into some data that is currently being shared to another thread via structured concurrency, they won’t be able to mutate it during the structured concurrency.

This is what I’m saying: that sounds eerily similar to shared-xor-mutable :P

It seems like one plan would be to:

1. Define closure types that have/don’t have mut effects inside them
2. Define structured concurrency to always take closures that don’t have mut effects inside them
3. Define mutexes which can apply closures with mut effects without also being a mut effect externally.

is that about right?

score 1 · canonical

Last time I read https://verdagon.dev/blog/group-borrowing I was convinced that this approach works for simple structs + arrays where all fields are public, but would quickly become unwieldy for anything requiring “path abstraction” like a binary tree or linked list. Wildcard paths solve this complaint, neat! (I did not read the golden spike articles)

Still a little nervous about “value invalidation” TOCTTOU for how this system deals with concurrency, seems shared-xor-mutable has a leg up there, but this is looking pretty nice for the single-threaded case.

score 1 · canonical

cool article! i’ve worked with a bit of both Rust & OCaml and can understand where they’re coming from. i have some gripes with it tho, especially with how it assumes Rust’s typeclasses to be the standard for what’s possible

inline interfaces aren’t a thing

no reason they couldn’t be! assuming it’s just namespacing and not any further meaning.

impl blocks aren’t composable

again, no big technical reason preventing this from being a thing, just aesthetic ones:

impl<T: Eq> {
  fn are_they_eq(a: T, b: T) -> bool { a == b }
}

compile times…

the way modules are done in OCaml and Go basically mandate vtables, which is mostly fine for normal programs, but unacceptable when you want to eke every last bit of performance out at runtime, even if that means longer compile times. ad-hoc polymorphism makes monomorphization easier, and i like it better for that.

Each function stands alone and you have to reason at the function level.

what? no, typeclasses can specify relations between their functions just the same. providing mempty & mappend that typecheck isn’t enough to actually conform Monoid, you need to obey the laws too.

overall pretty good, explains the concepts well, even if it’s biases against my own biases :P

score 2 · canonical