4 ms·
It can be hard to get a hold on so many features, I hear you. Some of this is Rust, some of this is your perspective vs. Rust's perspective. Here's what I have
by steveklabnik 8y ago
It can be hard to get a hold on so many features, I hear you. Some of this is Rust, some of this is your perspective vs. Rust's perspective. Here's what I have for you:
* Partial borrow.
The status of this is unclear. It does work in many cases. It's complicated. I would push back a little on the "no good reason" though, but this is gonna be long so I'll leave it at that.
* Rc/RefCell/Box
Yes, this is painful, but that's because shared ownership is painful. Rust is pushing you away from a certain kind of architecture. Many people think this is a good thing...
* No simple way to declare non-const global objects
That is lazy_static. But
> forces the code to be thread-safe even if no threading support is necessary (that is, I can't use my non-thread-safe classes in a lazy_static).
This is perceived as a good thing; if you code changes later to use threads, you're not hosed.
If you want something that's not for multi-threading, then don't use something that can be used with multiple threading! TLS is probably what you actually wanted here.
* In generic code, there is no simple way to represent integer types.
We went through three versions of these traits, and were not happy with any of them. It's a tough problem.
* No integer generic parameters
This is coming; the design work has been accepted, and now it's on to implementation. It's expected in nightly by the end of the year and probably stable early next year.
* PhantomData is awkward, it absolutely sounds like something the compiler should handle, not the programmer.
The compiler could try to infer variance, but that means that if your code changed, you'd have a breaking change. In general, around interface boundaries, Rust requires you to state what you want.
It's even less awkward than what came before it, for what it's worth.
* "Wrapping<u32> + 1" doesn't compile
Rust is pickier about numbers than many langauges; 1u32 + 1u8 doesn't compile either. Many people find this valuable; you don't have to memorize complex promotion rules, and you always get the semantic you asked for.
- dikaiosune 8y agoRe: non-thread-safe items in lazy_static, you can also wrap them in a mutex within just the lazy_static so the struct only uses synchronization when it actually needs to be thread-safe.
- deleted 8y ago[deleted]
- dbaupp 8y agoThat removes the Sync requirement, but still requires Send, so doesn't completely resolve the requirement for thread-safety (e.g. Rc can't be stored).
- estebank 8y ago>> "Wrapping<u32> + 1" doesn't compile > Rust is pickier about numbers than many langauges; 1u32 + 1u8 doesn't compile either. Many people find this valuable; you don't have to memorize complex promotion rules, and you always get the semantic you asked for. Although I'm happy with rust avoiding automatic promotion across the board, Wrapping<u32> + {integer}` could be handled more gracefully, in the same way that `u32 + {integer}` is handled.
- steveklabnik 8y agoYes; to be clear, what I'm saying here is "we tend to be conservative with these kinds of things at first". We could and may change this in the future, but once you do it, you can't go back. It's better to be conservative, feel where the pain leads you, and improve, then to speculate on things and end up adding bad stuff.
- giovannibajo1 8y ago> * Partial borrow. > The status of this is unclear. It does work in many cases. It's complicated. I would push back a little on the "no good reason" though, but this is gonna be long so I'll leave it at that. Not all partial borrows are safe, but a lot of them are. Most programmers know how to write safe code coming from different languages without borrow checker; they do put bugs sometimes -- that's true -- but most of the times the code I write is safe. It's just that there's no way to tell Rust that it is, and the workaround has a global impact on the code being affected (it forces to split structures, which greatly increases the cognitive load in reading and writing the code). > * Rc/RefCell/Box > Yes, this is painful, but that's because shared ownership is painful. But the point is that I do NOT want shared ownership. What I want is to have a single owner of a long-living object, and several long-living references to it in other objects. When I say "long-living", I mean that the liveness of those objects is not visible through the call stack, so I can't use borrowing references. The only way to model this today is with shared ownership, which implies more than I would be willing to imply. The same problem is apparent when trying to implement the callback pattern (which I forgot to list in my OP). Callbacks are basically impossible to do in Rust, and I found out I must have used callbacks everywhere in my last many years of programming in different languages, because I feel helpless in Rust when structuring code without being able to register and use callbacks. > This is perceived as a good thing; if you code changes later to use threads, you're not hosed. This does not sound very Rustecean :) If Rust is not opinionated and gives me full power with zero cost overhead, why does it force me to pay for thread-safeness (overhead) so that I can use threads later (opinion)? Notice also that code which is not thread-safe doesn't prevent me from using parallelism. It just prevents me from moving objects across threads. But I can surely leverage the power of multi-core with threads, as long as the thread-unsafe objects are created and used within a single thread. So I'm not sure why I should make them thread-safe... just because I want to use them in a non-const global. > If you want something that's not for multi-threading, then don't use something that can be used with multiple threading! TLS is probably what you actually wanted here. What I want is actually much simpler: let me initial globals with runtime code that the compiler schedules for me to run before main. C++ does that very well; Go does that optimally. Either approach is good enough. PS: TLS is potentially overhead again: indirect reference on non-PIE binaries. > Rust is pickier about numbers than many langauges; 1u32 + 1u8 doesn't compile either. I love that "1u32 + 1u8" doesn't compile, I hate integer promotion. What I'm saying is that "1u32 + {integer}" compiles, while "Wrapping<u32> + {integer}" doesn't. I think it's been a bad tradeoff to force people to use generics for wrapping integers when generics are still not good enough to implement a type which behaves like a native integer on common operations like "+ {integer}" or "as <type>".