Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...Vec<_> = self
.cell_positions()
.iter()
.map(|pos| self.cell(pos))
.filter_map(|cell| match &cell.symbol {
Some(symbol) => match symbol {
Symbol::Square(colour) | Symbol::Sun(colour) => Some((colour, &cell.region)),
},
None => None,
})
.collect();
let square_regions: Vec<_> = self
.cell_positions()
.iter()
.map(|pos| self.cell(pos))
.filter_map(|cell| match...
...self.queue_url.clone()
};
match self.sqs_client.delete_message_batch(&req) {
Ok(res) => {
unimplemented!()
},
Err(e) => {
println!("Failed to deleted {} messages {}", msg_count ,e);
}
}
}
}
A message for communicating to it:
pub enum MessageDeleterMessage {
DeleteMessages {
receipts: Vec<(String, Instant)>,
},
}
A ‘route_msg’ function to destructure the message and pass it...
...U8) -> U8 {{
match n {{
\u{FFA0}0 => \u{FFA0}1,
\u{FFA0}1 => \u{FFA0}1,
_ => fibonacci(n - \u{FFA0}1) + fibonacci(n - \u{FFA0}2),
}}
}}
fn factorial(n: U12) -> U12 {{
match n {{
\u{FFA0}\u{FFA0}0 | \u{FFA0}\u{FFA0}1 => \u{FFA0}\u{FFA0}1,
_ => factorial(n...
...pub fn push(&mut self, string: &str)
-> Result<(), ClassPathParseError> { /* ... */ }
/// Attempts to resolve a class from the various entries.
/// Stops at the first entry that has a match or an error.
pub fn resolve(&self, class_name: &str)
-> Result<Option<Vec<u8>>, ClassLoadingError> { /* ... */ }
}
The implementation of ClassPath will simply iterate through...
...impl Drink {
fn kind(&self) -> DrinkKind {
match self {
Drink::TapWater -> DrinkKind::TapWater,
Drink::Coffee(..) -> DrinkKind::Coffee,
Drink::Tea { .. } -> DrinkKind::Tea
}
}
}
And ability to iterate over all variants of DrinkKind:
impl DrinkKind {
fn all() -> Vec<DrinkKind> {
use DrinkKind::*;
vec![TapWater, Coffee, Tea]
}
}
The problem with the solution
The solution above will...
...Expr,) -> Option<Value> { match (kind, eval(vars, expr)?) { (UnExprKind::Not, Value::Bool(b)) => { Some(Value::Bool(!b)) } (UnExprKind::Neg, Value::Num(n)) => { Some(Value::Num(-n)) } _ => None, }}fn eval_binary( kind: BinExprKind, vars: &Variables<'_>, lhs: Expr, rhs: Expr,) -> Option<Value> { match kind { BinExprKind::Add => { if let Value::Num(lhs) = eval...
...let res = Bakery::insert_many(std::iter::empty()) .on_empty_do_nothing() // <- you needed to add this, // otherwise insert empty [] would lead to error .exec(db) .await;assert!(matches!(res, Ok(TryInsertResult::Empty)));
After careful consideration, we made a number of changes in 2.0:
removed APIs (e.g. Insert...
...impl Enumerator {
fn query_len(&self) -> Option<usize> {
Some(match self {
Enumerator::Empty => 0,
Enumerator::Values(v) => v.len(),
Enumerator::Iter(i) => match i.size_hint() {
(a, Some(b)) if a == b => a,
_ => return None,
},
Enumerator::RevIter(i) => match i.size_hint() {
(a, Some(b)) if a == b => a,
_ => return...
...false,
},
14:15,
)
(StackSlot refers to the values in the constants array)
Let’s match the two…
Yep Abstract Syntax Trees can get deeply nested, like this for loop…
(See the complete Abstract Syntax Tree)
But Abstract Syntax Trees are actually perfect for converting Rhai to uLisp.
Lisp is a...
...ip::SocketAddr) -> libc::c_int {
unsafe {
let fd = match libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0) {
-1 => panic!(),
fd => fd,
};
let mut storage = mem::zeroed();
let len = addr_to_sockaddr(addr, &mut storage);
let addrp = &storage as *const _ as *const libc::sockaddr;
match libc::bind(fd, addrp, len...
...This means 100% of the donations we receive go toward furthering our mission.Donations to Bevy Foundation (including all past donations that occurred this year) are now tax-deductible in the United States.Many employers have donation-matching programs for 501(c)(3)s. It is worth checking to see...
...is_match, find, captures.
A few lines of changes from using Captures to Matches reduce the running time by 2s.
Using dynamic programming to trace the best path in Viterbi decoding
I have speech processing and natural language processing background so I am quite familiar with hidden markov model training...
...returns a value), we can assign the values to `tile_repr`
// And then write the value to the format "stream"
let tile_repr = match self {
TileType::Empty => "Empty",
TileType::Red => "Player Red",
TileType::Black => "Player Black",
};
write!(f, "{tile_repr}")
}
}
Compiles without a hitch!
And the browser console now logs...
#11461 (first-contribution) filter generics in Extract struct from enum variant.
#11531 (first contribution) make fill_match_arms assist handle #[doc(hidden)] and #[non_exhaustive].
#11535 (first contribution) add install instructions for Kakoune and Helix.
#11524 (first contribution) state that only the latest stable toolchain is officially supported.
#11424 pass...
...After that, I will turn to virtual dispatch, impls,
and matching, and show how they interact.The Rust enumI don’t know about you, but when I work with C++, I find that the
first thing that I miss is the Rust enum. Usually what happens is
that I start...
...if let Some(matches) = matches.subcommand_matches("generate") {
let services_config_path = matches.value_of("services_config").unwrap();
let service_configs = ServiceConfig::load_all(services_config_path)
.expect("Unable to read services configuration file.");
let out_dir = Path::new(matches.value_of("out_dir").unwrap());
commands::generate::generate_services(service...
...u8) -> Self {
match v {
1 => Self::Legacy,
2 => Self::WriteAheadLog,
_ => Self::Unknown(v),
}
}
}
Let's just check in on a few things here. First we are deriveing a few more items,
PartialEq and Eq allow for using the == operator with 2 FormatVersions while
the PartialOrd and Ord allow for the...
...The migration lint will be implemented as follows:
* Find method calls matching the name of one of the newly added traits' methods.
This can be done either by hardcoding these method names or by setting up some
kind of registry through the use of an attribute on the relevant traits...
...Additionally, the first
inference time is by default quite long to match behaviour observed in
the wild.
There’s also, some likelihood of the inference panicking or failing
without a panic. Interfacing with neural network runtimes often involves an FFI
interface and GPUs. Both of these can cause issues for...
...Implementing global aliasing
The need is to be able to match both PascalCase and camelCase, while
keeping the field names in snake_case to cope with established Rust naming
conventions. I first tried to add support for multiple deserialize entries
with the following syntax:
#[serde(rename_all(deserialize = "PascalCase", deserialize...
"Treat *anything* starting with `cargo` as if it is `cargo run`. This applies even to commands that do not build anything, such as `cargo clean`, and t..."