Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...enable equality operators for exact matching, while disabling unused features such as comparison operators and facet search.
This targeted configuration can notably boost indexing performance.
Experimental: composite embedders
Meilisearch 1.14 introduces a new experimental feature that lets you use different embedders at search and indexing time, allowing you to...
...This prevents users from using an impl which is entirely covered by a where-bound, matching the behavior of the old implementation and avoiding some weird errors, e.g. trait-system-refactor-initiative#76.
NormalizesTo goals are a function
See the normalization chapter. We replace the expected term with an...
...u64) -> u64 {
match n {
0 => 0,
1 => 1,
n => fib(n-1) + fib(n-2),
}
}
In its naive recursive variant, executing this function takes
exponential time. With memoization, however, each unique call to
fib will be evaluated just once. This way, we can cut the
running time down from exponential...
...They also often introduce issues when using old C or C++ libraries—often desirable because so much existing code uses these languages—and so special care has to be taken when mixing and matching.
Languages such as Java, C#, and JavaScript also do not use native code, instead tending to...
...Rather, the trait matching
system implicitly instantiates impls as part of trait matching. This
implies that all type parameters are always instantiated with type
variables. These type variables are assigned fallbacks according to
the defaults given.
### Type variables with fallbacks
We extend the inference system so that when a type...
...a GET request to /home/1 will match with both!
But the request handler will fail to extract route parameters from /home/:id if you forget to change the field name in HomeRouteParams from home_id to id. Even worse, the failure will happen at runtime—if there are no...
...The specific
declarative syntax using pattern matching and templating is often referred to as
'macros by example'.
'Pattern macro' has been suggested as an alternative for 'declarative macro'.
## Drawbacks
[drawbacks]: #drawbacks
There is a risk that `macro_rules!` is good enough for most users and there is
low adoption of...
...or raw pointer that has invalid metadata:
• dyn Trait metadata is invalid if it is not a pointer to a vtable for Trait that matches the actual dynamic trait the pointer or reference points to
• slice metadata is invalid if the length is not a valid usize (i.e., it...
...Request<PlanetRequest>,
) -> Result<Response<PlanetResponse>, Status> {
debug!("Got a request: {:?}", request);
let planet_name = request.into_inner().name;
let planet =
persistence::repository::get_by_name(&planet_name, &get_connection(&self.pool));
match planet {
Ok(planet) => {
let planet = PlanetWrapper {
planet: planet.0,
satellites: planet.1,
}
.into();
let reply = PlanetResponse {
planet: Some...
...Let’s have it for plain if and address match and if let once there actually is a workable design for those.
No LTS
Rust has successfully delivered on “stability without stagnation” to the point that Red Hat delivers Rust updates for RHEL on a 3-month frequency instead of...
...I think that it adds an extra hurdle to learnability1, it obscures the (incredibly simple!) way that Rust's error-handling works, it produces an unfortunate asymmetry between producing Result values (where the shape of the data is implied by the context) and matching on Result values (where you will...
...Some(#margin_int),
}
}
None => quote! {},
};
let maybe_color_fg_expr = match color_fg {
Some(color_expr) => {
quote! {
color_fg: Some(crossterm::style::#color_expr.into()),
}
}
None => quote! {},
};
let maybe_color_bg_expr = match color_bg {
Some(color_expr) => {
quote! {
color_bg: Some(crossterm::style::#color_expr.into()),
}
}
None => quote! {},
};
quote...
...0 };
for ch in &self.slice[..i] {
match *ch {
b'\n' => {
position.line += 1;
position.column = 0;
}
_ => {
position.column += 1;
}
}
}
position
}
…which is called from position() to format the error, which is documented as:/// Position of the most recent call to next().
///
/// ...
///
/// Only called in case of an error, so...
...for mut body in g.l_body.iter_mut(&g.graph) {
let tr = match g.graph.get_neighbor(&body, &g.l_transform) {
Some(tr) => tr,
None => continue,
};
let coll = match graph.get_neighbor(&body, &g.l_collider) {
Some(c) => c,
None => continue,
};
// ...do stuff with `body`, `tr` and `coll`!
}
// note...
...You can call C libraries from Rust, or mix and match C++
components with Rust packages.
Overall, Rust sits neatly in the “best of both worlds” space between
garbage-collected memory-safe languages like Go, and high-performance,
close-to-the-metal languages like C++.
Happy, productive developers
Okay, Rust...
...After [src/grammar] transitions into this state, for any discovered discrepancies the
rustc parser implementation must be adjusted to match the [src/grammar], unless decided otherwise
by the RFC process.
### RFC process changes for syntactic changes and additions
Once the [src/grammar] enters semi-canonical state, all RFCs must describe...
...base}; // OK, only base.x is accessed
drop(y_ref);
Struct expressions can't be used directly in a loop or if expression's head, or in the scrutinee of an if let or match expression. However, struct expressions can be used in these situations if they are within another...
...let (tcp_stream, socket_addr) = tcp_listener.accept().await?;
let tx = tx.clone();
tokio::spawn(async move {
let result = handle_client_task(tcp_stream, tx, socket_addr).await;
match result {
Ok(_) => {
log::info!("handle_client_task() terminated gracefully")
}
Err(error) => log::error!("handle_client_task() encountered error: {}", error),
}
});
}
}
To run...
...running `/usr/bin/package.rs` without root privileges)
How do we handle the `package.edition` field, balancing
single-file package use case needs (no boilerplate, modern
experience) with the expectations of Rust for reproducibility?
- Matching the expectation of a reproducible Rust experience
- Users wanting the latest experience, in general
- Boilerplate...
...match page_title(url).poll() {
Ready(page_title) => match page_title {
Some(title) => println!("The title for {url} was {title}"),
None => println!("{url} had no title"),
}
Pending => {
// But what goes here?
}
}
What should we do when the future is still Pending? We need some way to try again, and again...
"\[W\]e reached a tipping point. **We decided to move our entire codebase to Rust**... . Rust seemed to give us all the capabilities we needed, **howev..."