Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...This function is essentially just a large match statement over the opcode of the root CLIF instruction, with the match-arms looking deeper as needed.
Here is a simplified version of the match-arm for an integer add operation lowered to AArch64 (the full version is here):
<span class="k...
...use std::env;
fn main() {
match env::var("LANG") {
Ok(lang) => println!("Language code: {}", lang),
Err(e) => println!("Couldn't read LANG ({})", e),
};
}
$ cargo run
Language code: pl_PL.UTF-8
envy
envy is a small crate that uses serde
to automatically deserialize process environment into a Rust struct.
#![feature...
...Some things wouldn't ever be written on one line, like this match expression, and certainly not with a comma in front of the closing brace: fn eq(&self, other: &IpAddr) -> bool { match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, } } Some places use non-multiple-of-4 indentation...
...i32) -> f32 {
match index {
0 => self.threshold,
_ => 0.0,
}
}
fn set_parameter(&mut self, index: i32, value: f32) {
match index {
// We don't want to divide by zero, so we'll clamp the value
0 => self.threshold = value.max(0.01),
_ => (),
}
}
fn get_parameter_name(&self, index: i32) -> String {
match...
...match operand.into_future() {
mut pinned => loop {
let mut pin = unsafe { Pin::new_unchecked(&mut pinned) };
match Pin::future::poll(Pin::borrow(&mut pin), &mut current_context) {
Poll::Ready(r) => break r,
Poll::Pending => yield Poll::Pending,
}
}
}
where the yield pseudo-code returns Poll::Pending and, when re-invoked, resumes...
...It’d look like this:// The below code is just a simplification -- it may not compile!
impl<Id> Expression<Id> {
fn add_casts(&self, type_: &Type<Id>) -> Result<Self, Error<Id>> {
let mut clone = match self {
Self::Access { lhs, rhs } => {
let lhs_type = lhs.infer()?;
let Type::Arrow { lhs: key...
...Unresolved questions
The behavior specified here should match the behavior of MSVC at least. Does
it match the behavior of other C/C++ compilers as well?
Should it still be safe to borrow fields whose alignment is less than or equal
to the specified packing or should all field borrows...
...This function is all about pattern matching and unifying the error representation using .into():
fn poll_ready(
&mut self,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<(), Self::Error>> {
match self.web.poll_ready(cx) {
Poll::Ready(Ok(())) => match self.grpc.poll_ready(cx) {
Poll::Ready(Ok(())) => Poll::Ready...
Emulate macro-rules pattern matching in procedural macros proc-macro-rules macros You are probably looking for the proc-macro-rules crate.
...The subroutines that decide whether a particular impl/where-clause/etc applies to a particular obligation are collectively referred to as the process of matching. For impl candidates , this amounts to unifying the impl header (the Self type and the trait arguments) while ignoring nested obligations. If matching succeeds then...
...For your sanity, the match statement in this function is shortened for this example. fn recurse(stmt: &Statement, errors: &mut Vec<String>, mut is_global: bool) {
let mut allow_vars = true;
if is_global {
is_global = false;
allow_vars = false;
}
match stmt {
Statement::FunctionDeclaration(func) => match func {
FunctionDeclarationStat::Local { body...
...16:09 - matches!
Macro documentation
Jon proposes assert_matches
18:13 - Error::description deprecation
RFC
Soft deprecation in 1.27
failure
thiserror
anyhow
eyre
Jane expermenting with track_caller in eyre
24:23 - Other changes in 1.42
Documentation improvements to cargo
26:47 - Rust 1.43
27:17 - item...
...Changes to rules around temporary lifetimes for if let and the last expression in a block (2024).No need for pattern matching branches for impossible variants (e.g, using ! or Infallible) (1.82).Restrictions on using explicit referencing in patterns with match ergonomics (2024).Standard libraryLazyCell and LazyLock, alternatives to...
...fn main() {
let args = Arguments::parse();
let logger = logger::DummyLogger::new(args.verbosity as usize);
match args.cmd {
SubCommand::Count { package_name } => match count(&package_name, args.max_depth, &logger) {
Ok(c) => println!("{} uses found", c),
Err(e) => eprintln!("error in processing : {}", e),
},
SubCommand::Projects {
start_path,
exclude,
} => match projects...
...The key difference
here is how we use a match statement to replace multiple patterns using a single closure.
The &capture[2] syntax is used to access the second capture group in the regex match, which is the
suffix of the contraction, and this is then passed to the match...
...extern crate version_check as rustc; match rustc::is_min_date("2018-12-18") { Some(true) => "Yep! It's recent!", Some(false) => "No, it's older.", None => "Couldn't determine the rustc version." }; Check that the running compiler supports feature flags: extern crate version_check as rustc; match rustc::is...
...Clear) -> Self::Response {
self.ticks.clear();
Ack::new()
}
}
We can now add the match arm to our Router’s handle_message() method.
// sim/src/router.rs
use fps_counter::Clear;
impl<'a> MessageHandler for Router<'a> {
fn handle_message(&mut self, msg: &Packet) -> Result<Packet, CommsError> {
match msg.id() {
1...
...When the responding IP matches our target, we’ve reached the destination
and break out.
This needs sudo to run because of the raw ICMP socket.
1
2
3
4
5
6
7
8
9
10
11
$ sudo cargo run
1 <tailscale-ip>
2 <router-ip>
3 <isp-gateway-ip...
...ReplyEntry) {
println!("lookup(parent={}, name={})", parent, name.display());
let inode = match self.inodes.get(name.as_str().unwrap()) {
Some(inode) => inode,
None => {
reply.error(ENOENT);
return;
},
};
match self.attrs.get(inode) {
Some(attr) => {
let ttl = Timespec::new(1, 0);
reply.entry(&ttl, attr, 0);
},
None => reply.error(ENOENT),
};
}
This method...
...Explicitly matching every Result case is required to avoid panic. Or is it? Let's learn together to use turbofish syntax and the anyhow crate to produce more elegant but still idiomatic Rust code that allows us to explicitly handle Result(s) as necessary. We'll demonstrate making Rest API...
"Clippy’s Favorite Activity Is Criticizing Clippy’s Codebase"