// in None case // │ in Some(_) case // ┌┴─┐ ┌───────────────────┐ if foo.map_or(true, |foo_val| foo_val < 5) { // … } For more information see Option::map_or.
If you read the documentation for Result::unwrap, you’ll note that it’s under a little section called: impl<T, E> Result<T, E> where E: Debug This means the methods in that section only exist so long as the given constraints are satisfied. The only reason unwrap wouldn’t exist is that Error doesn’t implement Debug.
Yes, crates that depend on your library will ignore your Cargo.lock. The Cargo FAQ provides more details: Why do binaries have Cargo.lock in version control, but not libraries? The purpose of a Cargo.lock is to describe the state of the world at the time of a successful build. It is then used to provide deterministic … Read more
as casts are fundamentally different from From conversions. From conversions are “simple and safe” whereas as casts are purely “safe”. When considering numeric types, From conversions exist only when the output is guaranteed to be the same, i.e. there is no loss of information (no truncation or flooring or loss of precision). as casts, however, … Read more
Yes, the ? operator is equivalent to try!(). ? is now in stable Rust 1.13, released on November 10, 2016. The best source of documentation at the moment seems to be RFC 0243. Note that the catch described in the RFC is not yet implemented at this writing (issue).
From the home crate. The definition of home_dir provided by the standard library is incorrect because it relies on the $HOME environment variable which has basically no meaning in Windows. This causes surprising situations where a Rust program will behave differently depending on whether it is run under a Unix emulation environment. Neither Cargo nor … Read more
Although the accepted answer is correct, it doesn’t cover the non-trivial case. To stream output and handle it manually, use Stdio::piped() and manually handle the .stdout property on the child returned from calling spawn, like this: use std::process::{Command, Stdio}; use std::path::Path; use std::io::{BufReader, BufRead}; pub fn exec_stream<P: AsRef<Path>>(binary: P, args: Vec<&’static str>) { let mut … Read more
It seems what you need is “slice patterns”: fn main() { let line = “127.0.0.1 1000 what!?”; let v = line.split_whitespace().take(3).collect::<Vec<&str>>(); if let [ip, port, msg] = &v[..] { println!(“{}:{} says ‘{}'”, ip, port, msg); } } Playground link Note the if let instead of plain let. Slice patterns are refutable, so we need to … Read more
You need to explicitly opt-in by placing #![feature(collections)] at the top of your crate’s root source file. Using a nightly compiler merely permits you to use unstable features, it doesn’t automatically enable them. See also this related SO question.
Since Rust 1.6, Read::read_exact can be used to do this. If bytes_to_read is the number of bytes you need to read, possibly determined at runtime, and reader is the stream to read from: let mut buf = vec![0u8; bytes_to_read]; reader.read_exact(&mut buf)?; The part that wasn’t clear to me from the read_exact documentation was that the … Read more