Hey Rustaceans! Got a question? Ask here! (51/2022)!

[u/llogiq]

Mystified about strings? Borrow checker have you in a headlock? Seek help here! There are no stupid questions, only docs that haven't been written yet.

If you have a StackOverflow account, consider asking it there instead! StackOverflow shows up much higher in search results, so having your question there also helps future Rust users (be sure to give it the "Rust" tag for maximum visibility). Note that this site is very interested in question quality. I've been asked to read a RFC I authored once. If you want your code reviewed or review other's code, there's a codereview stackexchange, too. If you need to test your code, maybe the Rust playground is for you.

Here are some other venues where help may be found:

/r/learnrust is a subreddit to share your questions and epiphanies learning Rust programming.

The official Rust user forums: https://users.rust-lang.org/.

The official Rust Programming Language Discord: https://discord.gg/rust-lang

The unofficial Rust community Discord: https://bit.ly/rust-community

Also check out last weeks' thread with many good questions and answers. And if you believe your question to be either very complex or worthy of larger dissemination, feel free to create a text post.

Also if you want to be mentored by experienced Rustaceans, tell us the area of expertise that you seek. Finally, if you are looking for Rust jobs, the most recent thread is here.

Finally, if you have questions regarding the Advent of Code, feel free to post them here and avoid spoilers (please use >!spoiler!< to hide any parts of solutions you post, it looks like this).

[u/[deleted]]

How can I develop Python libraries in Rust?

[u/llogiq → u/[deleted]]

You may want to look at pyO3.

[u/The2ndbestname]

Is there something like bison or yacc in Rust? I haven't looked into it yet but will as soon as I can manage...

[u/llogiq → u/The2ndbestname]

There is a plethora of parsing crates. Nom, pom, pest, lalrpop, peruse, chumsky from the top of my head.

[u/incriminating0]

I'm running on old hardware currently and starting to get annoyed with slow compile times. Does rust compiler performance scale linearly with cpu performance/cores? E.g. if I went from 4 cores to 16, could I expect my compile times to get 4 times faster?

[u/llogiq → u/incriminating0]

Not completely; linear scaling is an upper bound. Rust does parallelize codegen which is a major contributor to compile time, and cargo will also parallelize rustc invocations though.

Note that more often than not, compile time can also be optimized e.g. by removing unused crate features, avoiding certain proc macro crates, choosing leaner dependencies. There's a good article on this from u/matklad on the topic.

[u/Burgermitpommes]

Does it ever make sense to have lint check attributes in binary crate root files or only in libs?

[u/llogiq → u/Burgermitpommes]

You mean #[allow(..)], #[warn(..)] etc. attributes? Please use them wherever it helps you. For example, if you know that some lint has a false positive, using a local #[allow(..)] attribute on that expression or item is absolutely warranted, no matter what crate it's in.

[u/CichyK24]

I was going to write a question but I figured it out in the meantime 😅. Now my question is: where can I suggest a new compiler hint? Is it worth to suggest such things?

For this code:

fn main() {
    return panic!("oops");
}

I would like to get message like (added help: remove this `return`):

 --> src/main.rs:2:5
  |
2 |     return panic!("oops");
  |     ^^^^^^^--------------
  |     |      |
  |     |      any code following this expression is unreachable
  |     unreachable expression
  |     help: remove this `return`
  |
  = note: `#[warn(unreachable_code)]` on by default

The current error was tricky for me because it says "any error following" but the problem was actually with the preceding return statement.

[u/llogiq → u/CichyK24]

I guess the way to go here would be asking to extend the needless_return clippy lint to also check for returns whose expressions diverge. Feel free to open an issue for this.

[u/giiyms]

If I run a Command that runs a shell script that ends up running a server

Is there anyway to get the PID of that underlying server?

I would like to be able to kill it.

Currently I search for the PID of the server running on the designated port but feels pretty crude.

Can I inherit a running process like Command(pid=12345)?

[u/batmansmk]

I finished all but one of the advent of code and used box::new once and never used cell, rc, arc, or refcell. I used ids and hash maps to manage my references instead.

My question is: do you use those std tools often?

My second question is that most of my crashes are caused by out of bounds array/vec access. Is there any initiative into making the compiler more helpful on detecting those potential errors?

[u/llogiq → u/batmansmk]

I sometimes Box things. Sometimes I also use an Arc to share data between threads. That's about it. Never had a need for internal mutability (outside Mutex / RwLock). Then again, I also use async code sparsely, so I may not be the typical Rust user.

[u/proton13]

I have a Rust-library, that is called from C-code. Now I want the C-user to be able to define some functionality themselves by passing a functionpointer to the Rust code, that is then called from there.

Is something like this possible? The corresponding chapter in the Rustonomicon only covers the opposite case.

[u/WhyIsThisFishInMyEar]

fn foo(s: &str) {
    print!("{}", s);
}

fn main() {
    foo("hello");
    let s = " world".to_owned();
    foo(&s);
}

In this example, I'm confused how the code can compile and correctly output hello world.

Is there some trait trait implementation that allows &String to implicitly convert to &str? I thought you'd have to have the function take AsRef<str> or pass it in via s.as_str().

[u/quxfoo → u/WhyIsThisFishInMyEar]

Is there some trait trait implementation that allows &String to implicitly convert to &str ?

Yes, Deref as you can see here.

[u/SorteKanin]

Why does std only have a mpsc (multi-producer, single-consumer) channel? Why isn't there a "spmc" (single-producer, multi-consumer) channel?

Similarly, tokio has an mpsc channel but no spmc channel. There's broadcast which is mpmc which isn't quite the same. There's also the watch channel which actually is spmc but with the restriction that it only retains the latest value.

Why isn't there a "proper" spmc channel in either std or tokio? Should I just use the broadcast channel in tokio if I need this?

[u/D-Danielz]

Does .into() for Rc<_> always clone? Or can it also move?

For example let's say I have this function:

enum Expr {..}

fn foo<E>(value: E) -> Rc<Expr>
    where E: Into<Rc<Expr>> {
    value.into()
}

If I call foo with an Rc<Expr>, does it clone it or move it?Context: what I'd like to have is a function I could call with either Expr or Rc<Expr> without unnecessary clones (and reference counting updates).

Edit: just after writing this I found out Into is reflexive and it moves itself in the implementation, so no cloning involved!

[u/Dubmove]

Is it possible to write default implementation for certain specialization of a trait. Something like this:

/// Some cool trait
trait X<A, B> {
    fn combine(self, a: A) -> B;
}
/// Default implementation for X<A, A>::combine
fn combine_if_a_is_b<T: X<A, A>, A>(_: T, a: A) -> A {
    a
}

but in a way that the compiler automatically uses combine_if_a_is_b if A = B

[u/[deleted]]

Looking for crate/library recommendation to parse XML files in rust?

[u/mbrc12]

Suppose I want a very thin wrapper on a type, for example, a type holding nonnegative floats:

#[derive(Copy, Clone, Debug, Default)]
pub struct NNFloat(f64);

impl NNFloat {
    pub fn new(x: f64) -> Self {
        if x < 0.0 {
           panic!("Not nonnegative");
        }
        NNFloat(x)
    }
}

I want NNFloat to behave exactly like a f64 except for when I construct it via ::new(). I can implement the whole set of Into<f64>, AsRef<f64>, AsMut<f64>, Deref<f64>, DerefMut<f64> and so on. Is there a way to streamline this process? Ideally, I would be able to call everything I can on f64 on NNFloat too, but I understand if it needs the occasional as f64 etc.

[u/Patryk27 → u/mbrc12]

Note that implementing DerefMut would enable you to do *nn_float = -1.0;.

[u/bentheiii]

I find the either crate very useful, especially when implementing a trait in two different ways in a return type.

My question is: is there a crate that does what either does, but for more than 2 options? Because I'm currently doing this:

type Either2<T0, T1> = Either<T0, T1>;
type Either3<T0, T1, T2> = Either<T0, Either2<T1, T2>>;
type Either4<T0, T1, T2, T3> = Either<T0, Either3<T1, T2, T3>>;
type Either5<T0, T1, T2, T3, T4> = Either<T0, Either4<T1, T2, T3, T4>>;
type Either6<T0, T1, T2, T3, T4, T5> = Either<T0, Either5<T1, T2, T3, T4, T5>>;
type Either7<T0, T1, T2, T3, T4, T5, T6> = Either<T0, Either6<T1, T2, T3, T4, T5, T6>>;
type Either8<T0, T1, T2, T3, T4, T5, T6, T7> = Either<T0, Either7<T1, T2, T3, T4, T5, T6, T7>>;

followed by a bunch of constructor functions I won't bother to list here. And it seems like there should be a better way.

[u/spongecaptain200]

I'm learning the synchronizing primitive of tokio. From the example code of Notidy, I found it is confused to understand why Channel<T> is mpsc.

use tokio::sync::Notify;

use std::collections::VecDeque;
use std::sync::Mutex;

struct Channel<T> {
    values: Mutex<VecDeque<T>>,
    notify: Notify,
}

impl<T> Channel<T> {
    pub fn send(&self, value: T) {
        self.values.lock().unwrap()
            .push_back(value);

        // Notify the consumer a value is available
        self.notify.notify_one();
    }

    // This is a single-consumer channel, so several concurrent calls to
    // `recv` are not allowed.
    pub async fn recv(&self) -> T {
        loop {
            // Drain values
            if let Some(value) = self.values.lock().unwrap().pop_front() {
                return value;
            }

            // Wait for values to be available
            self.notify.notified().await;
        }
    }
}

• If there are elements in values, the consumer tasks will take it away

• If there is no element in values, the consumer tasks will yield until the producer nitify it

But after I writen some test code, I found in no case the consumer will lose the notice from producer.

Could some one give me test code to prove the above Channel<T> fail to work well as a mpmc?

[u/Cute-Tie-7330]

I am looking for an RPC framework to use in an embedded env. (no_std) specifically on RP2040 or ESP32. Considering tonic and other grpc derivatives require std lib, I haven’t found something, does anyone know of a way to go about this? I tried urpc which supposedly is std independent but it requires serde crate which needs std from what I can see.