Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...Functional languages have potential and are safe
since they are ADT and pattern matching. But they’re not good for quick interpreters due to its
runtime. Conversely, C is quick and has no runtime, but it’s not
safe. I was searching for an ADT and pattern matching language
that...
...This would require changing the data layout of the structs to match C. The problem with using an enum is that a match operation is required on every dereference. I believe this match should be optimized out by the compiler, but I haven’t properly checked. But even then, struct...
pub const fn unwrap(self) -> T...Instead, prefer to use pattern matching and handle the None case explicitly, or call unwrap_or, unwrap_or_else, or unwrap_or_default. In functions returning Option, you can use the ? (try) operator.
Panics
Panics if the self value equals None.
Examples
let x = Some("air");
assert_eq!(x.unwrap...
pub const fn map<U, F>(self, op: F) -> Result<U, E>...let line = "1\n2\n3\n4\n";
for num in line.lines() {
match num.parse::<i32>().map(|i| i * 2) {
Ok(n) => println!("{n}"),
Err(..) => {}
}
}
...fn do_something() -> Result<(), Error> {
let user = get_user_opt().ok_or(Error::UserNotFound)?;
// do something
}
match
Then, of course, there is match:
fn do_something() -> Result<(), Error> {
let user = match get_user_opt() {
Some(user) => user,
None => return Err(Error::UserNotFound);
};
// do something
}
if let / let else
Even better...
...process socket events
for event in &events {
match event.token() {
Token(0) => {
loop {
match listener.accept() {
Ok((socket, _)) => {
// accept connection, create Handler
},
Err(_) => break
}
}
},
token if event.readiness().is_readable() => {
debug!("token {} readable", token.0);
if let Some(handler) = handlers.remove(&token) {
event_tx.send(handler).unwrap();
}
},
token if event...
...When searching for more than one byte, positions are considered a match if the byte at that position matches any of the bytes. The memmem sub-module provides forward and reverse substring search routines. In all such cases, routines operate on &[u8] without regard to encoding. This is exactly what...
...pub enum DbDriver { Postgresql, Mysql, } impl std::str::FromStr for DbDriver { type Err = String; fn from_str(s: &str) -> Result<Self, Self::Err> { match s.trim().to_lowercase().as_ref() { "postgres" => Ok(DbDriver::Postgresql), "mysql" => Ok(DbDriver::Mysql), _ => Err(format!("Unknown DB driver: {s}")) } } } #[derive(Envconfig)] pub struct DbConfig { // ... #[envconfig...
...pub enum DbDriver { Postgresql, Mysql, } impl std::str::FromStr for DbDriver { type Err = String; fn from_str(s: &str) -> Result<Self, Self::Err> { match s.trim().to_lowercase().as_ref() { "postgres" => Ok(DbDriver::Postgresql), "mysql" => Ok(DbDriver::Mysql), _ => Err(format!("Unknown DB driver: {s}")) } } } #[derive(Envconfig)] pub struct DbConfig { // ... #[envconfig...
...System76 offers health benefits, paid vacation, matching 401k, sabbatical, and an awesome dog-friendly work environment where smart people are free to create.
We are committed to providing equal employment opportunities to all employees and applicants, regardless of race, color, creed, religion, sex, gender identity/expression, age, national origin, disabilities...
...16) -> Result<Self, Self::Error> { match n { 0 => Ok(Foo::Bar), 100 => Ok(Foo::Baz), 200 => Ok(Foo::Quix), _ => Err(n), } } } fn main() { let bar = Foo::try_from(0); let baz = Foo::try_from(100); let quix = Foo::try_from(200); let bad = Foo::try_from(300); assert_eq!(bar...
pub fn duration(&self) -> Duration...Examples
use std::thread::sleep;
use std::time::{Duration, SystemTime};
let sys_time = SystemTime::now();
sleep(Duration::from_secs(1));
let new_sys_time = SystemTime::now();
match sys_time.duration_since(new_sys_time) {
Ok(_) => {}
Err(e) => println!("SystemTimeError difference: {:?}", e.duration()),
}
...Examples of such structures include but are not limited to
• Parenthesis
• Removed without replacement, the tree structure makes order explicit
• for loops
• Converted to match + loop + match
• Universal impl Trait
• Converted to generic arguments (but with some flags, to know that the user didn't write them)
• Existential impl Trait...
...Our algorithm prioritizes prefix matches and factors in the frequency of each candidate word within the dataset.
fn is_best_correction(word: &str, correction: &str) -> bool {
// Length-based filter
let len_diff = (word.len() as i32 - correction.len() as i32).abs();
if len_diff > 2 {
return false;
}
// Prefix matching (adjust...
...Vec<String>, output_dir: &str) -> Result<(), anyhow::Error> {
let mut html = templates::HEADER.to_owned();
let body = files
.into_iter()
.map(|file| {
let file = file.trim_start_matches(output_dir);
let title = file.trim_start_matches("/").trim_end_matches(".html");
format!(r#"<a href="{}">{}</a>"#, file, title)
})
.collect::<Vec<String...
pub fn remove<Q>(&mut self, value: &Q) -> bool...The value may be any borrowed form of the set's element type, but the ordering on the borrowed form must match the ordering on the element type.
Examples
use std::collections::BTreeSet;
let mut set = BTreeSet::new();
set.insert(2);
assert_eq!(set.remove(&2), true);
assert_eq!(set...
pub fn remove_entry<Q>(&mut self, k: &Q) -> Option<(K, V)>...The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.
Examples
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.remove_entry(&1), Some((1...
...syn::DeriveInput) -> syn::Result<TokenStream> { let attrs = Attrs::parse_attrs("from", &input)?; match (attrs.forward.is_some(), !attrs.custom.is_empty()) { (true, true) => Err(syn::Error::new_spanned( input, "`forward` and `on` arguments are mutually exclusive", )), (false, false) => Err(syn::Error::new_spanned( input, "either `forward` or `on` argument is...
...Value) -> Result<bool, Self::Error> {
match other {
Value::Bool(b) => Ok(b),
_ => Err(Error::BadVariableType),
}
}
}
impl TryFrom<Value> for i32 {
type Error = Error;
fn try_from(other: Value) -> Result<i32, Self::Error> {
match other {
Value::Integer(i) => Ok(i),
_ => Err(Error::BadVariableType),
}
}
}
impl TryFrom<Value> for f64 {
type Error = Error...
...On earlier versions of the Rust compiler, I had to use an iterator pipeline, using .scan(), match, .filter(), and .collect(), at twice the line count, to get tolerable performance. Now the loop is faster. A match would work here, but the code would be longer. Rust could have just one...
"Man, rust crates are so allergic to 1.0 that they'll skip all the way to version 22."