In rust, tests are written in the same file as the code. But I want to have the tests in a separate file.

Conventionally, only the integration tests are written in files under tests folder. ¹

I just wanted to have the unit tests in a separate file. So I created a file src/my_tests.rs and moved all the tests there.

But cargo test kept saying running 0 tests

Turns out, I’m not the only one. ²

In rust, str is a primitive type, but many non-primitive types are also in scope by default.

e.g. We do not need to add use statement to use Vec - which is NOT a primitive type.

It comes from std::vec

So Vec::new() is really std::vec::Vec::new()

Vec::new() works because Rust inserts this at the beginning of every module:

use std::prelude::v1::*;

This makes Vec (and String, Option and Result) available by default.

When I published my previous post on mastodon, Sebastian pointed out ¹ that using #[cfg] is better than cfg! macro.

Documentation explains that :

cfg!, unlike #[cfg], does not remove any code and only evaluates to true or false. For example, all blocks in an if/else expression need to be valid when cfg! is used for the condition, regardless of what cfg! is evaluating.

Thanks, Sebastian!

We all know we shouldn’t use print debugging, and yet we all do 😉 ¹

Jokes apart, when I’m still developing the code, I use the debugger where possible. But sometimes, I want to keep certain print statements to verify runtime behaviour, especially when rolling out new feature and when there are too many variations (some of them unknown) in incoming data.

I’m aware, logging is the right way to handle this (with loglevel set to debug or something), but it seems too much when developing toy projects.

At first, I assumed since we’ve declared the capacity upfront, it would be maximum capacity of the Vec

Turns out, since Vec is expected to shrink and grow, as needed, there is no maximum capacity for Vec

It just ensures that “sufficient” memory is allocated to the Vec, such that memory reallocation is not required.

On the other hand, if you need more that what you declared with with_capacity, you will get it, but there will need to be reallocation (of memory), so it will be inefficient.

Today I learnt that certain rust code can be marked such that it is compiled only for specific platform.

This makes sense for low level libraries that provide platform-specific functionality that is not available on other platforms.

This is achieved by tagging the function with #[cfg(target_os = "xyz")]

Here xyz can be one of the following :

• “windows”
• “macos”
• “ios”
• “linux”
• “android”
• “freebsd”
• “dragonfly”
• “openbsd”
• “netbsd”

Similar to target_os, here are other options :

At least for floating point numbers, it does not crash/panic! 🤷‍♂

fn main() {
    let x = 10.0;
    let y = 0.0;
    println!("{:?}", x/y);
}

This above code returns inf

But if we change the number to int, compiler catches this ¹ at shows the following error:

error: this operation will panic at runtime

One of the strength of Rust is memory management. This also leads to compiler errors related to move or borrow When we assign an existing variable to new variable, two things can happen.

Either the data is copied - in that case we can use both old and the new variable without worry. ¹

Or data is moved - now we can only use the new variable, as the old variable is “out of scope”. But there is a way to access both the new and old variables. But in that case we have to explicit.

As I am setting up my new machine, I came across this error when emacs tried to use rust-analyzer

error: Unknown binary 'rust-analyzer' in official toolchain 'stable-x86_64-apple-darwin'.

As mentioned in this SO question, which rust-analyzer did not show any error.¹

Luckily, the same SO question also had the solution

I needed to explicitly install it via rustup component add rust-analyzer

When refactoring code to make API call to Gemini, I learnt how to format raw strings in rust.

fn main() {
    let var1 = "test1";
    let formatted = format!(r#"var1 is: {}"#, var1);
    println!("{}", formatted);
}

This gives output as : var1 is: test1

If you want { in the output, then it needs to be escaped with additional { like:

fn main() {
    let var1 = "test1";
    let formatted = format!(r#"{{contents: {}}}"#, var1);
    println!("{}", formatted);
}

This gives output as : {contents: test1}