Ok, so here is something I always meant to create a pre-RFC, but never got around collecting references (such as the exact number of crates that implement this, and how they are used, and pain points in interop) and prior discussion. But
In this area, what I really want out of the stdlib is a type that represents a dense, row-major 2D matrix with dynamic size and contiguous elements - something as analogous to a 2D version of Vec as possible. Possible names include Vec2D and DMat.
This exact same type has a lot of usage in the Rust ecosystem (much more than a chiral variant like a column major matrix with the same characteristics - maybe because row major is C's default), and it's not just in linear algebra but whenever people want tabular data to be densely packed. So this type has been defined dozens of times. I once saw even an interoperability crate (that ~nobody uses so they are pointless n+1 standards), but I can't find i right now.
Fortunately, due to the very precise data layout requirements such a type has, usually you can cheaply convert between them (usually by passing around raw pointers and calling an unsafe API), Even if one type is row-major and the other colum-major, such conversion is also cheap (though it may be expensive to iterate in the non-preferred dimension). It's like if Vec didn't exist in the stdlib, the multiple implementations would normally be convertible to each other cheaply, because the heap-allocated buffer (the expensive thing to copy) would always be laid out the same in memory. So this issue is more like a papercut rather than a showstopper.
But it's exactly because it's a papercut that it got unaddressed for so long, and papercuts compounds over time.
And I don't think that Rust should wait so that custom DSTs are available. It would make borrowing such a type more ergonomic, but in absence of that there is already precedent in the Rust ecosystem to make Something and SomethingRef types. And if custom DSTs ever land, just make the ref type an alias, like the situation between Infallible and !.
I remember seeing a very old discussion about this, and it stalled because there's more than one way to describe 2D slices. I think that the conventions Rust Index trait naturally leads to a 2D slice with strides, similar to the imgref crate, and that's because in Rust it's usual to be able to index with ranges, and with a pair of ranges you can index a small rectangle inside the matrix (see the image in that crate's readme). That's not the absolutely most efficient a slice can be, but it's just one word for greatly added flexibility, exactly the cost of passing around Vec<T> with fixed size vs Box<[T]>.