D has transitive inference of purity (either weak or strong) on templated functions. This is useful in, for instance, safe parallelization.
Does Rust have something similar?
Specifically, Rust functions that read/write shared/global variables inside unsafe blocks cannot be safely parallelized. Is it up to the developer of such functions to not do such mistakes?
As a comparison, in the D case, such functions will be inferred as (memory) @safe but non-pure. IMHO, that is a more precise way of categorizing the behaviour of such a function.
I don't think you're following me here; unsafe blocks in Rust can "trick" the compiler into assuming that a function only access state via it's arguments when it, in fact, also read/write global/shared state. I guess @leonardo's comment references this problem.
Even without unsafe, a function could also access thread local variables or statics with interior mutability. This is perfectly memory safe for parallelization, but could still have logic errors around atomicity, and certainly isn't pure.
Rayon doesn't solve that, but it's not really a data race, at least as far as memory safety is concerned. You can still have logic errors around read-modify-write, or deadlock mutexes, etc. There's a large discussion in the readme, "Warning: Be wary of atomicity".