Rust | A directory of programs and algorithms written in Rust

You are not measuring the elapsed time correctly:

1. total_send_time measures the duration of the spawn() call, but as the actual task is executed asynchronously, start_in.elapsed() does not give you any information about how much time the task actually takes.

2. The ran in time, as measured by start.elapsed() is also not useful at all. As you are using blocking sleep operation, you are just measuring how much time your app has spent in the std::thread::sleep()

3. Last but not least, your time_to_sleep calculation is completely incorrect, because of the issue mentioned in point 1.

i think you are looking for this:

Basically, the problem at hand is that rodio::Decoder::new consumes the value which it reads from (well, actually it is already consumed by BufReader::new). So, if you have a loop or a closure that can be called multiple times, you have to come up with a fresh value each time. This what File::open does in your first code snipped.

In your second code snipped, you only create a File once, and then try to consume it multiple times, which Rust's ownership concept prevents you from doing.

Also notice, that using reference is sadly not really an option with rodio since the decoders must be 'static (see for instance the Sink::append trait bound on S).

If you think your file system is a bit slow, and you want to optimize this, then you might actually want to read the entire file up-front (which File::open doesn't do). Doing this should also provide you with a buffer (e.g. a Vec) that you can clone, and thus allows to repeatedly create fresh values that can be consumed by the Decoder. Here is an example doing this:

Your immediate issue is that T: GarbageBin<'a, 'b> where 'a and 'b are parameters of create_bin_with_rubbish and must therefore outlive calls to that function—but the actual lifetimes passed to T::new are only internal to the function and do not therefore satisfy those bounds.

Instead of parameterising create_bin_with_rubbish with lifetimes 'a and 'b, one way to resolve this would be to use instead an HRTB (higher-ranked trait bound):

First of all, you don't need exactly IntoIterator bound here. It's just enough for Iterator.

This is not possible. The reason is that converting a Unicode String to lowercase/uppercase may need to reallocate the String, as case folding within Unicode might need more/fewer characters and/or bytes to encode the folded variant.

Either you can return a Vec, where the new String holds the conversion. Or, if you are sure that your input is pure ASCII, you take use make_ascii_lowercase to do the conversion in-place; this has the downside that if proper Unicode folding requires more/less characters/bytes, no folding takes place.

In the first case:

Redis doesn't define structured serialization formats. It mostly store strings and integers. So you have to choose or define your format for your struct.

A popular one is JSON, as you noticed, but if you just want to (de)serialize simple pairs of (id, description), it's not very readable nor convenient.

In such a case, you can define your own format, for example the id and the description with a dash in between:

If you plan to write a lot of WASM in Go, you might want to consider compiling with TinyGo, which is a Go compiler for embedded and WASM.

TinyGo supports a //export or alias //go:export comment directive that does what you're looking for.

I'm copy-pasting the very first example from TinyGo WASM docs: