The itertools crate has methods like tuples and next_tuple that can help with this. use itertools::Itertools; // 0.9.0 fn main() { let v = vec![1, 2, 3]; let (a, b) = v.iter().next_tuple().unwrap(); assert_eq!(a, &1); assert_eq!(b, &2); }
You can pass trailing arguments to cargo run using –: cargo run — –test From the man page: All of the trailing arguments are passed to the binary to run. If you’re passing arguments to both Cargo and the binary, the ones after — go to the binary, the ones before go to Cargo.
The type of each element of a tuple can be different, so you can’t iterate over them. Tuples are not even guaranteed to store their data in the same order as the type definition, so they wouldn’t be good candidates for efficient iteration, even if you were to implement Iterator for them yourself. However, an … Read more
You can either: Add an allow attribute on a struct, module, function, etc.: #[allow(dead_code)] struct SemanticDirection; Add an allow as a crate-level attribute; notice the !: #![allow(dead_code)] Pass it to rustc: rustc -A dead_code main.rs Pass it using cargo via the RUSTFLAGS environment variable: RUSTFLAGS=”$RUSTFLAGS -A dead_code” cargo build
If you look at the String documentation, there are a few methods you could use. There’s String::from_utf8 that takes a Vec<u8>, and there’s also String::from_utf8_lossy which takes a &[u8]. Note that a Vec<T> is more-or-less an owned, resizable wrapper around a [T]. That is, if you have a Vec<u8>, you can turn it into a … Read more
With the API you can use Builder::clang_arg with arbitrary arguments: let b = bindgen::builder().header(“foo.h”).clang_arg(“-I/path”); From the command line you can do the same by appending arguments after –, like: bindgen foo.h — -I/path
What do you want to happen if function() returns an Err result? You can’t use try!/? because it causes the containing function to return the same Err, but main() can’t return an Err (it returns (), not Result<…>). If you want to panic, you can use unwrap: function().unwrap(); If you want to ignore errors, discard … Read more
Just in case someone is looking for setting environment variable from source code, here is how you do it: use std::env; fn main() { // this method needs to be inside main() method env::set_var(“RUST_BACKTRACE”, “1”); } The benefit of this approach — in contrast to manually setting the env variable from PowerShell– is that you … 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