Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...Time for our first request!
extern crate hyper;
use hyper::Url;
use hyper::client::Request;
fn main() {
let url = match Url::parse("http://httpbin.org/status/200") {
Ok(url) => url,
Err(_) => panic!("Uh oh."),
};
println!("> get: {}", url);
let fresh_request = match Request::get(url) {
Ok(request) => request,
Err(_) => panic!("Whoops...
...Vec<(usize, String)> = Vec::new();
let mut line_number = 1;
for line in contents.lines() {
let is_match = regex.is_match(line);
let should_include = if invert { !is_match } else { is_match };
if should_include {
results.push((line_number, line.to_string()));
}
line_number += 1;
}
results
}
We are borrowing contents...
...u8) {
let checkpoint = p.checkpoint();
match p.peek() {
Some(SyntaxKind::Number) | Some(SyntaxKind::Ident) => p.bump(),
Some(SyntaxKind::Minus) => {
let op = PrefixOp::Neg;
let ((), right_binding_power) = op.binding_power();
}
_ => {}
}
loop {
let op = match p.peek() {
Some(SyntaxKind::Plus) => InfixOp::Add,
Some(SyntaxKind::Minus) => InfixOp::Sub,
Some(SyntaxKind::Star) => InfixOp...
...This meant that it wasn't possible to use the matching!-macro on that parameter.
The matching macro operates on immutable views of the function inputs, where a single, common lifetime parameter cuts it (because matching only reads things and does not return anything).
Given these limitations it became clear...
...loop {
let mut state = Start;
let mut end = start;
for c in source[start..].chars() {
let next = match state {
Start => match c {
'(' => Some(Lparen),
')' => Some(Rparen),
'0'...'9' => Some(Number),
'a'...'z' => Some(Symbol),
c if c.is_whitespace() => Some(Whitespace),
_ => None,
},
Lparen | Rparen => None,
Number => match c {
'0'...'9...
#5821 Remove Unused Parameter refactoring.
#5695 completion for unstable features.
#5643 Add new consuming modifier to semantic syntax highlighting, apply consuming and mutable to methods.
#5758 structural search replace now inserts *, & and &mut in the
replacement to match any auto[de]ref in the matched code.
#5682 allow disabling specific...
...Using Qwen3-4B as the primary generator under matched token budgets, DTV improves pass rates from 72.3% to 82.0% on C-to-Rust and from 33.3% to 46.0% on JavaScript-to-TypeScript relative to matched self-refinement baselines, while using fewer tokens per case; the same...
...At its core, the Matcher class does the heavy lifting and handles all the querying logic, i.e., checking whether a document matches a query.In JavaScript, it’s implemented as a cascade of nested closures, i.e., functions take some information about the query and return a function that...
...Values that are matched with wildcards must still be initialized.
let x: u8;
let c = || {
let _ = x; // ERROR: Binding `x` isn't initialized.
};
Capturing for discriminant reads
If pattern matching reads a discriminant, the place containing that discriminant is captured by ImmBorrow.
Matching against a variant of an enum that...
## Summary
[summary]: #summary
Currently when using an if let statement and an irrefutable pattern (read always match) is used the compiler complains with an `E0162: irrefutable if-let pattern`.
The current state breaks macros who want to accept patterns generically and this RFC proposes changing this error to an error...
## Summary
Add a `literal` fragment specifier for `macro_rules!` patterns that matches literal constants:
```rust
macro_rules! foo {
($l:literal) => ( /* ... */ );
};
```
## Motivation
There are a lot of macros out there that take literal constants as arguments (often string constants). For now, most use the `expr` fragment specifier, which is fine since...
...Just as it should be. 😊
Finding the exception handler
Link to heading
Finding a matching exception handler is just a question of checking all of them, in order, and stopping with the first one that matches, i.e. whose catch class is a superclass of the actual exception class, since...
...impl ::core::cmp::Ord for Point {
#[inline]
fn cmp(&self, other: &Point) -> ::core::cmp::Ordering {
- match *other {
- Self {
- x: ref __self_1_0,
- y: ref __self_1_1,
- } => match *self {
- Self {
- x: ref __self_0_0,
- y: ref __self_0_1,
- } => match ::core::cmp::Ord::cmp(&(*__self_0_0), &(*__self...
...Finally, it is useful for the reader to keep in mind that according to
the definitions of this RFC, no simple NT matches
the empty fragment, and likewise no token matches
the empty fragment of Rust syntax. (Thus, the *only* NT that can match
the empty fragment is a complex...
...For that we’ll use matching, another handy construct.
23 let mut v: Vec<char> = s.chars().collect();
24 v.sort();
25 let ss: String = v.into_iter().collect();
26
27 match dict.get(&ss) {
28 Some(mut v) => v.push(s),
29 _ => {
30 let mut v = Vec::new();
31...
...PCRE2 match error: match limit exceeded
Aborted (core dumped)
The Silver Searcher fails similarly. It reports the first line as a match and
neglects the match in the third line. The rest of the search tools benchmarked
in this article handle this case without a problem.
Literal optimizations
Picking a...
## Summary
[summary]: #summary
Add a `lifetime` specifier for `macro_rules!` patterns, that matches any valid
lifetime.
## Motivation
[motivation]: #motivation
Certain classes of macros are completely impossible without the ability to pass
lifetimes. Specifically, anything that wants to implement a trait from inside of
a macro is going to need to...
...TokenStream) -> TokenStream { let macro_string = parse_macro_input!(input as MacroString); let path = match macro_string.eval() { Ok(path) => path, Err(err) => return TokenStream::from(err.to_compile_error()), }; let content = match fs::read(&path) { Ok(content) => content, Err(err) => return TokenStream::from(macro_string.error(err).to_compile_error...
...let all_matched: String = selection.iter().map(|s| s.inner_html().trim().to_string()).collect(); assert_eq!( all_matched, "<li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li>" ); // or: let all_matched: String = selection.nodes().iter().map(|s| s.inner_html...
...impl error::Error for LibError {
fn description(&self) -> &str {
match *self {
BadStatusCode => "bad status code",
IoError(err) => "encountered an I/O error",
}
}
fn detail(&self) -> Option<String> {
match *self {
BadStatusCode(code) => Some(format!("status code was {}", code)),
_ => None,
}
}
fn cause(&self) -> Option<&error::Error> {
match *self {
IoError(ref err) => Some...
""I'll never!"
"No, never is in the 2024 Edition."
"But never can't be this year, it's never!"
"Well we're trying to make it happen now!"
"But never is..."