Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...join("CMakeLists.txt").exists()); let mut builder = cmake::Config::new(lib_source_dir); // Look for -Zsanitizer=address for flag in rustflags::from_env() { if matches!(flag, Flag::Z(z) if z == "sanitizer=address") { builder.define("ENABLE_SANITIZERS", "ON"); builder.define("SANITIZERS", "address"); break; } } builder.build(); } License Licensed under either of...
...This allows the Provider to expose a consistent interface to the rest of the program, while adjusting request and response types to match the underlying blockchain. Providers can be composed via stacking. For example, a Provider that tracks the nonce for a given address can be stacked onto a Provider...
...On the other
hand, adding or renaming an ingredient could cause the fuzzy-matching to pick a totally different
closest-match than what it did when I wrote the recipe to start with, which I don’t want.
Every ingredient and recipe (and anything else I add to the system...
...The value is scaled to match that suffix if possible. use human_format::Formatter; let mut f = Formatter::new(); f.with_suffix("M"); assert_eq!(f.format(100_000.0), "0.10 M"); If the suffix is not valid for the current Scales , the formatter falls back to automatic selection...
...Scrutinee
A scrutinee is the expression that is matched on in match expressions and similar pattern matching constructs. For example, in match x { A => 1, B => 2 }, the expression x is the scrutinee.
Size
The size of a value has two definitions.
The first is that it is how much...
...impl Instrumentation { // (continued) pub(crate) fn setup(&self) -> color_eyre::Result<()> { let filter_layer = self.filter_layer()?; let registry = tracing_subscriber::registry() .with(filter_layer) .with(tracing_error::ErrorLayer::default()); // `try_init` called inside `match` since `with` changes the type match self.logger { Logger::Compact => { registry.with(self.fmt_layer...
...Indeed the amount of frames in the backtrace can be huge (especially when using tokio), and we want to find the last frame that matches one of the modules we are interested in.
So we'll have to provide a list of modules to the allocator, and it will use...
Automata construction and matching using regular expressions. regex-automata This crate exposes a variety of regex engines used by the regex crate. It provides a vast, sprawling and "expert" level API to each regex engine. The regex engines provided by this crate focus heavily on finite automata implementations and specifically...
...State) -> (Option<usize>, State) {
loop {
state = match state {
State::Enter => {
return_!(Some(0); State::AfterYield0);
}
State::AfterYield0 => {
return_!(Some(1); State::AfterYield1);
}
State::AfterYield1 => {
return_!(Some(2); State::AfterYield2);
}
State::AfterYield2 => {
goto!(State::Exit);
}
State::Exit => {
return_!(None; State::Exit);
}
}
}
}
}
We move the current state into advance, then have this...
...use fluvio_smartstream::{smartstream, Record};#[smartstream(filter)]pub fn filter_odd(record: &Record) -> bool { // Parse the input bytes as a UTF-8 string, or return false let string_result = std::str::from_utf8(record.value.as_ref()); let string = match string_result { Ok(s) => s, _ => return false, }; // Parse the string...
...In cases where multiple peers match, the one with the
longest prefix match is selected.
Conversely, for incoming UDP datagrams, after decapsulation, we
obtain an IP packet with a known source address (src).
Given the connected Peer from which this packet originates,
we check if src falls within that peer...
...But also… we need to pattern match again.
Like so:
match (&this.a, &this.b) {
(State::Ok(_), State::Ok(_)) => {
let a = match std::mem::replace(&mut this.a, State::Gone) {
State::Ok(t) => t,
_ => unreachable!(),
};
let b = match std::mem::replace(&mut this.b, State::Gone) {
State::Ok(t...
...chriskrycho
Twitter: @chriskrycho
A dummy container for use with references.A simple example of using the dereference operator.A simple demonstration of matching against a reference type.Give a basic example of how the reference operator works.
...Currently rustc cannot generate this instruction, but we plan to add it as an extension of #[loop_match], a feature that I worked on in a previous Project Goal. I wrote about this earlier in Improving state machine code generation . Currently #[loop_match] is only useful when the next state...
...² Java’s switch statement is both less powerful than the fully destructuring
pattern matching of Rust’s match and has surprising fallthrough between
case statements (I have my IDE warn on this to mitigate the surprise).
Note that this list is incomplete, and some things don’t completely match...
...It was related to the fact that Meilisearch did not have enough data to rate crates except the query matching words.
Meilisearch doesn't know how to settle equal crates with only the matching words
Downloads counts amazingly improved the search results. This data is available through crates.io. A...
...The innermost expression that encloses both of these
expressions is the match itself (as depicted above), and hence the
borrow is considered to extend until the end of the
match. Unfortunately, the match encloses not only the `Some` branch,
but also the `None` branch, and hence when we go to...
...It's not completely incidental due to Web history, but encoding_rs will prioritize compliance with the WHATWG Encoding Standard over matching the Windows system converters exactly. Still, encoding_rs is in practice useful for decoding legacy Windows data, because all the "ANSI code pages" that are the default for...
pub fn home_dir() -> Option<crate::path::PathBuf>...Examples
use std::env;
match env::home_dir() {
Some(path) => println!("Your home directory, probably: {}", path.display()),
None => println!("Impossible to get your home dir!"),
}
...On the NVIDIA B200 GPU, cuTile Rust achieves 7 TB/s for element-wise operations and 2 PFlop/s for GEMM (96% of cuBLAS), matching cuTile Python within measurement noise. Grout, a cuTile-Rust-based inference engine, exercises cuTile Rust across an end-to-end Qwen3 inference path. In batch...
"If you write a bug in your Rust program, Rust doesn’t blame you. Rust asks “how could the compiler have spotted that bug”."