Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...Metric<T> = T> {
/// Returns the nearest match to `target` (or `None` if this index is empty).
fn nearest(&self, target: &U) -> Option<Neighbor<&T>>;
/// Returns the nearest match to `target` within the `threshold`, if one exists.
fn nearest_within(&self, target: &U, threshold: f64) -> Option<Neighbor<&T>>;
/// Returns the up...
...base64::Config = match_config(opt);
let bytes = base64::decode_config(b64, config).expect("decode failed: invalid b64");
String::from_utf8(bytes).unwrap()
}
#[rustler::nif]
pub fn encode(s: String, opt: Atom) -> String {
let config: base64::Config = match_config(opt);
base64::encode_config(s.as_bytes(), config)
}
fn match_config(option...
...FairDice,
}
impl SimpleFuture<u8> for LoadedDice {
fn poll(&mut self) -> Poll<u8> {
match self.inner.poll() {
Poll::Ready(x) => Poll::Ready(x + 1),
Poll::Pending => Poll::Pending,
}
}
}
Now.. writing all those "match poll, if pending then return, if ready
then continue" blocks can also get pretty tedious. Thankfully, Rust
provides...
...fn extract_entities(tree: &Tree, source: &str) -> Vec<SemanticEntity> {
let mut cursor = tree.root_node().walk();
let mut entities = Vec::new();
for node in tree.root_node().children(&mut cursor) {
match node.kind() {
"function_item" | "function_definition" => {
entities.push(build_entity(node, source, "function"));
}
"class_definition" | "impl_item" => {
let class...
...The compiler's searching and file matching logic would be altered to only match
crates based on name. If two versions of a crate are found, the compiler will
unconditionally emit an error. It will be up to the user to move the two
libraries on the filesystem and control...
...bz_stream = mem::zeroed();
let result = BZ2_bzCompressInit(&mut stream as *mut _,
1, // 1 x 100000 block size
4, // verbosity (4 = most verbose)
0); // default work factor
match result {
r if r == (BZ_CONFIG_ERROR as _) => panic!("BZ_CONFIG_ERROR"),
r if r == (BZ_PARAM_ERROR as _) => panic!("BZ_PARAM...
...Self::Message) -> ShouldRender {
match msg {
Msg::Increment => self.value += 1,
Msg::Decrement => self.value -= 1,
}
true
}
fn change(&mut self, _props: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
html! {
<div>
<button onclick=self.link.callback(|_| Msg::Increment)>{"+"}</button>
<span style="width: 50px">{ self.value }</span>
<button onclick=self.link...
...So we used the matches!() macro inside the assertion to verify this use
case. The expression used was assert!(matches!(...));, that is not as clarifying as it could be.
I have used similar expressions for quite a while, but I was secretly hoping that assert_matches!() would become part
of...
Martin Larralde -- In a classic case of “Rewrite It In Rust”, implementing a novel algorithm for identifying binding sites in DNA led to a 100x improvement in speed. This talk emphasizes on what made it easier with Rust compared to C & C++, which are still in use predominantly in...
...fn main(){
loop {
print!("> ");
stdout().flush();
let mut input = String::new();
stdin().read_line(&mut input).unwrap();
let mut parts = input.trim().split_whitespace();
let command = parts.next().unwrap();
let args = parts;
match command {
"cd" => {
// default to '/' as new directory if one was not provided
let new_dir = args.peekable...
...SyntaxNode) -> Option<Self> {
let result = match node.kind() {
SyntaxKind::InfixExpr => Self::BinaryExpr(BinaryExpr(node)),
SyntaxKind::Literal => Self::Literal(Literal(node)),
SyntaxKind::ParenExpr => Self::ParenExpr(ParenExpr(node)),
SyntaxKind::PrefixExpr => Self::UnaryExpr(UnaryExpr(node)),
SyntaxKind::VariableRef => Self::VariableRef(VariableRef(node)),
_ => return None,
};
Some(result)
}
}
We’re still missing an AST node, namely...
...We have to match on the Result for that:let blocks = match Blocks::from_file("Blocks.txt") {
Ok(blocks) => blocks,
Err(unicode_blocks::Error::Io(e)) if e.kind() == io::ErrorKind::NotFound => {
}
};
Great! But the compiler is yelling that the match arms aren’t exhaustive. Not too hard to fix...
Rust toolchains newer than 2022-07-29 contain a proc macro server that should be compatible with macros built by the matching compiler.
Since today’s release, the server is automatically detected by and used rust-analyzer.
This means that, from now on, proc macros will keep working when the...
...Subsequent producers must use the same subject:
// First producer - assigns schema subject to topic
let first = client.producer()
.with_topic("new-topic")
.with_schema_subject("user-events") // ✅ Sets topic's schema
.build();
// Second producer - must match
let second = client.producer()
.with_topic("new-topic")
.with_schema_subject("user-events") // ✅ Matches...
...enum variants, you can also use match, but keep it simple: Only match one thing, and avoid more complex things like guard clauses:
// Don't nest patterns in match arms
match err_opt_val {
Some(Err(e)) => panic!("{e}"),
_ => (),
}
// instead, nest `match` expressions
match err_opt_val {
Some(err_val...
...def assert_matches(counts1, counts2):
"""Match A to Z counts."""
for character in 'abcdefghijklmnopqrstuvwxyz':
assert counts1[character] == counts2[character]
assert_matches(
frequency_1(TEXT),
frequency_3(TEXT)
)
Our new implementation is even faster:
Code
Elapsed microseconds
frequency_2(TEXT)
25,965.5
frequency_3(TEXT)
19,443.5
The Practice...
...bool> MyEnum<AllowB> {
fn is_a(&self) -> bool {
match *self {
MyEnum::A => true,
_ => false,
}
}
}
impl MyEnum<true> {
// this won't be allowed on MyEnum<false>, giving a helpful compile-time error
fn is_b(&self) -> bool {
match *self {
MyEnum::B => true,
_ => false,
}
}
}
The first thing that comes to mind is...
...This is what the match construct is all about: match item_option { Some(item) => { //Do something with resource println!("{}", item); } None => {}};It's called pattern matching and it's a switch statement, but for types. Here the Some branch is the only code path with a valid reference to item...
...Only types which have the "structural match"
property can be used as const parameters. This would exclude floats, for
example.
The structural match property is intended as a stopgap until a final solution
for matching against consts has been arrived at. It is important for the
purposes of type equality...
...Usually, you'll want to copy this value from a corresponding `-fpatchable-function-entry=` being passed to the C compiler in your project - `total_nops` will match the first parameter used by your C compiler, and the optional `offset` parameter passed to the C compiler will match `prefix_nops`.
To...
"You don't declare lifetimes. Lifetimes come from the shape of your code, so to change what the lifetimes are, you must change the shape of the code."