4 ms·
I found a few things a little difficult. First, the compiler is not actually as smart / accepting of valid borrow patterns as should abstractly be possible. Thi
by loeg 4y ago
I found a few things a little difficult. First, the compiler is not actually as smart / accepting of valid borrow patterns as should abstractly be possible. Things like borrowing different subfields of a struct in different and nonconflicting ways to different subroutines. This got a lot better in recent memory with non-lexical lifetimes but I think is still a problem.
Two: splitting mut borrows. It’s reasonable to take a mut borrow of some resource and divide it into two independent borrows of exclusive components. Think non-overlapping subarrays, or independent struct members. The language does not really provide this for you, but it is safe. (There are some APIs like this but last time I checked they didn’t cover all usecases.)
Structs containing a borrow are just weird and annoying to work with. Lifetime parameterization everywhere is verbose and it’s difficult to determine where you’ve made a mistake. The syntax for describing lifetime relationships is non-obvious to me.
- estebank 4y ago> There are some APIs like this but last time I checked they didn’t cover all usecases. This refers to[1] <&mut [T]>::split_at_mut(usize) -> (&mut [T], &mut [T])` used as let (first_42, rest) = mutable_slice.split_at_mut(42); but you can see that the inner logic is just a bit of pointer twiddling[2] let len = self.len(); let ptr = self.as_ptr(); // SAFETY: Caller has to check that `0 <= mid <= self.len()` unsafe { (from_raw_parts(ptr, mid), from_raw_parts(ptr.add(mid), len - mid)) } [1]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at_mut https://doc.rust-lang.org/std/primitive.slice.html#method.sp... [2]: https://doc.rust-lang.org/src/core/slice/mod.rs.html#1641-1645 https://doc.rust-lang.org/src/core/slice/mod.rs.html#1641-16...
- loeg 4y agoYes, exactly. I was using this for zero-copy serialization into a buffer. At the time, I don’t believe that API had been stabilized yet.
- bobbylarrybobby 4y agoFor someone looking for an example of this, here's a SO post: https://stackoverflow.com/questions/74592882/extend-a-string-with-another-string-within-the-same-vector-rust https://stackoverflow.com/questions/74592882/extend-a-string... Tl;dr Rust can't distinguish between a `Vec` whose length is mutable (which might need to reallocate) and one whose elements are mutable (which can provide mutable references to its elements but will never have to move them), so it prevents mutation in a case where it would be safe.
- zozbot234 4y agoIsn't the latter just a mutable slice?