Unwrap | Learn Swift interactively on your iPhone | iOS library

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.

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:

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:

So the reason for the error message is that instance is a local variable in your instantiate function. Because you aren't moving its ownership to the return value, it will be dropped at the end of the function.

But then if it gets dropped, any reference to it would be invalid. That's why Rust doesn't let you return something holding a reference to the local variable.

First, your struct is redundant, because PhysicalDevice already holds a reference for the instance. Even without the local variable problem, I think you'd run into an ownership problem.

Second, let's say you rewrite and get rid of your InstanceInfo struct and instead you want to just return a PhysicalDevice<'static>. Well if that's what you promise to the compiler, then you have to make sure that the instance you create will live for as long as the program lives.

You can do that either by having instance be a static variable of your module, or by creating it at the very beginning of the program and then simply pass a reference ot it around.

For example

This has been resolved. See above for the solution. It is marked with a header saying solution.

urls is actually of type [String: URL?]. Note that the value type is optional, because URL.init(string:) is failable.

When you try to get a value from this dictionary, you get a URL??. The guard only unwraps one layer of the optional.

One way to unwrap a nested optional (no matter how many layers), is to use as?:

I am compiling with: g++ -lblas -llapack -llapacke -I /usr/include main.cpp

That command line is wrong. Do this instead:

The thing the compiler is looking for is a lifetime bound. A lifetime bound of 'a doesn't mean “this type is a reference with lifetime 'a”, but rather “all of the references this type contains have lifetimes of at least 'a”.

(When a lifetime bound is written explicitly, it looks like where T: 'a.)

Thus, any type which does not contain any references (or rather, has no lifetime parameters) automatically satisfies the 'static lifetime bound. If T: 'static, then Arc: 'static (and the same for Box and Rc).

How could Arc::clone(&msg) get a 'static lifetime? The value it points to isn't known at compile-time, and could die before the whole program exits.

It does not point to the value using a reference, so it's fine. The type of your value is Arc>; there are no lifetime parameters here because there are no references. If it were, hypothetically, Arc<'a, Mutex> (a lifetime parameter which Arc doesn't actually have), then that type would not satisfy the bound.

The job of Arc (or Rc or Box) is to own the value it points to. Ownership is not a reference and thus not subject to lifetimes.

However, if you had the type Arc<&'a str>> then that would not satisfy the bound, because it contains a reference which is not 'static.

1- Try changing