The most idiomatic way would be to just use an existing crate, in this case shellexpand (github, crates.io) seems to do what you want: extern crate shellexpand; // 1.0.0 #[test] fn test_shellexpand() { let home = std::env::var(“HOME”).unwrap(); assert_eq!(shellexpand::tilde(“~/foo”), format!(“{}/foo”, home)); } Alternatively, you could try it with dirs (crates.io). Here is a sketch: extern crate … Read more
You could put the functions you do not want to format in a module, tag the entire module with a #[rustfmt::skip], then pull in the items to the parent module with use. #[rustfmt::skip] mod unformatted { pub fn add(a : i32, b : i32) -> i32 { a + b } pub fn sub(a : … Read more
Consider you have a module my_mod with a pub function my_func. You can’t use this function in your crate (or outside your crate) until you include your module using mod my_mod statement. After you include your module, you can use your function like that: mod my_mod; … my_mod::my_func(…) … You can’t use my_mod::my_func statement if … Read more
No, there is not. A closure is a method (a kind of function) under the hood. You are asking for the ability to exit a parent function from an arbitrarily deeply nested function call. Such non-local flow control has generally proven to be extremely bad for programmer sanity and program maintenance. To solve your problem: … Read more
Is it possible in Rust to delete an object before the end of scope? Yes. Is it possible to call the destructor of an object explicitly in Rust? No. To clarify, you can use std::mem::drop to transfer ownership of a variable, which causes it to go out of scope: struct Noisy; impl Drop for Noisy … Read more
Therefore my question is: Is naming arguments in function call is possible in Rust Rust does not support named parameters as part of the language. is it considered to be a good practice according to Rust best practices? (I’m a beginner) Generally not (the rather strong typing usually helps mitigate this issue) In cases where … Read more
They are somewhat redundant with each other. However, as you say, Drain just borrows the vector, in particular, it has a lifetime connected with the vector. If one is wishing to return an iterator, or otherwise munge iterators in the most flexible way possible, using into_iter is better, since it’s not chained to the owner … Read more
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.
Another option is to add the #[ignore] attribute. #[ignore] #[test] fn test_1() { let a = 1; let b = 2; println!(“{},{}”, a, b); assert_ne!(a, b); } This adds a nice colored ignored to the test results. test tests::test_1 … ignored test tests::test_2 … ok test result: ok. 1 passed; 0 failed; 1 ignored; 0 … Read more