Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...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...
...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...
...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...
...When combined with `#[repr(C)]` the size alignment and layout of the struct
should match the equivalent struct in C.
`#[repr(packed)]` and `#[repr(packed = "1")]` should have identical behavior.
Because this lowers the effective alignment of fields in the same way that
`#[repr(packed)]` does (which caused [issue #27060...
...The router receives the request and efficiently matches the request path against the registered routes. The pattern /{code} matches /abc12345, captures the path segment, verifies the HTTP method is GET, and selects the redirect handler.
Handler extraction: Before calling redirect, Axum runs the extractors. State<AppState> clones the Arc (cheap...
...implicit declaration of function ‘prinft’ [-Wimplicit-function-declaration]
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
// The first match group matches the file name which is relative.
"file": 1,
// The second match group matches the line on which the problem occurred.
"line": 2,
// The third match group matches the column at...
...0,
}
}
pub fn next_record(&mut self) -> Option<anyhow::Result<Cursor>> {
let page = match self.pager.read_page(self.page) {
Ok(page) => page,
Err(e) => return Some(Err(e)),
};
match page {
Page::TableLeaf(leaf) => {
let cell = leaf.cells.get(self.cell)?;
let header = match parse_record_header(&cell.payload) {
Ok...
...nested OR-patterns and trait aliases.Nested OR-patternsThis was mentioned as an upcoming feature in the post Recent and future pattern matching improvements from the Inside Rust Blog in March. In short, it allows you to nest patterns when pattern matching.Imagine you have an Option<u8> and you...
...Spawn Failed
Assertion Failed
Status (success / failure) Failed
Exit Code Failed
Output
Strings matched when shouldn't
Strings matched when should
Bytes matched when shouldn't
Bytes matched when should
Sub-strings matched when shouldn't
Sub-strings matched when should
Byte subset matched when shouldn't
Byte subset matched...
...Lazy<RegexSet> = Lazy::new(|| {
RegexSet::new(RULES.iter().map(|&(_, regex)| regex))
.expect("All regexes should be valid")
});
let matches = REGEX_SET.matches(blob);
if !matches.matched_any() {
return None;
}
Some(matches.iter().map(|i| RULES[i].0).collect())
}
And with the find_secrets() function done, we can go ahead and...
"what even is time?!?"