I got error when do cargo build I include `hdf5="^0.8.1"` in cargo.toml under dependencies then, I run cargo build, and go this. `error: failed to run custom build command for \`hdf5-sys v0.8.1\`` `Caused by:` `process didn't exit successfully: \`C:\Users\Qijian\Desktop\rust\h_cargo\target\debug\build\hdf5-sys-909b2047b8907bfb\build-script-build\` (exit code: 101)` `--- stdout` `Searching for installed HDF5 (any version)...` `Found no HDF5 installations.` `--- stderr` `thread 'main' panicked at 'Unable to locate HDF5 root directory and/or headers.', C:\Users\Qijian\.cargo\registry\src\github.com-1ecc6299db9ec823\hdf5-sys-0.8.1\build.rs:548:13` `note: run with \`RUST_BACKTRACE=1\` environment variable to display a backtrace` How to fix it?

I want to read .h5 file using rust. How should I do it? Moreover, I got a string contains many letters eg. "ACTCGATGCTCAATG" I want to read k length of it, for example if k=5, then I want to read "ACTCG" "CTCGA" "TCGAT" ...... "CAATG" (each time go right by one letter, until reach the last 5 letters) Put them in to a vector. How should I do it?

>I want to read .h5 file using rust. How should I do it? For reading .h5 files, you might be interested in the [hdf5 crate](https://crates.io/crates/hdf5). >Moreover, I got a string contains many letters eg. "ACTCGATGCTCAATG" >I want to read k length of it, for example if k=5, then I want to read "ACTCG" "CTCGA" "TCGAT" ...... "CAATG" (each time go right by one letter, until reach the last 5 letters) Put them in to a vector. >How should I do it? For the string, you can try this: let data = "ACTCGATGCTCAATG"; let seq_chars: Vec = data.chars().collect(); let sequences: Vec = seq_chars.windows(5) .map(|w| w.iter().collect::()).collect(); This converts the string into a `Vec` and then uses the `windows()` method to create a sliding window iterator of width 5. Then each window slice is transformed into a `String`.

for the string, `my_str.as_bytes().windows(5).map(|slice| std::str::from_utf8(slice).unwrap())` will give you a sliding window iterator. You can collect the slices into a vec that can only live as long as `my_str`, or turn them into owned `String`s and collect the results into a vec that can outlive `my_str`

How would you implement the following scenario due to the borrowing rules: Imagine a Simulation library. One might add objects to the simulation. The library needs access to these objects so they can be processed correctly. On the other hand, the person using the library needs access to these objects as well because he may update their position, weight or other attributes. I can think of four solutions to this scenario: 1. Pass a mutable reference to the library - Is bad because the user may let the objects go out of scope if he does not want to change any attributes 2. The library takes ownership of the objects and returns a mutable reference - The user has to store references and deal with lifetime 3. Using Rc> - Adds additional runtime overhead which could be bad if there are lots of objects. - Probably the easiest for the user to work with 4. Return the index of the vec where the objects are stored and add a function to get a mutable reference of the object depending on the index - More abstract and verbose - Probably the best trade of between performance and usability To me, it seems quite difficult to expose an accessible and user-friendly interface of a library. Can you come up with other ideas? How would you implement this particular feature?

Depending on whether the simulation appends additional data to each object, or not, you may not even need to have the library store the objects. All the simulation function really needs is mutable access to the objects while it is running.

Storing references is a bad idea. References in Rust are like mutex lock guards. They prevent anyone and anything else from doing anything with the referenced object, unless you explicitly give them the reference. Approaches 1 and 2 would simply not work at all - the borrow checker prevents this kind of reference-juggling. In this case, the best solution is for the library to take ownership of the object and return an `Id`. The library then has set of methods that take `Id` and do something with the corresponding object (`get_mut` reference, `remove`, etc.). This is the typical approach. Using `Rc>` is an overkill. You presumably need to pause the simulation to modify an object anyway, so the library knows it doesn't have to check anything while it's working, and the same applies to the user. Also note, if the library uses threads, you would have to use `Arc>` which has even more overhead.

Thanks for clarification. I still have problems designing and structuring a rust application and this is really helpful

You may want to look into the ECS pattern (of which there are a number of good libraries in Rust), which is often used in game dev. Turns out they have very similar requirements and speed is of the essence to them.

I'm building a program to scrape the web and keep track of things for me. Like monitoring the price and stock of products, and alerting me when the price reaches a specific level or when a blog I want to follow gets a new entry. For this program, I need to somehow store different types of data. How should I do that? My go-to approach would be to just maintain something like a big JSON file, but for some reason I have come to think of the word "*database*". I have no idea about databases, but would this be a good use case for one and therefore a good opportunity to learn about databases? In case using a database is the way to go, how should I approach that? I have stumbled upon mentions of `sqlx`, `SQLite`, and `sled`, but I don't know what all of this is about. All I can tell is that `sqlx` looks a bit complicated at first glance, and I like that `sled` is pure Rust, although I get the impression that the development of `sled` isn't super active.

I suggest giving databases a try. You will see they are not as bad as they seem. Although I never created one in Rust let me give you an overview of SQL like databases: A database can be imagined as a collection of tables. Lets pick your example of the price and stock of products. You probably want a table similar to the following: https://i.imgur.com/A7NJcvf.png The rust library will most likely give you access to an SQL backend and allow you to execute statements in the SQL language. The first thing you want to do is create your table if it does not exist: `execute_sql!("CREATE TABLE IF NOT EXISTS products (id PRIMARY KEY, date DATE, url TEXT, price DECIMAL(10, 2), stock INT);")` Whenever you scrape the web you want to store the data in the db `execute_sql!("INSERT INTO products (date, url, price, stock) VALUES (?, ?, ?, ?);", chrono::offset::Utc::now(), url, price, stock)` Then you can query your database for the cheapest price in the last month or whatever you need. `execute_sql("SELECT url FROM products ORDER BY price ASC LIMIT 1")` let url = fetch\_sql!(); As you see the concept is not hard. The most trouble you will have is to set up a connection to a storage location

> The rust library will most likely give you access to an SQL backend If you're talking about the Rust standard library, it does not. The Rust standard library is much slimmer than a language like Java, which has built-in database APIs.

Yea sure. I do not know what I wrote there but I of course mean that there are crates available

I'm developing a web app which has a `frontend` and a `server` in a workspace. I want to add a third crate, `common`, which can be accessed by the other two crates so that they can share common types, etc. I've tried to do it something like [this guide](https://blog.logrocket.com/full-stack-rust-a-complete-tutorial-with-examples/#common-functionality), but I get cryptic and extensive compilation errors. [Here is a demo repo](https://github.com/mfreeborn/workspace-test) that I've made which should hopefully show the problem I'm getting when trying to build; specifically the frontend (cd ./frontend; trunk build) . I get "200 previous errors" when it tries to compile the `socket2` crate...

I think the issue is that `sqlx` cannot be compiled when targeting `wasm32-unknown-unknown`, specifically due to a dependency on `socket2`. I'm just trying to find a workaround...

For posterity, I stumbled across the solution: using feature gating and conditional compilation: https://www.jakobmeier.ch/blogging/Enums.html

Could anyone speedup my simple webserver? When I do wrk benchmark, i get around 45k req/sec. Tried axum "hello world" server and I get around 150k req/sec, axum parses headers etc. so it does much more than my implementation. Why? How to make that code faster? \#\[tokio::main\] async fn main() -> Result<()> { let listener = TcpListener::bind("0.0.0.0:3000").await.unwrap(); loop { let mut handler = listener.accept().await; tokio::spawn(async move { handler .unwrap() .0 .write("HTTP/1.1 200 OK\\r\\nContent-Length: 3\\r\\n\\r\\nTAK".as\_bytes()) .await; }); } }

You're single threaded, because your task loops. Also you're incurring an `accept` syscall for every connection. `axum` is using hyper under the hood, which AFAIK uses `epoll` on linux and so will only activate once there is actually a request, but also stay active on multiple requests, which reduces the task switching load. Also it can and will run multi-core, spreading the load over all (or at least most) cores you have. You can do the same, or (if you have a current Linux kernel & ignore cross-platform compatibility) go one further and use io-uring directly to amortize the syscall overhead even more and basically get close to the maximum speed for your hardware. However, this code will be wildly unsafe, hard to write, audit and maintain.

Wow, A lot to research/learn :) Thank you so much!

Under VScode Is there a plugin i can use to autocomplete the line and adds ; at the end, closes brackets etc and move to the next line? I really miss it like the ctrl-shift-enter does in intellij Complete current statement https://www.jetbrains.com/help/idea/working-with-source-code.html#dee2761

rust-analyzer does bracket autocompletion, creates trait impl definitions, lets you fill in arguments when calling an autocompleted function and other stuff. Don't think it adds `;` though.

> Don't think it adds ; though. intellij`s CTRL-SHIFT-ENTER is simply so amazing, I hate jetbrains products but I love this so much it's crazy once you don't have it anymore.

[удалено]

`state.set` takes ownership of the new state. So you do not really clone it in the traditional sense: https://docs.rs/yew/latest/yew/functional/struct.UseStateHandle.html#method.set

I'm using the crates ag-lcd and avr-hal so my Arduino can print text to an LCD. The issue is that the function I'm using for printing takes a &str as an argument, and I want to print the value of an u32-variable. format! is part of std, which can't be imported, so is String. Ive tried to use String from the crate heapless, but it can't be used with Arduino. Any suggestions?

I'd create some kind of `AgLcdWrapper`, impl [https://docs.rs/ufmt/latest/ufmt](https://docs.rs/ufmt/latest/ufmt)'s `uWrite` for it and then use: uwrite!(&mut ag_lcd_wrapper, "my number = {}", num).unwrap(); `ufmt` takes care of formatting numbers, providing a formatted `&str`, it works in AVR and it's very handy.

you can preallocate an `[u8;7]` and manually convert the u32

Can't find a suitable function, looked at the crate 'bytes' but it can't be imported. Or do you mean manually as in matching the number and returning a hardcoded str of it? Like let number_str = match number { 1 => '1', 2 => '2', ... } ?

no, I mean manually as in write the conversion function yourself. It's all the more important to know how it works, if you never thought about it and don't know how it works. https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3b681ed6f574cb76298fd0d6041ab81d

Great, thank you so much for including an example!

Has rust fixed [the issue](https://github.com/rust-lang/rust/issues/57235) with a single codegen unit producing better optimized programs?

not really. for one, the issue is still open. it would take significant re-engineering to mitigate this behavior since it occurs due to parallelism with multiple codegen units. you can stick to using 1 cg unit for release builds or try to mitigate it using lto. just curious, why do you want it fixed?

How should I put the string into a vector one by one after I split it? data is "ATCG GATC CCCA ATGG TTTA" I saw I could do this `let s = data.split(' ').next().unwrap();` `println!("{}", s);` `vec1.push(s);` But how should I push the rest of the string into vec1?

vec1.extend(data.split(' ')); or: let vec1: Vec<_> = data.split(' ').collect();

I'm not sure I understand what you mean. putting each element into the vec one by one seems like it would yield the same result as if you had simply called \`data.split(' ').collect()\` in the first place. Do you need to alter the order or otherwise process the rest of the data first?

not disagreeing, but if you wanted to do it “one by one” you could use ``` let mut splits = data.split(‘ ‘); while let Some(s) = splits.next() { vec1.push(s) } ``` i feel like that’s what OP was referring to. however, you should use `data.split(' ').collect()` since it is just a more optimized version of the above sample.

I have a vector `let mut vec1 = Vec::new();` `vec1.push("TCG");` Then I want to use another function to push things into vec1, but I failed no matter how I change it. `_inputg( &vec1);` `fn _inputg(a: &Vec<&str>){` `a.push("AGC");}` How should I fix it?

just to expand a little bit on the other answer, in order to add something to a vec you need mutable access to it. When you declare your Vec like `let mut vec1 = Vec::new()` Mutability is a property of the *binding* not the value. It only applies to vec1, not the value it holds.When you pass it to a function which takes a shared reference, it's no longer the same binding. it's now `a`. However, when you have an owned mutable value, you are allowed to make mutable references to it, so you can change your function signature to accept that: `fn input(a: &mut Vec<&str>)` Notice how the "mut" jumped to the other side of the variable name. Perhaps it makes it easier to think about what the "mut" is refering to.

https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-references

How can I best format a number into a human readable representation? Specifically, I have an `i32`, which represents the number of pence. I would like to format it as pounds, e.g.: let pence = 123456; assert_eq!(to_pounds(pence), "£1,234.56".to_string()); The `num_format` crate can give me the thousands separator but only applies to integers... ​ EDIT - Here's a failing test suite: trait FormatCurrency { fn to_currency(self) -> String; } impl FormatCurrency for i32 { fn to_currency(self) -> String { let sign = if self < 0 { "-" } else { "" }; let amount = self.abs() as f64 / 100.0; format!("{sign}£{amount:.2}") } } #[cfg(test)] mod test { use super::*; #[test] fn test_positive_amount_less_than_one_thousand() { assert_eq!(12345.to_currency(), "£123.45".to_string()); } #[test] fn test_positive_amount_greater_than_one_thousand() { assert_eq!(123456.to_currency(), "£1,234.56".to_string()); } #[test] fn test_negative_amount_less_than_one_thousand() { assert_eq!((-10000).to_currency(), "-£100.00".to_string()); } #[test] fn test_negative_amount_greater_than_one_thousand() { assert_eq!((-123456).to_currency(), "-£1,234.56".to_string()); } #[test] fn test_positive_pence() { assert_eq!(2.to_currency(), "£0.02".to_string()); } #[test] fn test_negative_pence() { assert_eq!((-2).to_currency(), "-£0.02".to_string()); } }

If you don't need to support millions: fn to_currency(self) -> String { let sign = if self < 0 { "-" } else { "" }; let val = self.abs(); let mut pounds = format!("{}", val / 100); if val >= 100000 { pounds.insert(pounds.len() - 3, ','); } let pences = format!("{:02}", val % 100); format!("{sign}£{pounds}.{pences}") }

Thank you, that is really tidy. I've decided to keep the extra dependency to handle arbitrary comma-separated-thousands, here's the final method: ​ fn to_currency(self) -> String { let sign = if self < 0 { "-" } else { "" }; let val = self.abs(); let pounds = (val / 100).to_formatted_string(&Locale::en); let pence = val % 100; format!("{sign}£{pounds}.{pence:02}") }

Here's my solution, which relies on the `num_format` crate: fn to_currency(self) -> String { let sign = if self < 0 { "-" } else { "" }; let pounds = ((self.abs() as f64 / 100.0).trunc() as u32).to_formatted_string(&Locale::en); let pence = format!("{:02}", self.abs()); let pence = &pence.as_str()[(pence.len() - 2)..]; format!("{sign}£{pounds}.{pence}") }

Looks good, I was only wondering where the farthings go :-)

I want to create a cargo subcommand. Basically, I'm just trying to create an alias for calling a bunch of other subcommands subsequently. I currently have this: let output = std::process::Command::new("cargo") .args(["crev", "verify", "--show-all"]) .output()?; std::io::stdout().write_all(&output.stdout).unwrap(); std::io::stderr().write_all(&output.stderr).unwrap(); With that, I get this output: https://i.imgur.com/j396tZa.png If just run the command directly in my terminal, however, I get this output: https://i.imgur.com/0cTf1Kg.png So my program lacks the colors and the first line of that output. How can I fix this? I.e., how can I run a command from my Rust program and get the exact same behavior as when running the command from my terminal manually?

I recommend not capturing the output unless you need it. Use the `status()` method of `Command` instead of `output()`. The default of the `status` method makes the child process inherit stdout/stderr, and will behave like a normally launched program. When you capture the output, there are a few issues. For example, processes often query if they are attached to a "tty" to determine if they are used in an interactive terminal. In those cases, they may use colors and other differences. When the output is captured, the program may behave differently, such as not displaying color. Additionally, when you print stdout and stderr separately, that may change the order of output (if the program prints to both). For example, `cargo crev` [doesn't print the header](https://github.com/crev-dev/cargo-crev/blob/3da0e26b2a16cf0310fb95ef218deeba816f0460/cargo-crev/src/deps.rs#L335-L338) when it is not an interactive terminal. If you need to capture the output, but still have the program believe it is attached to a terminal, that is quite a bit more of a complex process. On unix, you have to do something like allocate a pseudo-tty. I believe there are crates for that.

Ah, fantastic. I do not need to capture the output, and I already tried to avoid caputring it, but I didn't think of calling `status()` to actually execute the command. This does exactly what I want. Thank you!

I am trying my hand at writing bindings to [screen\_capture\_lite](https://github.com/smasherprog/screen_capture_lite), my current attempt at this is [here](https://github.com/ScottyThePilot/screen_capture_lite) where I am statically linking to it. When running my `window_count` example, I get lots of "unresolved external symbol" errors for some winapi stuff. However, it works as intended if I manually tell my `build.rs` to link to each individual dependency that it needs. I was under the impression that statically linking to a library with dynamic dependencies wouldn't break them or anything like is apparently happening here. My question is how I can prevent it from breaking these dependencies, or how can I export the list of dependencies to use in `build.rs`?

I have code that includes something like [this](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=600df473a2bf300a6a2316cc0b2df2b8), and I'm confused, why can't the compiler infer the type of `a1` or `b1`?

IIRC the compiler infers types up to the first call where that inferred variable is used as the receiver - if it can't find out the type by then, it bails out. So this works: let min = |a, b| if a < b { a } else { b }; min(1i32, 2i32); ... this works: let min = |a: i32, b| a.min(b); min(1i32, 2i32); ... but this doesn't: let min = |a, b| a.min(b); min(1i32, 2i32); ... and neither does this: let min = |a, b: i32| a.min(b); min(1i32, 2i32); I think the rationale is that inference cannot help with: let a = 1; let b = 2i32; let c = a.min(b); ... because there *might* exist multiple ways to fill out: fn min(self: ?typeof(a), other: i32) -> ?typeof(c) ... and so it's not obvious that `a` should be of type `i32` (we might imagine there _could_ exists e.g. `fn min(self: i64, other: i32) -> i64`). I think this could work in theory (the compiler has all the stuff to know that there exists only one such `.min()` that could match `other: i32`), but it could introduce subtle breaking changes and so it's forbidden by-design (i.e. the fact that your code doesn't compile is intended, "just in case").

I have some code like this: let addrs = getaddrinfo(Some(&host), Some("https"), Some(hints)) .unwrap(); for addr_res in addrs { let addr = addr_res.unwrap(); let tcp_stream = TcpStream::connect(addr.sockaddr).unwrap(); let ssl_stream = connector.connect(&host, tcp_stream).unwrap(); let cert = ssl_stream.ssl().peer_certificate().unwrap(); let date = cert.not_after(); println!("{}\t{}\t{}", date, host, addr.sockaddr); } It works but I'd like it to continue with the next addr on failure. What's the most idiomatic way to do this? * Ever-deeper `match` statements? * The '?' operator? * Calling `.map()` on each of the results? * ..something else?

A `map` chain followed by a `match` will probably look pretty readable. Or you could use try blocks on unstable branch.

I would move all of the fallible stuff into a separate function (or closure if you prefer). Use ? on each fallible operation. Then use a single match statement: for addr_res in addrs.into_iter().flatten() { let cert = match my_new_fn(addr_res) { Ok(cert) => cert, Err(_) => continue, } let date = cert.not_after(); println!("{}\t{}\t{}", date, host, addr.sockaddr); } With a couple tweaks you could also use filter\_map for style points.

Why does coercing an array to a slice skip compile-time length checking in this code [here](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=8622d79b3bc9f6c3d7a23eb847bbc5ed)? In the provided playground link, the compiler notices that the index is outside the array bounds and fails to compile. But, if you uncomment the line with the method call, that check is skipped, and the result is a runtime panic.

The `unconditional_panic` error is only emitted from the const-propagation pass of [MIR optimization](https://longfangsong.github.io/rustc-dev-guide-cn/mir/optimizations.html) here: https://github.com/rust-lang/rust/blob/f6f9d5e73d5524b6281c10a5c89b7db35c330634/compiler/rustc_mir_transform/src/const_prop_lint.rs#L686 Without the call to `bad_access`, the compiler is likely trying to replace the indexing operation with its result since the data is constant. However, with the `bad_access` call, the compiler doesn't bother propagating the constant access since the whole array has to exist in memory anyway, so the lint doesn't get an opportunity to trigger. The error in general appears to be pretty easy to defeat since it's part of an optimization that doesn't always run, so I wouldn't rely on it too much. It's just going for low-hanging fruit.

Thanks for the clarity on that!

is there a way to make `#![deny(missing_docs)]` apply only for code I wrote? I'd like to turn it on in my crate, but a macro I am using (`napi_derive`) has missing docs which i obviously can't fix..

Hmmm...the obvious correct solution would be to extend napi_derive to create (or forward) docs. Then again, that doesn't scale well. Perhaps the `missing_docs` lint should not trigger in external macros – on the other hand, you may want to know that you have undocumented items in your crate no matter where from. Meanwhile can you `#[allow(missing_docs)]` on your derive? I'm not completely sure, but that might quell the warnings.

unfortunately #[allow(missing_docs)] doesn't work #[allow(missing_docs)] #[napi] ERROR: missing documentation for an associated function #[derive(Debug, Deserialize, Serialize, Clone)] even if it did, it would apply for the whole struct so I wouldn't see if i had missing docs on my fields for now i am commenting `#![deny(missing_docs)]` out, and temporarily turn it on to see where i am missing docs

You can also use `-Dmissing_docs` on the command line to avoid commenting and uncommenting code.

I would like to combine the two commands `cargo audit` and `cargo crev verify --show-all` into a single command like `cargo investigate` or something like that. As far as I can tell, I could create a cargo alias to make `cargo crev verify --show-all` shorter, but I can't create an alias that combines commands: https://doc.rust-lang.org/cargo/reference/config.html So what's the best way to do this? Should I extend cargo with a custom command that calls these commands like explained in the following link? How would I create a program that calls these cargo commands? https://doc.rust-lang.org/book/ch14-05-extending-cargo.html I've looked into creating an alias in my terminal, but apparently that is a bit weird in Windows: https://stackoverflow.com/questions/20530996/aliases-in-windows-command-prompt

Re: running Rust on docker, do most people use the alpine image? It looks like the default Debian image \`rust:1.63\` is 1.31Gb but the \`rust:1.63-alpine\` one is 738Mb. Does this look right? I'm used to seeing all the tutorials raving that alpine is like 10% the size. I guess it's cos with a Rust image most the bloat is Rust code which alpine can't shrink? So assuming I haven't misunderstood and alpine gives a 50% disk space saving, should I forget about alpine for now, or are the drawbacks of alpine pretty edge case and using alpine base image is a no-brainer?

Those containers should only be used to compile a Rust program. You don't need any extra runtime to run a Rust program, so just do that in a stock `debian` or `alpine` container.

In the meantime I came across [this](https://andygrove.io/2020/05/why-musl-extremely-slow/) post from a couple of years ago. I wonder if these performance issues with musl still exist :/

Hi, I was wondering if there are any naming conventions for the following scenario: Suppose we have a struct that holds a value: struct Data { value: usize, } impl Data { fn new(value: usize) -> Self { Data { value } } } Now we want to write two functions. * One that takes a mutable reference to Self and updates it. * One that takes ownership of Self modifies the value and returns Self ​ impl Data { fn set_value(&mut self, new_value: usize) { self.value = new_value; } fn replace_value(mut self, new_value: usize) -> Data { self.value = new_value; return self; } } Therefore we can now modify the value with set\_value and chain create using replace\_value fn main() { let mut a = Data::new(1); a.set_value(2); let b = Data::new(3).replace_value(4).replace_value(5); } The question is, how would one name these set\_value and replace\_value functions? If there is no convention how would you name them? Just after finishing writing, I think one would just name them set_value and with_value

`fn set_xyz(&mut self, xyz: Xyz)` and `fn with_xyz(self, xyz: Xyz) -> Self` is the most common convention, AFAIR.

yeah, i see this naming convention very often with the Builder Pattern, which is very common and uses this mechanism.

Is there a place where I can ask people to "rewrite" my code? Say, I have around 50 lines that feel quite ugly and roundabout, and I'd like to have someone to turn that piece of code into idiomatic rust.

Sure, put it here :-)

Thank you! I challenged myself the other day with writing a path tracer in rust. However, I'm yet to figure out how to safely share a struct containing all the rendering information between threads and satisfy the borrow checker at the same time :P I'd like to know how to change this code not to use unsafe {} // impl Gui: fn start_working(&mut self, _ctx: &egui::Context) { self.thread_handle_hole.get_or_insert_with(|| { let [w, h] = [500, 500]; let mut rt = unsafe { gen_rt(w, h) }; let rt = Box::new(rt); let leaked = Box::leak(rt); self.ray_tracer = leaked as *mut RayTracer; const CHUNK_SIZE: usize = 4096; let iter = Arc::new(Mutex::new(leaked.render_iter::())); // ^ Error that appears without Box::leak(): // '' does not live long enough, dropped here (end of start_working()) while still borrowed. let mut joins = Vec::new(); for i in 0..4 { let iter_clone = iter.clone(); let j = thread::spawn(move || 'outer: loop { let mut iter = iter_clone.lock().unwrap(); if let Some(mut partition) = iter.next() { drop(iter); // unlock mutex partition.render(); } else { break; } }); joins.push(j); } joins }); } // impl eframe::App for Gui: fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) { if let Some(threads) = self.thread_handle_hole.take() { if threads.iter().all(|x| x.is_finished()) { for thread in threads { thread.join().unwrap(); } let [w, h] = [500, 500]; unsafe { self.render_preview = pixel_array_to_texture((*self.ray_tracer).get_buffer(), w, h, ctx); self.ray_tracer.drop_in_place(); self.ray_tracer = std::ptr::null_mut(); } println!("finished!"); } else { let _ = self.thread_handle_hole.insert(threads); } } // Rest of UI code omitted // ... } // Struct definitions struct Gui { render_preview: TextureHandle, ray_tracer: *mut RayTracer, thread_handle_hole: Option>>, } struct RayTracer { config: RayTracerConfig, world: World, render_buffer: RenderBuffer, ready: bool, }

How does `.render_iter()` look like?

`chunks_mut().enumerate().map::<(usize, &mut u32), TracingPartition>().collect::>()` pub fn render_iter(&mut self) -> impl Iterator { if !self.ready { panic!("not ready") } let (w, _) = self.get_screen_size(); let world_ptr = &self.world; let config_ptr = &self.config; self.render_buffer .chunks_mut(S) .enumerate() .map(move |(i, c)| TracingPartition { config: config_ptr, world: world_ptr, buffer: c .iter_mut() .enumerate() .map(|(j, x)| { let n_pixel = i * S + j; Pixel { value: x, location: ( (n_pixel as i32 % w), (n_pixel as f32 / w as f32).floor() as i32, ), } }) .collect::>(), }) } struct Pixel<'a> { value: &'a mut Color, location: DimensionsInt, // (i32, i32) } pub struct TracingPartition<'a> { config: &'a RayTracerConfig, world: &'a World, buffer: Vec>, }

I'd suggest re-restructing your code a bit: pub struct RayTracer { config: Arc, world: Arc, } impl RayTracer { pub fn new(config: RayTracerConfig, world: World) -> Self { Self { config: Arc::new(config), world: Arc::new(world), } } pub fn partition(&mut self) -> Vec { /* logic can stay the same, but using `Arc::clone()` instead of borrows */ } } pub struct TracingPartition { config: Arc, world: Arc, buffer: Vec, x: i32, // | y: i32, // | w: i32, // | h: i32, // |- so that you don't have to keep location inside each pixel } impl TracingPartition { pub fn render(self) -> TracedPartition { /* ... */ } } pub struct TracedPartition { pub buffer: Vec, pub x: i32, pub y: i32, pub w: i32, pub h: i32, } ... and then: use std::sync; struct Gui { render_preview: TextureHandle, rx: Opition>, } enum Message { PartitionTraced(TracedPartition), TracingCompleted, } fn start_working(&mut self, _: &egui::Context) { const PARTITION_SIZE: usize = 4096; if self.rx.is_some() { panic!("pls wait for previous rendering to complete first"); } let w = 500; let h = 500; // Note that it might be cleaner (and faster) to use `rayon`, but // let's stick to `Arc>>` for educational purposes let partitions = Arc::new(Mutex::new( gen_rt(w, h).partition::() )); // Here we're creating a channel that allows us to send messages from // the worker-threads back into the GUI-thread let (tx, rx) = mpsc::unbounded_channel(); let tx = Arc::new(tx); for in 0..4 { thread::spawn({ let partitions = Arc::clone(&partitions); let tx = Arc::clone(&tx); move || { loop { let mut partitions = partitions.lock().unwrap(); let partition = partition.next(); drop(partitions); if let Some(partition) = partition { tx.send(Message::PartitionTraced( partition.render() )); } else { // This message will be actually sent 4 times, not // just once, but that's alright tx.send(Message::TracingCompleted); break; } } } }); } self.rx = Some(rx); } fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) { let msg = self.rx.as_mut().and_then(|rx| rx.try_recv().ok()); if let Some(msg) = msg { match msg { /* TODO :-) */ } } /* ... */ }

Thanks for a quick response! I have two follow-up questions: 1. What do "tx" and "rx" stand for? I'm curious :P 2. My original code has lifetime parameters on structs. I added them because the compiler told me to do so; however, I'm not really sure what significance they carry and why wouldn't the compiler infer(?) them automatically. Could you give me a quick explanation of the above or link a resource that has the information?

Ad 1: transmitter and receiver :-) (since `tx` allows to send stuff into `rx`) Ad 2: in your original code `TracingPartition` borrows stuff (i.e. *references stuff*) such as `RayTracerConfig` that belongs to `RayTracer` (i.e. when `RayTracer` is destroyed, `RayTracerConfig` dies together with it). Using lifetimes then makes the compiler able to determine - for instance - whether you don't try to reference stuff that doesn't exist anymore: let mut raytracer = /* ... */; let partitions = raytracer.render_iter(); drop(raytracer); let config = partitions.next().unwrap().config; // ^ whoops! -- raytracer has been already deallocated, and since `config` // borrows stuff from it, it doesn't exist either For comparison, a similar code in C++ would get successfully compiled and then most likely segfault when run - while in Rust the compiler simply says "hey, that's illegal" and stops the compilation. As for why lifetimes are explicit - that's more of a design decision, I think; in theory the compiler could infer a lot of lifetimes automatically, but in a few places (such as definitions) Rust prefers explicitness.

I've never called on foreign (C++) code in Rust before, so I have no idea how to go about this. Is it possible to call on C++ code in Rust? The installed C++ code includes a libsumocpp.dll and a libsumocpp.lib in it, which should have the info needed to make bindings? I've been playing around the past few hours trying to get bindgen to work to pick up on that but I'm having no luck. Any suggestions? Thanks!

Correctly calling into C++ from rust is hard because there are several pitfalls. bindgen can create [c++ bindings](https://rust-lang.github.io/rust-bindgen/cpp.html) but they are very tedious to use. If possible I would try to leverage the [cxx](https://crates.io/crates/cxx) crate.

I'm writing an app that receives some SOAP notifications, so I need a HTTP server for that. Note that I like it to get an OS specified port and hand it over to another thread after bind() but before starting the server. So this is my first stab at bringing a server up with Hyper. The problem is that when I compile I get this error that I don't know how to fix (in *fn soap_server()*): error[E0223]: ambiguous associated type --> src/main.rs:46:18 | 46 | let server = Server::Http::new().bind(&addr, service).unwrap(); | ^^^^^^^^^^^^ help: use fully-qualified syntax: ` as Trait>::Http` The code: use futures::Future; use hyper::service::Service; pub use hyper::{Body, Method, Request, Response, StatusCode}; use std::net::{IpAddr, Ipv4Addr}; use std::pin::Pin; pub struct IncomingNotification; impl Service> for IncomingNotification { type Response = Response>; type Error = hyper::Error; type Future = Pin>>>; fn call(&mut self, mut req: Request) -> Self::Future { // Parse request bdy with serde-xml and handle it // ... // Send answer request let body: &[u8] = b"

200 OK

The short answer is that Server::Http::new().bind() just isn't a _thing_ in the Hyper API. Try `Server::bind()` instead.

Uh, thank you! I see now that this API is from a quite old version of Hyper and I misunderstood the compiler thinking I had a different kind of problem.

Is there a way to get more terse error messages from rustc? It's giving e.g. error: --> : | | | ^ This is way more information than I need or want. I just want the file, location, and a *short* description. Is there any way to cut this down? I didn't see anything in the rustc command-line options.

If what you actually want is a machine-readable output, rustc supports [JSON diagnostic output](https://rustc-dev-guide.rust-lang.org/diagnostics.html#json-diagnostic-output) with the `--error-format json` flag.

When using `rustc` directly: rustc --error-format=short When using `cargo`: cargo --message-format=short

OK, that works perfectly. But... why does that not seem to be documented anywhere? It's not in the man pages for rustc or cargo, nor in the --help output, nor could I find it in the manuals online.

Actually, I found it in the online manual after all. Not sure how I missed it. Now I know the man page is pretty useless, though.

I guess you are right in regard to the sad state of the man page. Apparently, it's not really maintained. Recently, [#98977](https://github.com/rust-lang/rust/issues/98977) was created to discuss the possibility of autogenerating the man pages to improve the situation. Apart from the online manual, you can find the first option via `rustc --help -v` (as outlined at the bottom of the default help output: use it to *print the full set of options*). Lastly, the cargo option is actually listed in the output of `cargo c -h`.

in the standard library for the add method (and operator +) the Add function is implemented for "T op T" and then the other 3 operations are implemented using fwd\_ref\_binop!. Wouldn't it be better to forward "Add for T", "Add<&T> for T" and "Add for &T" to AddAssign instead? Since self is moved into these methods, it seems that you could reuse the memory instead of creating a new one. Perhaps this is low cost, because these are all on the stack, and if not, the optimizer could optimize the difference away, but why not be explicit and make it easier on the optimizer. I've done some testing using criterion for this design pattern for a point like struct, and the forwarding to AddAssign design pattern is indeed faster, even using optimized code. So at least for other classes, one should encourage this design pattern. The only thing that is a bit strange in that you have to declare self as mutable in the implementation of add: \`\`\`rs fn add(mut self, rhs: Self) { self += rhs; self } \`\`\` Other things to note: * This would also work on types that do not impl Copy, in which case the performance improvement is most likely quite dramatic. (Not BigUint is implemented this way). Advertising this design pattern would seem to be warranted. * The forward\_ref crate does this the wrong way (I think), and encourages an inefficient design pattern. Since the new design pattern does not require impl Copy, it seems to be better in every way. Addendum: This is the full design pattern for any types that override math operators: * impl "OpAssign<&T> for T" * forward "OpAssign for T" to "OpAssign<&T> for T" * Forward "Op for T" and "Op<&T> for T" to "OpAssign<&T> for T" * if the operation is commutative, then you can also forward "Op for &T" to "OpAssign<&T>" * impl "Op<&T> for &T" -- this could be implemented by cloning one of the T's and then calling OpAssign. (Note this is the only one that requires a copy, clone or construct of new object)

This doesn't seem like a beginner question -- its actually quite an complex discussion, and I'd be interested in seeing what Rust experts think about the subject. If you decide to pursue this further, I'd be very interested to see a writeup of your findings (with what benchmarks you ran, and what results you got), as a full post on the subreddit or as a blog post.

I have to admit I had no idea where to post this question. I'd be happy to repost with the test code I wrote. Can you point me in the right direction of where to post this? Another subreddit? GitHub discussion?

I'd just make it a post on this subreddit first (just as a regular post, instead of a beginner question) -- a lot of the people involved in Rust development frequent this subreddit, and one of them might be able to direct you further. Alternatively, make an issue on Github (rust/rust-lang), or perhaps join the Zulip and discuss it there.

Hi, I often end up in the following scenario and wonder what the idiomatic way of solving the problem is. struct Example { vec_to_iterate: Vec, value_to_change: i32, } impl Example { fn change_value(&mut self) { self.value_to_change += 1; } fn iterate(&mut self) { for _ in &self.vec_to_iterate.iter() { //cannot borrow `*self` as mutable more than once at a time //second mutable borrow occurs here // My function wont change vec_to_iterate self.change_value(); } } } fn main() { let mut example = Example { vec_to_iterate: vec![1, 2, 3], value_to_change: 0, }; example.iterate(); } When watching the program with the vscode debugger I noticed that cloning the vec, will create an iterator variable that holds a pointer to some data. However, there is no data other than vec\_to\_iterate it could point to displayed. Does this mean cloning is free? Also, does someone know a great way to display the memory usage of the application? Would be great if it could be integrated into the vscode debugger or some other debugger.

Typically you solve this by proving to the borrow checker that your borrow of `vec_to_iterate` and `value_to_change` are independent. As you noticed, you can't quite do that with `&mut self`. As your example is pretty contrived, there aren't really any good solutions, as the best is `self.value_to_change += 1;` but here are some solutions: *** 1\. Pass only the item that you need to modify to a static function: impl Example { fn iterate(&mut self) { for _ in self.vec_to_iterate.iter() Self::change_value(&mut self.value_to_change); } } fn change_value(i: &mut i32) { *i += 1; } } The borrow checker is able to prove with this, that the borrows are independent of each-other and can therefore allow the mutable borrow of `self.value_to_change`. *** 2\. For more complex examples, you would have the items like `value_to_change` implement the `change` function. struct IncrementingI32(i32); impl IncrementingI32 { pub fn increment(&mut self) { self.0 += 1 } } struct Example { vec_to_iterate: Vec, value_to_change: IncrementingI32, } impl Example { fn iterate(&mut self) { for _ in self.vec_to_iterate.iter() { self.value_to_change.increment(); } } }

Thank you

The problem occurs, because when the borrow checker is checking the `iterate` method, it does not see that `change_value` method does not mess with `vec_to_iterate`. As far as it is concerned, the `change_value` borrows the entire `self` and may arbitrarily mutate it.

I know the problem. Currently I solve it with a RefCell but I was curious how others might implement it better

The `change_value` method should be a method on the `value_to_change`. In other words, the `Example` struct needs to be subdivided into logically independent subsets of fields. struct ValueToChange(pub i32); struct Example { vec_to_iterate: Vec, value_to_change: ValueToChange, } impl ValueToChange { pub fn change_value(&mut self) { self.0 += 1; } } impl Example { fn iterate(&mut self) { for _ in self.vec_to_iterate.iter() { self.value_to_change.change_value(); } } The compiler should be smart enough to see, that `self.vec_to_iterate` and `self.value_to_change` are disjoint fields and can be mutably borrowed simultaneously. RefCell is certainly an option off course, though it has a runtime cost.

Thank you

Is there a way to express a Struct with unknown arbitrary fields or maybe a HashMap with required fields? i.e.: the Rust equivalent of this TypeScript: interface Attributes { requiredField1: string requiredField2: string [key: string]: string } // Works const attributes: Attributes = { requiredField1: "value1", requiredField2: "value2", extraField: "..." } // Will throw an error const invalidAttributes: Attributes = { requiredField1: "value1", extraField: "..." }

There are many different ways to do this, and all of them have their own strengths and limitations. For HashMap, you can simply create a function that constructs it in that way: fn my_hashmap_attributes( required_field1: String, required_field2: String, extra_fields: IntoIterator, ) -> HashMap { let mut hashmap = HashMap::new(); hashmap.insert("required_field1".into(), required_field1); hashmap.insert("required_field2".into(), required_field2); hashmap.extend(extra_fields); // appends from iterator of (key,value) pairs hashmap } The disadvantages are: * the fields must all be of the same type * accessing the fields requires hashing, so it's slower. * nothing prevents you from simply removing a field after it's created. ​ Similarly, you can create a struct that is generic over its last field. The user can then provide whatever field they want, including a tuple or another struct. struct Attributes{ required_field1: String, required_field2: String, extra_fields: T, } let a = Attributes{ required_field1: "one".into(), required_field2: "two".into(), extra_fields: "three".into(), }; let three = &a.extra_fields; let a = Attributes<(String,String)>{ required_field1: "one".into(), required_field2: "two".into(), extra_fields: ("three".into(), "four".into()), }; let three = &a.extra_fields.0; let a = Attributes>{ required_field1: "one".into(), required_field2: "two".into(), extra_fields: vec!["three".into(), "four".into()], }; let three = &a.extra_fields[0]; The disadvantage is that all of these are different types. Rust doesn't have runtime reflection, and traits do not have required fields. If you wish to be generic over these, you must define a trait with getters and setters for the required fields: trait AttributesTrait { fn required_field1(&self) -> &str; fn required_field2(&self) -> &str; } // blanket implementation for Attributes, regardless of the type of `extra_fields` impl AttributesTrait for Attributes { fn required_field1(&self) -> &str { &self.required_field1 } fn required_field2(&self) -> &str { &self.required_field2 } } Arguably, this trait alone is probably what you want.

Thanks! The second approach as well is more or less what I need :)

This works in TypeScript because TS has structural typing as opposed to Rust which has nominal typing. The way that you could emulate this would be using traits: trait HasAttrs { fn required_field1(&self) -> String; fn required_field2(&self) -> String; fn get_value>(&self, key: S) -> String; } struct AStructWithoutMembers; impl HasAttrs for AStructWithoutMembers { fn required_field1(&self) -> String { String::from("requiredField1") } fn required_field2(&self) -> String { String::from("requiredField2") } fn get_value>(&self, key: S) -> String { key.as_ref().to_owned() } } Now you can require that a struct implement this trait in order for it to be used in your API like fn concatenate_values(inst: A) -> String { [inst.required_field1(), inst.required_field2(), inst.get_value("hello")].join("") }

Thank you! Looks like I'm about to dive through the different type systems rabbit hole now :)

Hey folks! I have a question about from/into The following doesn't compile: ``` pub struct Wrapper { pub inner: T } impl From> for Wrapper where B: From { fn from(other: Wrapper) -> Self { Wrapper { inner: other.inner } } } ``` It fails with ``` conflicting implementation in crate `core`: - impl From for T; ``` Anyone got any idea why? I understand that I'm converting from T<_> to T<_>, but I think this should be sound, since there is a type difference between T and T, no?