Rust is een programmeertaal bedacht door Graydon Hoare en oorspronkelijk ontwikkeld door Mozilla. Het is deels geïnspireerd op de programmeertaal C, maar kent syntactische en semantische verschillen. Het focust op veiligheid en beoogt moderne computersystemen efficiënter te benutten. Het wordt ingezet door onder ander Cloudflare, OVH, Mozilla, Deliveroo, Coursera, AppSignal en Threema. Versie 1.38.0 is onlangs uitgebracht met de volgende aankondiging: What’s in 1.38.0 stable The highlight of this release is pipelined compilation. Pipelined compilation To compile a crate, the compiler doesn’t need the dependencies to be fully built. Instead, it just needs their “metadata” (i.e. the list of types, dependencies, exports…). This metadata is produced early in the compilation process. Starting with Rust 1.38.0, Cargo will take advantage of this by automatically starting to build dependent crates as soon as metadata is ready. While the change doesn’t have any effect on builds for a single crate, during testing we got reports of 10-20% compilation speed increases for optimized, clean builds of some crate graphs. Other ones did not improve much, and the speedup depends on the hardware running the build, so your mileage might vary. No code changes are needed to benefit from this. Linting some incorrect uses of mem::{uninitialized, zeroed} As previously announced, std::mem::uninitialized is essentially impossible to use safely. Instead, MaybeUninit should be used. We have not yet deprecated mem::uninitialized; this will be done in a future release. Starting in 1.38.0, however, rustc will provide a lint for a narrow class of incorrect initializations using mem::uninitialized or mem::zeroed. It is undefined behavior for some types, such as &T and Box, to ever contain an all-0 bit pattern, because they represent pointer-like objects that cannot be null. It is therefore an error to use mem::uninitialized or mem::zeroed to initialize one of these types, so the new lint will attempt to warn whenever one of those functions is used to initialize one of them, either directly or as a member of a larger struct. The check is recursive, so the following code will emit a warning: struct Wrap(T); struct Outer(Wrap); struct CannotBeZero { outer: Outer, foo: i32, bar: f32 } … let bad_value: CannotBeZero = unsafe { std::mem::uninitialized() }; Astute readers may note that Rust has more types that cannot be zero, notably NonNull and NonZero. For now, initialization of these structs with mem::uninitialized or mem::zeroed is not linted against. These checks do not cover all cases of unsound use of mem::uninitialized or mem::zeroed, they merely help identify code that is definitely wrong. All code should still be moved to use MaybeUninit instead. #[deprecated] macros The #[deprecated] attribute, first introduced in Rust 1.9.0, allows crate authors to notify their users an item of their crate is deprecated and will be removed in a future release. Rust 1.38.0 extends the attribute, allowing it to be applied to macros as well. std::any::type_name For debugging, it is sometimes useful to get the name of a type. For instance, in generic code, you may want to see, at run-time, what concrete types a function’s type parameters has been instantiated with. This can now be done using std::any::type_name: fn gen_value() -> T { println!(“Initializing an instance of {}”, std::any::type_name::()); Default::default() } fn main() { let _: i32 = gen_value(); let _: String = gen_value(); } This prints: Initializing an instance of i32 Initializing an instance of alloc::string::String Like all standard library functions intended only for debugging, the exact contents and format of the string are not guaranteed. The value returned is only a best-effort description of the type; multiple types may share the same type_name value, and the value may change in future compiler releases. Library changes
