Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
...Rust 1.96.0
Stabilizes new core::range types and core::assert_matches!/core::debug_assert_matches!.
WebAssembly targets now fail on undefined linker symbols by default instead of implicitly treating them as "env" imports.
Includes Cargo fixes for CVE-2026-5223 and CVE-2026-5222 for users of third...
...DeserializeOwned>(buf: &mut BytesMut) -> Option<T> {
let p = buf.iter().position(|b| b == &b'\n');
match p {
None => None,
Some(n) => {
let res = serde_json::from_slice(&buf.split_to(n).freeze()).ok();
buf.advance(1); // Skip the newline char
buf.reserve(BUFFER_SIZE); // Make sure the buffer can hold...
...Nested routers with fallbacks
Router::nest allows you to send all requests with a matching prefix to some
other router or service. However in 0.5 it wasn't possible for nested routers to
have their own fallbacks. In 0.6 that now works:
use axum::{Router, Json, http::StatusCode...
...Notice that it derives the Deserialize trait, meaning, it can be deserialized from JSON
warp::post() filter to accept only POST requests
warp::body::json() to read JSON payload
.and(..) filter to chain them together and ensure that a successful request must match all of the required filters
use serde...
...The structs can be constructed, destructed, and participate in
pattern matches.
Private fields on tuple structs will prevent the following behaviors:
* Private fields cannot be bound in patterns (both in irrefutable and refutable
contexts, i.e. `let` and `match` statements).
* Private fields cannot be specified outside of the defining module...
...exact matches instead of semantic approximations, automatic .gitignore respect, and predictable behavior. You know exactly what it's searching.A Hacker News commenter pointed out this is still technically RAG, just using information retrieval techniques that have existed for decades. Sometimes proven approaches beat newer alternatives.I wrote a deeper...
...nix = "0.18.0"
Now add the below code in main.rs
use nix::sys::wait::wait;
use nix::unistd::ForkResult::{Child, Parent};
use nix::unistd::{fork, getpid, getppid};
fn main() {
let pid = fork();
match pid.expect("Fork Failed: Unable to create child process!") {
Child => println!(
"Hello from child process...
...Expected range of matching incoming requests: == 1
Number of matched incoming requests: 0
Implementation Strategy
We have more than enough tests to give us feedback now - let's kick off the implementation work!
We will start with a naive approach:
Retrieve the newsletter issue details from the body of the...
...But to take a whole block of code, and replace everything that looks like a message lock in that block…well, it might be possible with pattern-matching and quite a bit of recursion, but it’s going to be a lot easier to use procedural macros, a Rust macro...
...mathieuh updated the Request constructor to match more recent specification changes.
impowski added Graphviz output of rust-bindgen’s IR
New Contributors
Dawing Cho
Eddie Quan
Gregory Katz
Huxley
Ian
Sam Liu
Jefry Lagrange
Neck Varentsov
vwvww
Ethan Glasser-Camp
Interested in helping build a web browser? Take a look...
...It’s
just unfortunate that I have to resort to “old-school” error-handling when I’m in a
filter:new_house_uuids = new_house_uuids
.into_iter()
.filter(|new_house_uuid| {
let existing_owner = db.investment_users.get(new_house_uuid);
match existing_owner {
Ok(Some(_)) | Err(_) => false,
Ok...
...For other topics (e.g., related topics with language features such as structs, patterns and matchings, and foreign function interface), information is only available on Q&A websites while lacking in the official documentation. Finally, we discuss implications for programming language documenters, particularly how to leverage our approach to prioritize...
...Token) -> Result<Foo, E> {
try!(d.expect_struct_start(token, "Foo"));
let mut a = None;
let mut b = None;
let mut c = None;
static FIELDS: &'static [&'static str] = &["a", "b", "c"];
loop {
let idx = match try!(d.expect_struct_field_or_end(FIELDS)) {
Some(idx) => idx,
None => { break; }
};
match idx...
...Some links:Video of the talk on YouTube.Slides on Google Slides.Repository with links and notes on GitHub.Coverage on Linux Weekly News.Introduction#Let’s start with a simple example – you decide to read from a channel in a loop and gather a bunch of messages:loop {
match...
...It also provides other important benefits, such as improved error handling, stricter typing, sum types, pattern matching, privacy, closures, generics, etc.
Possible Rust for Linux topics:
Rust in the kernel (e.g. status update, next steps...).
Use cases for Rust around the kernel (e.g. subsystems, drivers, other modules...).
Discussions...
...Many of the projects that we set in motion in 2021 and planned to finish in 2022 – most significantly, a new register allocator, and ISLE, a pattern-matching DSL that has come to serve as the core of our backends – have come to fruition, entering production and improving compiler output...
...With these ideas in mind, let's take a brief look at Rust's error handling!
let mut file_result = File::open("hello.txt");
match file_result {
Ok(mut file) => {
let mut data = String::new();
let _ = file.read_to_string(&mut data);
}
Err(e) => {
println!("error when reading file: {e...
...JSJITorExpr) -> JSJITorExpr
{
match e
{
JSJITorExpr::Jit { label: label } => jump(label),
JSJITorExpr::Expr { expr: expr } => {
let rawexpr = *expr;
match rawexpr
{
JSExpr::Integer {..} => JSJITorExpr::Expr { expr: Box::new(rawexpr) },
JSExpr::String {..} => JSJITorExpr::Expr { expr: Box::new(rawexpr) },
JSExpr::OperatorAdd { lexpr: l, rexpr: r } => {
let l = eval(*l);
let r = eval(*r);
//call...
...MatchWithValueHandlers – matches and dispatches on an owned input Value.
MatchWithValueHandlersRef – matches and dispatches on a borrowed input &Value.
MatchWithValueHandlersMut – matches and dispatches on a mutably borrowed input &mut Value.
These dispatchers are compatible with both the owned and borrowed variants of the handler traits, such as Computer and ComputerRef. Within...
...fn next(&mut self) -> Option<Self::Item> {
loop {
match *self.current_tree {
None => match self.prev_nodes.pop() {
None => {
return None;
}
Some(ref prev_node) => {
self.current_tree = &prev_node.right;
return Some(&prev_node.value);
}
},
Some(ref current_node) => {
if current_node.left.is_some() {
self.prev_nodes.push...
"Rust doesn't end unsafety, it just builds a strong, high-visibility fence around it, with warning signs on the one gate to get inside. As opposed to C..."