Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...Most of my functions with many return paths terminate with a match statement. Technically, these
could be reduced to a single return path by just wrapping the whole match in an Ok, but I don’t
know anyone who considers that good form, and I certainly don’t. But an...
...VS Code allows installing VSIX files that don’t match your platform. Please don’t do that.
If you’re running a 32-bit version of VS Code on a 64-bit Windows system, please install the 64-bit version of Code instead. This configuration used to work thanks to...
...There is ongoing work to determine how best to use all of these; for example, the Wasm spec interpreter is not well-suited to running large programs (it is designed to match the spec formalisms exactly, rather than for speed) and so we are not running it in that way...
...Vec<TokenTree> = item.into_iter().collect();
let literal = match &input.get(0) {
Some(proc_macro2::TokenTree::Literal(literal)) => literal.to_string(),
_ => panic!(),
};
The approach works, but it’s a bit strange
dealing with a Literal. For example I had to trim the quote characters off
myself, as there didn’t...
...Many constructs
like `match` and `if`, which use curly braces, also do not require semicolons
when they begin a statement.
## Drawbacks
- This introduces a difference between different macro invocation delimiters,
where previously there was no difference.
- This requires the use of semicolons in a few places where it was not...
...pub async fn handle_connections(&mut self) {
loop {
let ev = self.next_event().await;
let ev = match ev {
Ok(ev) => ev,
Err((e, i)) => {
eprintln!("Socket error: {e}");
self.read_connections.remove(&i);
self.write_connections.remove(&i);
continue;
}
};
match ev {
Event::Read((dest, items)) => {
let Some(writer) = self.write...
...ColumnOption::Default(_), .. } => {
152 has_default = true;
153 }
154 _ => {}
155 }
156 }
157
158 if has_not_null || has_default {
159 datatype
160 } else {
161 format!("Option<{datatype}>")
162 }
163}
164
165166fn extract_table_name(from: &Vec<TableWithJoins>) -> Option<String> {
167 match from.first() {
168 Some(table_with_joins) => match &table_with...
...It also provides other important benefits, such as improved error handling, stricter typing, sum types, pattern matching, privacy, closures, generics, etc.
This microconference intends to cover talks and discussions on both Rust for Linux as well as other non-kernel Rust topics.
Possible Rust for Linux topics:
Rust in the...
...user=user, 42≠99, logged=logged, in=in → 3 of 4
match (0.75 ≥ 0.4), so it merges. The single differing slot is generalized to a wildcard:
4-token shard
└─ user
└─ <*>
└─ #1 user <*> logged in (size 2) ← "42" and "99" collapsed to <*>
3. user 7 logged in. Same leaf...
...SmartThings offers Medical, Dental, Vision, HSA options, FSAs, EAP, 401(k) +matching, and various wellness benefits.
Unlimited PTO
We believe that work/life balance is a necessity, so we want to be sure you get the rest and relaxation you deserve.
Flex-Normal
With offices in Minneapolis, MN and Mountain...
...herencia rígida, nulidad descontrolada, y la ausencia de funciones como valores de primera clase en los lenguajes de la épocaRust, por su parte, es un lenguaje multiparadigma que incorpora elementos de programación orientada a objetos (traits, impls) y funcional (inmutabilidad por defecto, pattern matching exhaustivo, enums con datos,zero-cost...
...HN user momentumtop's explanation match my feelings exactly:The Haskell community, in my experience, is far more academic. A recent post to the Haskell libraries mailing list began with:"It was pointed out to me in a private communication that the tuple function \x->(x,x) is actually a...
...We don’t
want to expose the internals of the type because we might add a lot of other things in there and
allowing people to pattern-match a Person would break their code when we add more things.
impl Person {
pub fn new(name: String) -> Person {
Person { name }
}
}
That...
...While in Rust, a non-exhaustive match produces a compile-time error:
#[derive(Debug, Clone, Copy)]
enum Platform {
Linux,
MacOS,
Windows,
Unknown,
}
impl fmt::Display for Platform {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Platform::Linux => write!(f, "Linux"),
Platform::Macos => write!(f, "macOS"),
// Compile time...
...items
• macro_rules declarations and matcher metavariables
• Implementation associated items
•
Expressions:
• Closure parameters
• while let pattern bindings
• for pattern bindings
• if let pattern bindings
• match pattern bindings
• Loop labels
•
Generic parameters
•
Higher ranked trait bounds
•
let statement pattern bindings
•
The macro_use attribute can introduce macro names from another crate...
...An `enum` may be `#[repr(transparent)]` if it has exactly one variant, and that variant matches the same conditions which `struct` requires for transparency. Some concrete illustrations follow.
A union may be `#[repr(transparent)]` if it has exactly one non-zero-sized field:
```rust
// This union has the same representation...
...usize) -> u8 {
x.drain_range(index).next().unwrap()
}
fn pop(x: &mut Vec<u8>) -> Option<u8> {
match x.len() {
0 => None,
n => x.drain_range(n-1).next()
}
}
fn drain(x: &mut Vec<u8>) -> DrainRange<u8> {
x.drain_range(0..)
}
fn clear(x: &mut Vec<u8>) {
x.drain_range(0...
...DbErr = cake .into_active_model() .insert(db) .await .expect_err("inserting should fail due to duplicate primary key");match error { DbErr::Exec(RuntimeErr::SqlxError(error)) => match error { Error::Database(e) => { // We check the error code thrown by the database (MySQL in this case), // `23000` means `ER_DUP_KEY`: we have...
...This gives you precise error types that consumers can match on and handle differently. It's the approach that many library authors (rightfully) prefer because it provides a stable, matchable API.
Both approaches have their merits, but there's an interesting third option that's rarely discussed: the standard library...
...In the end, we were able to validate that our Rust hashing code was working and matched the Go behavior.Overall, this approach really paid off for us. We found a lot of bugs that otherwise we would have struggled to find. We were able to validate that our code...
"Just because Rust allows you to write super cool non-allocating zero-copy algorithms safely, doesn’t mean every algorithm you write should be super ..."