Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
#9180 fix some IDE functionality inside attribute macros.
#9239 fix coercion in match with expected type.
#9182 don’t complete derive macros as function-like macros.
#9187 fix edge case in import granularity guessing.
#9186 prefer attr macros in "Expand macro recursively".
#9191 don’t descend into MacroCall TokenTree delimiters...
...sources.wait(&mut events)?;
for (key, event) in events.iter() {
match key {
Source::Listener => loop {
// Accept as many connections as we can.
let (conn, addr) = match listener.accept() {
Ok((conn, addr)) => (conn, addr),
Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
Err(e) => return Err(e),
};
// Register the new...
...Since we already allow recursion
via const fn and termination of said recursion via `if` or `match`, all code
enabled by const recursion is already legal now. Some algorithms are better
expressed as imperative loops and a lot of Rust code uses loops instead of
recursion. Allowing loops in constants...
...Tera = {
10 let mut tera = match Tera::new("templates/**/*.html") {
11 Ok(t) => t,
12 Err(e) => {
13 println!("Parsing error(s): {}", e);
14 ::std::process::exit(1);
15 }
16 };
17 tera.autoescape_on(vec![".html", ".sql"]);
18 tera
19 };
20}
21
22pub fn start_blog(listener: TcpListener) -> Result<Server...
...In the following example, surrounding the matcher with $(...),+ will match one or more expression, separated by commas. Also note that the semicolon is optional on the last case.
// `find_min!` will calculate the minimum of any number of arguments.
macro_rules! find_min {
// Base case:
($x:expr) => ($x);
// `$x` followed...
...It's just a big old match statement.
We check the byte that's passed in and we return the appropriate value.
pub fn parse_system_realtime(status_byte: u8) -> SystemRealtime {
match status_byte {
0xf8 => SystemRealtime::Clock,
0xf9 => SystemRealtime::Tick,
0xfa => SystemRealtime::Start,
0xfb => SystemRealtime::Continue,
0xfc => SystemRealtime::Stop,
0xfe...
...the code used is_some() followed by unwrap(), instead of pattern matching, to extract the option’s inner value. Maybe the code was written before pattern matching was even introduced to the language, and I was the first one to notice it could be improved (language changes were routine in...
...Serialize>(t: &T) {
let serialized = serde_json::to_string(t).unwrap();
println!("{}", serialized);
}
pub async fn new(db_url: &str) -> Result<Box<dyn DatabaseDriver>> {
if db_url.starts_with("libsql") {
let token = match config::database_token() {
Ok(t) => t,
Err(err) => bail!("{}", err),
};
let client = match libsql::LibSQLDriver::new(db...
...UnevaluatedConst before trait solving.
#14890 use ::core instead of $crate in option_env! expansion.
#14893 fix need-mut false positive in closure capture of match scrutinee.
#14874 change how #![cfg(FALSE)] behaves on crate root.
#14895 don’t try to determine type of token inside macro calls.
#14904 render size...
...left braces.
#16822 improve resolution for inlay hints targeting the same position.
#16871, #16886 skip problematic cyclic dev-dependencies.
#16885 improve parser recovery for match arms.
#16812 fix "Go to implementation" for impls inside blocks.
#16909 keep the Attr::Literal spans.
#16911 fix hang on projects depending on rustc_private.
...because if has a return value, the type of the return value from both branches has to match. By not writing an else branch, we've declared the return value from the non-existent else branch to be (), which doesn't match with the return type of the if branch...
...If you publish a
crate with a `cfg(windows)` dependency then crates.io could expand this to
all known triples which match `cfg(windows)` when storing the metadata
internally. This would mean that crates using `cfg` syntax would continue to
be compatible with older versions of Cargo so long as...
...These 200 bytes have to be passed around, and also accessed every time we do a matches!(expr, Expression::Variant(_)) check, which is not very cache friendly for performance.So to make memory access efficient, it is best to box the enum variants.The perf-book describes additional info on...
...A difference is made between the DAG nodes that do exist in the SentencePiece model (marked as leaves) and the nodes that do not have a matching. Every token is pushed by being added to the children of the token containing all characters except the last one:
Get the characters...
...Record = result?;
let replacement = args.replacement.clone();
match &*args.column_name {
"name" => record.name = replacement,
"surname" => record.surname = replacement,
"city" => record.city = replacement,
"country" => record.country = replacement,
_ => panic!("incorrect column name"),
}
wtr.serialize(record)?;
}
wtr.flush()?;
Ok(())
}
fn main() {
let opt = Opt::from_args();
if let Err(err) = run(&opt...
...possible extensions
### `match_cfg`
The original version of this RFC was more expansive, and proposed a `match_cfg`
macro that provided some additional checking.
The `match_cfg` macro takes a sequence of `cfg` patterns, followed by `=>` and
an expression. Its syntax and semantics resembles that of `match`. However,
there are...
...Int) -> bool {
match op {
Add => x <= y,
Sub => x > y,
Mul => x != 1 && y != 1 && x <= y,
Div => y > 1 && ((x % y) == 0),
}
}
fn apply(op: &Op, x: Int, y: Int) -> Int {
match op {
Add => x + y,
Sub => x - y,
Mul => x * y,
Div => x / y,
}
}
Apart from syntax, no...
...fn poll(&mut self) -> Result<Async<u8>, io::Error> {
let mut buf = [0;1];
match self.0.poll_read(&mut buf) {
Ok(Async::Ready(_num_bytes_read)) => Ok(Async::Ready(buf[0])),
Ok(Async::NotReady) => Ok(Async::NotReady),
Err(e) => Err(e)
}
}
}
// Now we can use the above to create...
...Examples:
# let (a, b, c) = (0, 1, 2);
// For if branches
let bar = if true {
a
} else if false {
b
} else {
c
};
// For match arms
let baw = match 42 {
0 => a,
1 => b,
_ => c,
};
// For array elements
let bax = [a, b, c];
// For closure with multiple return statements
let clo...
...String,
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let cli_matches = App::new("Rust to the mooooon")
.version("1.0")
.arg(
Arg::with_name("concurrency")
.short("c")
.long("concurrency")
.help("Number of concurrent inserts")
.default_value("3"),
)
.arg(
Arg::with_name("inserts")
.short("i")
.long("inserts...
"As usual, the borrow checker is correct: we are doing memory crimes."