In this article, we are taking a look at one more, very important data structure that we are going to need for more advanced algorithms. After we compare both Dictionaries (Python) and Hash Maps (Rust), we will implement a DNA reverse_complement function.

Part 1: Dictionary and a Hash Map

Let’s create two new files called data_structures in each folder (Python/Rust), and add an empty functions:

For Python, we create a function dicts() and for Rust, we have _hash_maps() as that is what those data structures are called.

Let’s start by taking a quick look at Python Dictionary, so we have a reference point for our Rust Hash Map version.

def dicts():
    test_dict = {}
    test_dict['Key_1'] = 'Value_1'
    test_dict['Key_2'] = 'Value_2'
    test_dict['Key_3'] = ['Value_1', 'Value_2']

    print(test_dict['Key_1'])

    if test_dict['Key_3']:
        print(test_dict['Key_3'])
        print(test_dict['Key_3'][1])

    for key, value in test_dict.items():
        print(key, value)

This is very easy, right? On the line 2 we create an empty dictionary and on lines 3-5 we add Key-Value pairs. Line 5 adds a List as a Value.

On the line 7 we print the Value that ‘Key_1’ is pointing at, which is a string ‘Value_1’.

On the line 9, we make sure that our ‘test_dict’ has a key ‘Key_3’, and if yes, we print its Value. In this case, Line 10 will print a List and the line 11 will print the second value of the list ‘Value_2’.

And the last part is a For loop which accesses ‘items’ of our dictionary, which are Key-Value pairs, iterates through them and prints out both.

If we now call this function in our main.py file, we should see this output:

Now let’s see how we can replicate this in Rust:

use std::collections::HashMap;

fn _hash_maps() {
    let mut test_hm = HashMap::new();
    test_hm.insert("Key_1", vec!["Value_1"]);
    test_hm.insert("Key_2", vec!["Value_2"]);
    test_hm.insert("Key_3", vec!["Value_1", "Value_2"]);

    // println!("{}", test_hm["Key_1"]);
    println!("{:?}", test_hm["Key_1"]);

    if test_hm.contains_key("Key_3") {
        println!("{:?}", test_hm["Key_3"]);
        println!("{:?}", test_hm["Key_3"][1]);
    }

    for (key, value) in &test_hm {
        println!("{} {:?}", key, value);
    }
}

On the line 1 we are including a HashMap module as it is not included in Rust by default, unlike Vectors.

On the line 4 we create an empty Hash Map (a dictionary in Python).

On lines 5–7 we insert 3 Key-Value pairs the same way as in Python, but in Rust we need to call ‘insert’ method on our Hash Map. If we want to add a Vector with multiple values, like we do on the line 7, we need to make a Vector the default Value type for the whole Hash Map. This is even if we add a single Value like we do on lines 5 and 6.

Line 9 is there but is commented out. You can see that we are trying to print the Value that has a Key “Key_1”, using ‘{}’. This will generate the following error:

error[E0277]: `std::vec::Vec<&str>` doesn't implement `std::fmt::Display`
  --> src/dna_toolkit.rs:24:20
   |
24 |     println!("{}", test_hm["Key_1"]);
   |                    ^^^^^^^^^^^^^^^^ `std::vec::Vec<&str>` cannot be formatted with the default formatter
   |
   = help: the trait `std::fmt::Display` is not implemented for `std::vec::Vec<&str>`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
   = note: required by `std::fmt::Display::fmt`
   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

Amazing that the Rust compiler not only tells us that something is wrong, but also suggests a fix. Let’s use {:?} to format our output, which is a Vector in this case.

The rest of the code is almost identical to Python. The only difference is in Rust, we use ‘contains_key‘ method to check if a Key is in our Hash Map. Last For loop has the same structure, and does not even require items() method like Python does. Here is the final version:

Part 2: DNA Reverse Complement function

Now that we are armed with Dictionaries/Hash Maps, let’s take our existing DNA Reverse Complement function and port it to Rust. In this function we want to map one type of character to another, and given a string, use that map as a translator to generate a new string. We also want to reverse the result before we return it. Let’s go back to dna_toolkit.py/.rs files and add a new function.

So here is our Python version:

def reverse_complement(dna):
   	"""
    Generating a complement string and returning
    reveresed version.
    """
    trans_dict = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}
    complement_dna = ""

    for nuc in dna:
        complement_dna += trans_dict[nuc]

    return complement_dna[::-1]

Nice, clean, and easy, right? This function accepts a string and returns a string.

We just predefine a ‘trans_dict’, translation dictionary on the line 6, which we use as a mapper. On line 7 we create an empty string we will use to accumulate a new set of values in.

For loop on line 9 just loops through each character in the string of dna we passed to that function and checks them against the dictionary, and appends a mapped character to the ‘complement_dna’ string.

Last line 12 returns a reversed version of ‘complement_dna’.

So if we run our code now, we should see this:

We pass “ATCG” into our new function, it is being mapped against our mapping dictionary and “TAGC” is being generated. A reversed version is returned, and we see ‘CGAT’ in our output window.

Here is ‘Pythonic’ version of the same code. Let’s hope Rust will gain that type of functionality in the future. You could start your own Rust ‘crate’ and replicate this type of functionality and share it with the community.

def reverse_complement(self):
   	"""
    Generating a complement string and returning
    reveresed version.
    """
    mapping = str.maketrans('ATCG', 'TAGC')
    return self.seq.translate(mapping)[::-1]

Here is the Rust version:

fn _reverse_complement(dna: &String) -> String {
    // Generating a complement string and returning
    // reveresed version.
    let trans_hashmap: HashMap<char, char> = [('A', 'T'), ('T', 'A'), ('C', 'G'), ('G', 'C')]
        .iter()
        .copied()
        .collect();

    let mut complement_dna = String::new();

    for nuc in dna.chars().rev() {
        complement_dna.push(trans_hashmap[&nuc]);
    }

    return complement_dna;
}

Same as Python, it accepts a string and returns a string. On line 4 we attempt to replicate Python as much as we can. The part after = is an array, so we need to convert it into a collection, copy that collection into a Hash Map and return an iterator. That is why we have those 3 methods after our Hash Map. I suggest you read about these methods here: .iter(), .copied() and here .collect().

Line 9 is a new empty string (from our previous article).

Lines 11, 12 and 15 are almost the same as Python. The only difference being that in Rust, we use ‘dna.chars().rev()‘ to loop through the reversed set of characters from ‘dna‘ and return a string, while In Python we loop through the normal string, and then we reverse it before returning it. Subtle but important difference.

Note, that our mapper ‘trans_hashmap’ is immutable. We can make it mutable and use .insert() method like this:

let mut trans_dict = HashMap::new();
trans_dict.insert('A', 'T');
trans_dict.insert('T', 'A');
trans_dict.insert('C', 'G');
trans_dict.insert('G', 'C');

But a static, immutable version should be a faster solution. In this case, we have a fixed set of characters that will not change. So the original approach makes more sense.

Here is the final result:

We need to tweak the value we pass to be printed in Rust. If we try to pass just “ATCG”, Rust will tell us that we are passing a slice ‘str’ but our function is expecting a reference to a string ‘&String’. So we need to convert ‘str’ to a String and pass it by reference.

Now let’s finish by using our random DNA generator and look at the final result for both languages:

Alright. This is it for this article. See you in the next one.

Links

• Rust HashMap video #1: https://youtu.be/sTK8fagTsMk
• Rust HashMap video #2: https://youtu.be/ic9WEuto-gE

GitHub: https://github.com/rebelC0der/From_Python_To_Rust

Recommended Rust programming book:

For a video versions of these articles, check out my playlist here:

We start with Strings. Rust has two types. One, called ‘String slice’, and the other one is more like a string in other languages, which is just ‘String’. I am going to link to an amazing video about Strings in Rust in the ‘Links’ section below. Please make sure to watch it if you are completely new to this part of Rust.

In this article, we will focus on looking at how we can use Strings in Rust to replicate some of our ‘dna_toolkit’ code. In a previous article, we created two files for Rust and Python: ‘main.rs‘ and ‘main.py‘ respectively. We added all the code into those two files.

To avoid adding a lot of code into one file, let’s create separate files for each video, wrap the code into functions and include/import them into our ‘main‘ files.

So here is the project structure we created in our first article:

Let’s create two new files; ‘intro.py‘ and ‘intro.rs‘, move all the code from our ‘main‘ files into those files, and include/import them. So now our project should look like this:

Now that we have established the structure we will use, let’s add two more files called ‘strings‘ and proceed to our first segment.

Part 1: Strings

So now we should have something like this:

Note, that we added the underscore symbol to our Rust functions: _intro(), _strings(). This is to avoid this compiler warning message:

<strong>= note: `#[warn(dead_code)]` on by default</strong>

We will comment out calls to previous functions to avoid a lot of output at the same time, so we can focus only on the output of the current article code. In this case, Rust tells us that there is a ‘dead code’, meaning we have a function _intro() that is included but never called. This is not a problem, just remember to add underscore to all Rust functions that you are not using/calling.

We will focus on a String as it is a heap allocated data structure, meaning we can change it during the runtime, and it has a set of very useful methods.

test_str = "Doom"
print(test_str)

test_str += " III"
print(test_str)

test_str += '!'
print(test_str)

let mut test_str = String::from("Doom");
println!("{}", test_str);

test_str.push_str(" III");
println!("{}", test_str);

test_str.push('!');
println!("{}", test_str);

Python doesn’t care if you add a ‘character’ or another “String” to our main string, but Rust is strict about it. Here we have two Rust methods for:

• push_str(” “); – adds a string. Requires double quotes ” “. Line 4.
• push(‘ ‘); – adds a single character. Requires single quotes ‘ ‘. Line 7.

If in Python we just saytest_str = "Doom" and Python can understand it is a string, in Rust we need to tell the compiler explicitly: let mut test_str = String::from("Doom");

You can also create an empty String like this:
let mut test_str = String::new();

Both codes will output this:

Doom
Doom III
Doom III!

Check out a few other methods Rust String has : https://www.tutorialspoint.com/rust/rust_string.htm

Let’s combine two existing strings:

p1 = "Duke"
p2 = " Nukem"

p3 = p1 + p2
print(f"{p1} {p2} {p3}")

This is easy in Python. It just works, and we can keep accessing all three variables after we run this code.

If we attempt to do the same in Rust, we will run into an issue. Let’s take a look:

let p1 = String::from("Duke");
let p2 = String::from(" Nukem");

let p3 = p1 + &p2;
println!("{} {} {}", p1, p2, p3) // Will generate an error

Note, that when we add strings, the first string does not have ampersand & symbol. Every string we add after that has to have & symbol.

If we run this, we will see this issue:

<strong>println!("{} {} {}", p1, p2, p3);
                   | ^^ value borrowed here after move</strong>

On the line 4 we gave the ownership of p1 to p3, and we attempt to access it again on the line 5, by printing it out. p1 does not exist at this point, as the ownership has been transferred to p3.

We need to use Rust’s ‘format!‘ function, which will ‘borrow’ p1, and p2 memory locations to construct p3 and will not affect ownership of any variable:

let p1 = String::from("Duke");
let p2 = String::from(" Nukem");

let p3 = String::from(format!("{} {}", p1, p2));
println!("{} {} {}", p1, p2, p3);

Now we have replicated Python’s behavior. Both should output this:

Duke Nukem Duke Nuke

Now, let’s take a quick look at how we can print out individual characters, indices, and part of the string (a slice):

# Print each character:
for ch in p3:
    print(ch)

# Print each character and it's index:
for pos, ch in enumerate(p3):
    print(pos, ch)

# Print a slice of the string
print(p3[0:5])

for ch in p3.chars() {
    println!("{}", ch);
}

for (ind, ch) in p3.char_indices() {
    println!("{} - {}", ind, ch);
}

println!("{}", &p3[0..5]);

The code looks very similar as you can see. In Rust, we use the chars() method to get a single character and char_indices() to get an index and a character. Slicing is almost identical.

Part 2: Rand module (crate)

Now that we are armed with basic Rust String knowledge, let’s quickly port two “DNA Toolkit” functions. For that, we will need to use a random number generator. Random module is a part of Python and can just be included and used, but in Rust we need to add it as a dependence, build it, and only then we can use it. But this is super easy, as you will see.

Project dependencies configuration can be found in Cargo.toml file:

Before we just blindly add a module, let’s see how we can search for it. Open your terminal, make sure it is in ‘dna_engine’ folder, or use the built-in terminal and execute cargo search to search for rand module (crate).

cargo search rand

We can see we found the module we need:

Now let’s add it to our project. Modify Cargo.toml file Line 7-8 to look like this:

[dependencies]
rand = "0.7"

That’s it. When we finish writing a function (next segment) that will need this module, and run that function, Rust will see that we are trying to use this module. It will see we have added it to [dependencies] and download/build it for us.

Part 3: Random DNA sequence generation

Let’s add two new files: dna_toolkit.py and dna_toolkit.rs. This is where our two new function will live.

So here is our random DNA sequence generation function: (we use a loop in Python instead of list comprehension for demonstration purpose)

from random import choice

def gen_random_seq(length):
    nucleuotides = ['A', 'C', 'G', 'T']
    rnd_str = ""

    for _ in range(length):
        rnd_str += choice(nucleuotides)

    return rnd_str

use rand::Rng;

fn _gen_random_seq(length: i32) -> String {
    let nucleuotides = vec!['A', 'C', 'G', 'T'];
    let mut rnd_str = String::new();

    for _ in 0..length {
        rnd_str.push(nucleuotides[rand::thread_rng().gen_range(0, nucleuotides.len())]);
    }
    return rnd_str;
}

The structure is very similar.

• Line 1: We import/include random modules. choice/rand.
• Line 3: While in Python we don’t have to specify the type of the parameter and a return type, in Rust we need to do that. length: i32 tells the compiler we will be passing an integer to our function, and -> String part tells the compiler we will be returning a String.
• Line 8: Python code definitely looks cleaner, but Rust is not much harder to read. We are just asking the rand module to generate a random number in range from 0 to the length of the vector that has 4 nucleotide character in it. We push that randomly picked character onto our string. The only extra bit we have here is thread_rng(). As per Rust documentation: “Retrieve the lazily-initialized thread-local random number generator, seeded by the system“

Part 4: DNA to RNA transcription

In transcription, we just need to replace all ‘T’ – thymine nucleotides with ‘U’ – uracil. This is done with just one line of code in each, as Python and Rust have built-in functions for that:

def transcription(dna):
    return dna.replace("T", "U")

fn _transcription(dna: &String) -> String {
    return dna.replace("T", "U");
}

Easy, right? Now let’s look at both files side by side:

And let’s try adding the output to our main files to test our new functions:

from intro import intro
from strings import strings
from dna_toolkit import gen_random_seq, transcription

if __name__ == "__main__":
    print("Hello, I am Python!")

    # intro()
    # strings()

    dna = gen_random_seq(20)
    print(dna)
    print(transcription(dna))

include!("intro.rs");
include!("strings.rs");
include!("dna_toolkit.rs");

fn main() {
    println!("Hello, I am Rust and I am fast");
  
  	// intro();
    // _strings();
    
  	let dna = String::from(_gen_random_seq(20));
    println!("{}", &dna);
    println!("{}", _transcription(&dna));
}

And here are the outputs from both:

And here is how our file structure should look like so far:

That’s it for this article. Now we know how to create and manipulate Strings in Rust. How to write a simple function, pass a parameter to it and return a value. We also learned how to add a module (crate) to Rust and include files into other files.

Links

• Rust String video: https://youtu.be/ClPrjjHmo2Y
• Additional Rust String methods: https://www.tutorialspoint.com/rust/rust_string.htm

Recommended Rust programming book:

GitHub: https://github.com/rebelC0der/From_Python_To_Rust

Video version of the article:

While Python is an amazing, general purpose language and is super easy to write and understand, it might be too slow when we need to write an algorithm that needs to ‘crunch’ through a lot of data. Of course, well written Python code that uses something like NumPy or Cython, is still, very, very fast and probably enough in most cases. All the checks that are done by interpreted language like Python, will slow our code a lot.

We will look at Python and Rust code side-by-side and attempt to port (rewrite) some of our Bioinformatics related code from Python to Rust while comparing code execution speed of both. We will see, that we don’t necessarily need/have to sacrifice simplicity of Python for Rust’s speed. And some functionality, written in Python, will stay in Python and just call our faster code, rewritten in Rust. This way, we will attempt to get a ‘sweet spot’ (best from both languages) to solve our Bioinformatics problems.

Prerequisites:

• Good Python knowledge.
• Basic Rust knowledge (I assume you are here because you know what you are doing) 😛
• You understand the difference between compiled and interpreted language.
• You understand the difference between statically and dynamically typed languages.
• Code Editor with both, Python and Rust integrations.

Good to have:

• Previous C-style (C-type?) language experience.
• Desire to learn a new, exciting, compiled, memory safe and fast systems programming language.

Make sure you have the latest Python version installed: Link
Make sure you have the latest Rust/Cargo version installed: Link

We start by creating a folder, I called py_rust. In that, we create one folder ‘by hand’: python and add an empty file called main.py. This is where our Python code will live. For the Rust folder, we will use Rust’s project and package manager, Cargo. This will create a small project for us, with all the necessary files, needed to run and configure the Rust project.

Start a prompt (bash/shell/cmd) in our newly created py_rust folder, which already contains Python and execute the following:

cargo new rust --bin

So parameters are:

new – makes the cargo tool create a new project.
rust – the name of the folder for the project.
--bin – make the cargo tool create a project for a binary, not a library.

Now we should have the following structure:

[py_rust]
├── python
│   └── main.py
└── rust
    ├── Cargo.lock
    ├── Cargo.toml
    ├── src
    │   └── main.rs
    └── target

As Rust is a comparably young language, you might find tools and IDE integrations don’t work as well as say for Python, C++, Java. I am using VSCodium (VSCode) and it does have a good enough integration. Our goal here is to see two languages, Python and Rust, side-by-side, and be able to just use a keyboard shortcut to run both.

Please make sure that you add Python and Rust project folders into our code editor one-by-one, and not the whole py_rust folder. This is because the Rust cargo system will be looking for a project source in a root directory, so if our root directory is py_rust, this will fail. Adding each folder separately will make sure that both, Python and Rust are executed not from py_rust but from their individual workspace. More details on that in my video version of this article.

In the article here, we set up a VSCodium editor to be able to run Python as easy as possible, using just two plugins. If you have this configured already, you should, in theory, be able to run Rust exactly the same way. Make sure you have these two extensions installed:

The only thing we need to add is a code runner configuration for Rust.

1. While you have VSCodium opened, hit F1 and type settings and choose the first option:

2. Add this line to your settings.json file:

"code-runner.executorMap": {
	"rust": "if [ $(basename $dir) = 'examples' ]; then cargo run -q --example $fileNameWithoutExt; else cargo run -q; fi"
}

Now we should be able to run both, Python and Rust with just a key combination (Ctrl + Alt + N).

Let’s add our first line of code and execute it:

print("Hello, I am Python!")

fn main() {
    println!("Hello, I am Rust and I am fast");
}

And now we can try executing the code and if everything is configured correctly, we should see this:

And here is how our setup should look like:

Now let’s start looking at the actual code.

x = 100.0
y = 1.0

print(f"x: {x}, and y: {y}")
y = y * -0.3145
print(f"x: {x}, and y: {y}")

let x = 100.0;
let mut y = 1.0;

println!("x: {}, and y: {}", x, y);
y = y * -0.3145;
println!("x: {}, and y: {}", x, y);

Note: for Rust, we need to remember that all the code is wrapped in the main() {} function.

We can see, that the code is very similar. Print statements differ just a bit, but easy to get used to. In Python, we use f-strings. But the difference, of course, is in how we declare variables. This is why Rust is statically typed. We need to tell it what type our variable is before we use it. The concept of mutable/immutable is present in both languages, but in Rust we need to specify mut if we plan to change the value of the variable somewhere in the code. So on the line 5 we modify the variable y and that is why we need it to be mutable. If we don’t declare it as let mut and try executing the code, we will see the beauty of Rust’s compiler:

error[E0384]: cannot assign twice to immutable variable `y`
 --> src/main.rs:8:5
  |
5 |     let y = 1.0;
  |         -
  |         |
  |         first assignment to `y`
  |         help: make this binding mutable: `mut y`
...
8 |     y = y * -0.3145;
  |     ^^^^^^^^^^^^^^^ cannot assign twice to immutable variable

error: aborting due to previous error

For more information about this error, try `rustc --explain E0384`.
error: could not compile `rust`.

To learn more, run the command again with --verbose.

We can see, that Rust compiler tells us exactly what is wrong. I wish all languages had such a helpful output.

Let’s see how if and else look like in both:

if y < x:
    print(f"The difference is: {x-y}")
elif y == x:
    print(f"The difference is: {x-y}")
else:
    print(f"The difference is: {y-x}")

if y < x {
    println!("The difference is: {}", (x - y));
} else if y == x {
    println!("The difference is: {}", (y - x));
} else {
    println!("The difference is: {}", (y - x));
}

We can see that the code is almost identical. C-style language programmers probably will be tempted to wrap y < x in (y < x). Let’s try doing that and see what Rust will tell us.

warning: unnecessary parentheses around `if` condition
  --> src/main.rs:10:8
   |
10 |     if (y < x) {
   |        ^^^^^^^ help: remove these parentheses
   |
   = note: `#[warn(unused_parens)]` on by default

Well, what can I say? Beautiful! Learning Rust with such amazing help from the compiler is pure joy.

Loops will look very similar:

x = 5
while x > 0:
    print(f"x is {x}")
    x -= 1

for i in range(3, 7):
    print(f"i is {i}")

let mut x = 5;
while x > 0 {
    println!("x is {}", x);
    x -= 1;
}

// Version 1 (Very Pythony):
for i in 3..7 {
    println!("i is {}", i);
}

// Version 2 (If you need to create a range on the fly):
let num_range = 3..7;
for i in num_range {
    println!("i is {}", i);
}

While/For loops and range usage are almost identical. The only difference is if you want to re-use the x variable in Python, you just overwrite it. This is where we can see that Python is not, and Rust is type-safe and does not allow you to just re-use a variable and requires something called variable shadowing on the line 1. This is needed to protect you from writing broken code. Originally, we declared x = 100.0, and Rust interpreted it as a float. Now, if we just try overwriting it as x = 5; Rust will tell us that the original variable was float and now you are trying to assign an integer to it. Try doing that yourself and see what Rust compiler will tell you.

Let’s take a look at a List/Vector and how we can get an iterator and enumerator out of both:

tmp_lst = ['DNA', 'RNA', 'mRNA']

for value in tmp_lst:
    print(f"value is {value}")

let tmp_vec = vec!["DNA", "RNA", "mRNA"];

for value in tmp_vec {
    println!("value is {}", value);
}

This is easy. What in Python is a List, is a Vector in Rust. We should see this output from both:

value is DNA
value is RNA
value is mRNA

Now, if Python will allow accessing/modifying our List after we access it in a For loop, Rust will not allow us to do the same to its Vector. After both loops, try acceding/printing just the first element of a List/Vector: like this:

# Python:
print(tmp_lst[0])

// Rust:
println!("{}", tmp_vec[0]);

And now Rust will introduce us to yet another concept of Ownership and Borrowing, also (here)

error[E0382]: borrow of moved value: `tmp_vec`
  --> src/main.rs:34:20
   |
26 |     let tmp_vec = vec!["DNA", "RNA", "mRNA"];
   |         ------- move occurs because `tmp_vec` has type `std::vec::Vec<&str>`,
   | 	                                 which does not implement the `Copy` trait
27 |     for value in tmp_vec {
   |                  -------
   |                  |
   |                  value moved here
   |                  help: consider borrowing to avoid moving into the for loop: `&tmp_vec`
...
34 |     println!("{}", tmp_vec[0]);
   |                    ^^^^^^^ value borrowed here after move

If you never heard about this Rust concept, you should invest your time in reading about it. Basically, after we provided our tmp_vec Vector to a For loop in Rust, we gave the ownership of our tmp_vec Vector to that For Loop. For loop did what we asked it to do, which is to print the contents of that Vector, and after that, tmp_vec was discarded as our For loop owned it. After the For loop was done and out of scope, everything in the scope of that For loop is now gone too.

This is easily ‘fixed’ by ‘asking’ our tmp_vec to return just the iterator, and not itself: tmp_vec.iter(), and now line 7 will not produce an error:

let tmp_vec = vec!["DNA", "RNA", "mRNA"];

for value in tmp_vec.iter() {
    println!("value is {}", value);
}

println!("{}", tmp_vec[0]);

And now let’s add an enumerator to our For loop:

tmp_lst = ['DNA', 'RNA', 'mRNA']

for pos, value in enumerate(tmp_lst):
    print(f"value at pos {pos} is {value}")

let tmp_vec = vec!["DNA", "RNA", "mRNA"];

for (pos, value) in tmp_vec.iter().enumerate() {
    println!("value at pos {} is {}", pos, value);
}

Almost identical. Alright. This is it for this article. See you in the next one soon.

All the code is available her: https://github.com/rebelC0der/From_Python_To_Rust