There’s a swap method on slices: data.swap(i, j). The original code doesn’t work because the language requires that &muts do not alias, that is, if a piece of data is accessible via an &mut, then there must be no other way to use that data. In general, for successive indexes data[i], data[j], the compiler cannot … Read more
It’s a negative trait implementation for the Send trait as described in RFC 19. As a summary: The Send trait is an auto trait, which means it is automatically implemented for all types that only contain other Send types: unsafe auto trait Send {} (Send is also an unsafe trait, which means it is unsafe … Read more
Erlang uses green threads with preemption. This is possible only because Erlang has a VM, which also allows a lot of other things like code hotswap. But languages with VM are unsuitable for systems programming because they always have some constant overhead, both in memory and processing power. Rust is a systems programming language, and … Read more
Function item vs. function pointer When you refer to a function by its name, the type you get is not a function pointer (e.g. fn(u32) -> bool). Instead, you get an a zero-sized value of the function’s item type (e.g. fn(u32) -> bool {foo}). The value is zero-sized because it doesn’t store the actual function … Read more
Rust macros aren’t able to do that. Macros operate at the syntactic level, not at the semantic level. That means that although the compiler knows it has an expression (syntax), it doesn’t know what the type of the expression’s value (semantic) is at the moment the macro is expanded. A workaround would be to pass … Read more
from_str was renamed to parse and is now a method you can call on strings: use std::net::SocketAddr; fn main() { let server_details = “127.0.0.1:80”; let server: SocketAddr = server_details .parse() .expect(“Unable to parse socket address”); println!(“{:?}”, server); } If you’d like to be able to resolve DNS entries to IPv{4,6} addresses, you may want to … Read more
I found the answer: cargo doc –no-deps.
Cargo, the official package manager for Rust, defines some conventions regarding the layout of a Rust crate: . ├── Cargo.lock ├── Cargo.toml ├── benches │ └── large-input.rs ├── examples │ └── simple.rs ├── src │ ├── bin │ │ └── another_executable.rs │ ├── lib.rs │ └── main.rs └── tests └── some-integration-tests.rs Cargo.toml and Cargo.lock are … Read more
Let’s decompose it one-by-one. Box Box<T> is a pointer to heap-allocated T. We use it here because trait objects can only exist behind pointers. Trait objects In Box<Fn() + Send + ‘static>, Fn() + Send + ‘static is a trait object type. In future, it will be written Box<dyn (Fn() + Send + ‘static)> to … Read more
Rust does not have a garbage collector. Does Rust free up the memory of overwritten variables? Yes, otherwise it’d be a memory leak, which would be a pretty terrible design decision. The memory is freed when the variable is reassigned: struct Noisy; impl Drop for Noisy { fn drop(&mut self) { eprintln!(“Dropped”) } } fn … Read more