DEV Community: Augustine Madu

How to test Asynchronous Rust Programs with Tokio [TUTORIAL]

Augustine Madu — Thu, 02 Jan 2025 09:00:00 +0000

Hey Devs,

You may already know how to write tests for synchronous functions in Rust, but to write tests for asynchronous functions, you will need the aid of an external crate called Tokio.

Tokio is a very popular crate in Rust, which is used to run asynchronous and multi-threaded programs efficiently.

It also comes with a test attribute macro, which you can use on a test function to run it asynchronously.

In this tutorial, you will also learn how to get the state of an asynchronous function (whether it's pending or ready). This will be done by utilizing an external crate called Tokio-Test.

The Tokio-Test crate comes with a set of assertion macros, such as:

assert_pending
assert_ready
assert_ready_eq
assert_ready_ok
assert_ready_err

These are used to assert the state of an asynchronous function or block.

I will also show you how to work with timeouts and intervals in your test without slowing down your test.

Here's the YouTube video for the tutorial.

I hope you learn something new!

Lifetimes in Rust Explained with Examples

Augustine Madu — Sun, 01 Sep 2024 23:00:00 +0000

In this article, you are going to learn about lifetimes in rust, together with its purpose using examples.

For start, here we have a variable s, created at the outer scope, and at the inner scope, we have a variable t which is an integer 5, we then make s a reference to t.

fn main() {
  let s;

  {
    let t = 5;

    s = &t;
  }
}

This compiles at the time, but the problem with this is that when t goes out of scope, all its references will become invalid, now s becomes invalid.

If we try to print the value of s, then we get an error.

fn main() {
  let s;

  {
    let t = 5;

    s = &t;
  }

  println!("{s}");
}

error[E0597]: `t` does not live long enough
  --> lifetimes/src/main.rs:11:9
   |
9  |     let t = 5;
   |         - binding `t` declared here
10 |
11 |     s = &t;
   |         ^^ borrowed value does not live long enough
12 |   }
   |   - `t` dropped here while still borrowed
13 |
14 |   println!("{s}");
   |             --- borrow later used here

Rust figures this out using lifetimes. Each variable has a lifetime associated with the scope in which it was created. Here, s has a lifetime which we will call a, and t has a lifetime which we will call b.

fn main() {
  // LIFETIMES

  //---------------------- 'a
  let s;               //|
                       //|
  {                    //|
  //---------------'b    |
    let t = 5;  //|      |
                //|      |
    s = &t      //|      |
  //---------------'b    |
  }                    //|
  //---------------------|'a
}

When we assign s a reference to t, rust compares the lifetime of s and t and sees that the lifetime of s is longer than that of t, now when t goes out of scope, s becomes invalid.

Most times, we do not need to specify the lifetime of a reference. But to use a reference in a struct and sometimes in a function, you need to specify the lifetimes of the reference.

Let's look at the functions below to understand how to specify lifetimes in a function.

If you prefer a video version of this article. You can check out my YouTube video on it.

Example 1

For the first example, we try to return a reference for a variable created inside this function. But when the function scope ends the variable x is dropped and the reference becomes invalid, so this function returns an invalid reference therefore it wouldn’t compile.

fn example_1() -> &i32 {
  let x = 5;

  &x
}

  --> lifetimes/src/main.rs:13:19
   |
13 | fn example_1() -> &i32 {
   |                   ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from 
   help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
13 | fn example_1() -> &'static i32 {
   |                    +++++++
help: instead, you are more likely to want to return an owned value
   |
13 - fn example_1() -> &i32 {
13 + fn example_1() -> i32 {
   |

If a function returns a reference that is not static, then it should come from one of its parameters.

The purpose of lifetimes in functions is to inform the compiler how the lifetime of its output values relates to the lifetime of its input parameters. We shall see this in the coming examples.

Example 2

For the second example, we return x from the function’s parameter which is a reference of an integer. It compiles successfully as the compiler assigns the lifetime of the return value of this function to that of x from its parameter.

fn example_2(x: &i32) -> &i32 {
  x
}

But when we have two reference parameters and an output which is a reference, the compiler has no way of knowing how the lifetime of the output reference relates to that of the input.

Example 3

For the third example, here we have two reference parameters, now the compiler can not figure out which lifetime to assign the return value of the function, so we manually add a lifetime to the function.

fn example_3(x: &i32, y: &i32) -> &i32 {
  x
}

error[E0106]: missing lifetime specifier
  --> lifetimes/src/main.rs:23:35
   |
23 | fn example_3(x: &i32, y: &i32) -> &i32 {
   |                 ----     ----     ^ expected named li
fetime parameter
   |
   = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
   |
23 | fn example_3<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
   |             ++++     ++          ++          ++

We label the lifetime of a reference by adding an apostrophe after the ampersand followed by the letter we choose to label it with, in small cases.

&'a x
&'b mut x

To add a lifetime in a function, we specify the label of the lifetimes used in the function in an angle bracket, then give each reference parameter and return values of their lifetimes after their ampersand.

fn example_3<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
  x
}

Now this tells the compiler that the return value lives as long as both parameters live. If one of the two is dropped, the output of the function is dropped too.

In some situations, the lifetime of the return value only relates to some and not all the lifetime of the input parameters.

Example 4

For the fourth example, we return x from the parameter, and we want to specify that the lifetime of the return value only relates to that of the first parameter. So we add two lifetimes a and b for the function. We label the lifetime of x with a, and that of y with b. Since the lifetime of the return value relates to that of x, we label its lifetime with a as well.

fn example_4<'a, 'b>(x: &'a i32, y: &'b i32) -> &'a i32 {
  x
}

If we try to return y, we get an error, since the lifetime of y and the return value are different.

fn example_4<'a, 'b>(x: &'a i32, y: &'b i32) -> &'a i32 {
  y
}

error: lifetime may not live long enough
  --> lifetimes/src/main.rs:28:3
   |
27 | fn example_4<'a, 'b>(x: &'a i32, y: &'b i32) -> &'...
   |              --  -- lifetime `'b` defined here
   |              |
   |              lifetime `'a` defined here
28 |   y
   |   ^ function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'b`
   |
   = help: consider adding the following bound: `'b: 'a`

To see this further, in the main function, we have a variable x, and z at the outer scope and y at the inner scope.

At the inner scope, we assign z to be the return value of the function, outside the inner scope, we print the value of z and this compile successfully, since the lifetime of z is tied to that of x at the first parameter.

fn main() {
  let x = 2;

  let z;

  {
    let y = 3;

    z = example_4(&x, &y);
  }

  println!("{z}");
}

If y is at the first parameter and x is at the second, the lifetime of y will then be tied to the return value of the function, and when we try to use z outside the scope of y we get an error.

Example 5

For the fifth example, here, we have one reference parameter and the return value is a tuple containing two integer references. We do not need to explicitly specify the lifetimes as the compiler assumes that any reference in the output comes from this one parameter, so this compiles successfully without any errors.

fn example_5(x: &Vec<i32>) -> (&i32, &i32) {
  (&x[0], &x[1])
}

Example 6

For the sixth example, instead of just one reference parameter, we have two reference parameters. The compiler has no idea how the reference in the output relates to that of the input. The two references in the output can come from the first, the second, or both.

fn example_6(x: &Vec<i32>, y: &Vec<i32>) -> (&i32, &i32) {
  (&x[0], &y[0])
}

In our implementation, the first element of the tuple comes from the first parameter, while the second element of the tuple comes from the second parameter. To specify this in lifetimes, since we are dealing with two different lifetimes, we add two lifetimes labels to the function, and the lifetime we give to the first parameter, we give to the first element of the tuple, and we do that for the second parameter and second tuple.

fn example_6<'a, 'b>(x: &'a Vec<i32>, y: &'b Vec<i32>) -> (&'a i32, &'b i32) {
  (&x[0], &y[0])
}

Static Lifetimes

The next lifetime to talk about is the static lifetime. This is a lifetime of a variable that can live for the entire duration of the program. All string and byte literals have a static lifetime since they are stored in the program's binary which is always available.

Unlike our first example, this program compiles since the return value of this function can live as long as the program, we just have to specify that the lifetime of the return value is static using the static lifetime.

fn example_static() -> &'static str {
  let x = "hello";

  x
}

Specifying Lifetimes in a Struct

To use a reference in a struct that isn’t a static lifetime, we have to specify the lifetimes used in the struct in an angle bracket as well.

// we specify the lifetimes being used in an angle bracket
struct Person<'a> {
  name: &'a str,
}

// we don't add static lifetime in angle bracket
struct Car {
  color: &'static str,
}

When creating methods for this struct, we add after the ‘impl’ keyword as well.

impl<'a> Person<'a> {
  fn new() -> Self {
    todo!()
  }
}

Thanks for reading.

An article from my website https://cudi.dev/articles/lifetimes_in_rust_explained_with_examples

Borrowing and References in Rust Explained

Augustine Madu — Sat, 31 Aug 2024 23:00:00 +0000

To understand references in Rust, it will be beneficial to have knowledge on how the ownership system in Rust works.

Recap on Rust Ownership Model

Rust has an ownership system where only one variable can lead to a specific piece of data in the memory. The variable is called the owner of the data. The data can be stored either on the stack or the heap.

Variables that have a fixed size, like integers, float, or booleans are stored on the stack, while variables that can grow or change in size are stored on the heap.

Here, x is a stack variable and when we assign y the value of x, the value of x is copied on the stack and y becomes the owner of the copied value, and when we print them we can see that their values are the same.

let x = 2;

let y = x;

println!("x: {x}");

println!("y: {y}");

x: 2
y: 2

Copying data on the stack is cheap, but for data stored on the heap, copying their values is expensive. So when we assign b the value of a, since there can’t be two pointers to the same data, b becomes the new owner of the data, and the variable a becomes invalid.

When we try to print the value of a, we get an error.

let a = "hello".to_string();

let b = a;

println!("{a}");

error[E0382]: borrow of moved value: `a`
 --> references/src/main.rs:8:13
  |
4 |   let a = "hello".to_string();
  |       - move occurs because `a` has type `String`, which does not implement the `Copy` trait
5 |
6 |   let b = a;
  |           - value moved here
7 |
8 |   println!("{a}");
  |             ^^^ value borrowed here after move
  |

When data is stored on the heap, a pointer to that location is returned and pushed to the stack. The variable labels the address of the pointer on the stack.

You can read this article to learn more about ownership, the stack, and the heap.

If you prefer a video version of this article. You can check out my youtube video on it.

References and Borrowing in Rust

Sometimes you may want a variable to point to the data of another variable without taking ownership of that data. This is called borrowing.

What happens during borrowing is that a special pointer to the address of the owner is created and pushed to the stack and that pointer leads to the owner that leads to the data on the heap.

This special pointer is called a reference.

To make b a reference to a, we add an ampersand right in front of a.

let a = "hello".to_string();

let b = &a;

Now we can make use of both variables and print the values of both variables without any error.

println!("a: {a}");

println!("b: {b}");

a: hello
b: hello

Creating and using references comes with some rules called the borrowing rules.

The first one is that a reference is always valid. When we move ownership of the variable to the variable c. Variable a and all its references become invalid and we can no longer use them.

let a = "hello".to_string();

let b = &a;

let c = a;

When we try to use the variable b, we get an error.

println!("{b}");

error[E0505]: cannot move out of `a` because it is borrowed
  --> references/src/main.rs:8:11
   |
4  |   let a = "hello".to_string();
   |       - binding `a` declared here
5  |
6  |   let b = &a;
   |           -- borrow of `a` occurs here
7  |
8  |   let c = a;
   |           ^ move out of `a` occurs here
9  |
10 |   println!("{b}");
   |             --- borrow later used here

We can also pass ownerships and references in function parameters. To specify if a parameter is a reference we add an ampersand in front of the data type.

fn main() {
  let a = "hello".to_string();
}

fn takes_reference(s: &String) {
  //
}

fn takes_ownership(s: String) {
  //
}

If we pass a into the function that takes ownership, the pointer is moved to the parameter of the function, and a becomes invalid. We can no longer get or use a reference of a.

let a = "hello".to_string();

let b = &a;

takes_ownership(a);

// both statements are invalid

println!("{b}");

println!("{a}");

But if we replace it with one that takes a reference, we add a reference of a as the argument, and a still remains valid and we can still make use of it after the function.

let a = "hello".to_string();

let b = &a;

takes_reference(&a);

// both statements are now valid

println!("{b}");

println!("{a}");

Mutable and Immutable References

There are two kinds of references;

Mutable References, and
Immutable references.

A mutable reference is used when you want to mutate the variable’s data. Before creating a mutable reference the variable needs to be marked as mutable by adding mut before the variable name.

To make a reference mutable add mut after the ampersand.

let mut v = vec![0, 1, 2];

// mutable reference of v
let u = &mut v;

Here we have a function that mutates a vector of integers and pushes 3 onto the vector. In its parameter a, we specify that a should be a mutable reference of a vector.

fn mutates_vector(a: &mut Vec<i32>) {
  a.push(3)
}

And after we mutate v, a still has ownership of the vector and we can print out its value.

fn main() {
  let mut v = vec![0, 1, 2];

  mutates_vector(&mut v);

  println!("vector v: {v:?}");
}

fn mutates_vector(a: &mut Vec<i32>) {
  a.push(3)
}

vector v: [0, 1, 2, 3]

The second rule of borrowing is, we can have either as many immutable references or only one mutable reference. You can’t have a mutable reference and any other reference.

When there’s a mutable reference, all other references become invalid and we can’t use them.

If we try to print the value of c, we get an error. But we can use the mutable reference d since, it is the last reference.

let mut a = vec![0, 1, 2];

let b = &a;

let c = &a;

let d = &mut a;

d.push(3);

We can have multiple mutable references, as long as one is not used after another is created. Here we have mutable references d and e, mutating the vector a, as long as any other reference created before e is not being used, our program compiles and runs successfully.

let mut a = vec![0, 1, 2];

let d = &mut a;

d.push(3);

let e = &mut a;

e.push(4);

Introduction to Lifetimes

References can’t outlive the owner. Here we have a variable s, created at the outer scope, and at the inner scope, we have a variable t which is an integer 5, we then make s a reference to t.

let s;

{
  let t = 5;

  s = &t
}

This compiles at the time, but the problem with this is that when t goes out of scope, all its references will become invalid, now s becomes invalid.

If we try to print the value of s, then we get an error. Rust figures this out using lifetimes.

println!("{s}");

error[E0597]: `t` does not live long enough
  --> references/src/main.rs:11:9
   |
9  |     let t = 5;
   |         - binding `t` declared here
10 |
11 |     s = &t
   |         ^^ borrowed value does not live long enough
12 |   }
   |   - `t` dropped here while still borrowed
13 |
14 |   println!("{s}");
   |             --- borrow later used here

Each variable has a lifetime associated with the scope in which it was created. Here, s has a lifetime which we will call a, and t has a lifetime which we will call b.

When we assign s a reference to t, rust compares the lifetime of s and t and sees that the lifetime of s is longer than that of t, now when t goes out of scope, s becomes invalid.

fn main() {
  // LIFETIMES

  //---------------------- 'a
  let s;               //|
                       //|
  {                    //|
  //---------------'b    |
    let t = 5;  //|      |
                //|      |
    s = &t      //|      |
  //---------------'b    |
  }                    //|
  //---------------------|'a
}

Most times, we do not need to specify the lifetime of a reference since it can be implied by its scope.

But to use a reference in a struct and sometimes in a function, you need to specify the lifetimes of each reference.

To understand specifying lifetimes in a function, let’s look at these 3 functions.

In the first function, we try to return a reference for a variable created inside this function. But when the function scope ends the variable x is dropped and the reference becomes invalid, so this function returns an invalid reference therefore it wouldn’t compile.

fn example_1() -> &i32 {
  let x = 2;

  &x
}

error[E0106]: missing lifetime specifier
 --> references/src/main.rs:9:19
  |
9 | fn example_1() -> &i32 {
  |                   ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed 
value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`

In the second function, we return x from the function’s parameter which is a reference of an integer. It compiles successfully as the compiler assigns the lifetime of the return value of this function to that of x in the parameter.

fn example_2(x: &i32) -> &i32 {
  &x
}

So when we make use of this function, here, the variable b, is valid and given the lifetime of a.

fn main() {
  let a = 5;

  let b = example_2(&a);
}

Even if we create an inner scope and assign b to the return value of this function, we can make use of b outside the scope, as their lifetimes are the same.

fn main() {
  let a = 5;

  let b;

  {
    b = example_2(&a);
  }

  println!("b = {b}");
}

b = 5

For the third function, here we have two parameters, now the compiler can not figure out which lifetime to assign the return value of the function, so we manually add a lifetime to the function.

fn example_3(x: &i32, y: &i32) -> &i32 {
  &x
}

error[E0106]: missing lifetime specifier
  --> references/src/main.rs:19:35
   |
19 | fn example_3(x: &i32, y: &i32) -> &i32 {
   |                 ----     ----     ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, 
   but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
   |
19 | fn example_3<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
   |             ++++     ++          ++          ++

We label the lifetime of a reference by adding an apostrophe after the ampersand followed by the letter we choose to label it with, in small cases.

&'a i32

fn example_3<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
  &x
}

Now this tells the compiler that the return value lives as long as both parameters live. If one of the two is dropped, the output of the function is dropped too.

To learn more about lifetimes check out this article.

Thanks for reading.

An article from my website An article from my website https://cudi.dev/articles/borrowing_and_references_in_rust_explained

Rust ownership System Explained

Augustine Madu — Fri, 30 Aug 2024 23:00:00 +0000

To understand the concept of ownership, it is necessary to have an idea of what the stack and the heap are and how they work.

The Stack and Heap

Variables are labels containing addresses to data in the memory. Each piece of data is stored either on the stack or the heap. The stack and heap are parts of the memory available to your program during runtime.

The stack size is known at compile time and it’s fixed. Therefore it can only store data with a fixed size and known at compile time, such as integers, float, boolean, etc.

// STACK VARIABLES
let x: i32 = 2;

let y: f64 = 3.14;

let z: bool = false;

The heap stores data whose size are unknown or can grow in size.

New elements can be pushed into the vector at some time in the program. So it’s stored on the heap.

let a: Vec<i32> = vec![2, 4, 6, 8];

The variable b holds data that implements the display trait and this can be of any size, so we store it in the heap using the Box smart pointer.

use std::fmt::Display;

let b: Box<dyn Display> = Box::new(12);

Variable c is a String data structure and we can add more characters to it during the program, therefore it is also stored on the heap.

let c: String = String::from("hello");

The stack stores values in the order it gets them and removes the values in the opposite order. At the start of this new scope in the program, the 2 is added to the top of the stack. When we get to the inner sope, 3.0, and 4 are pushed to the top of the stack, and x and y point to their respective values.

fn main() {
  //OUTER SCOPE
  // w is pushed to top the stack
  let w = 2;

  {
    //INNER SCOPE
    // x and y are pushed to the top of the stack
    let x = 3.0;

    let y = 4;
  }

  // y and x are popped off the stack and
  // can not be used here
}

When we get to the end of the inner scope y and x are popped out of the stack. This is how all programming languages handle the addition and removal of data on the stack.

For adding data on the heap, the memory allocator finds a space big enough to hold the data, stores it, and returns a pointer which is the address of that memory.

Various programming languages have different approaches for removing data on the heap. High-level languages, like Javascript and Golang, have a garbage collector that periodically finds memory no longer in use and cleans them.

Low-level languages allow the user to explicitly allocate and free memory on the heap. In languages like C and C++, the programmer manually allocates memory which returns a pointer and deallocates the memory using that pointer.

If this is not done properly, it can lead to memory leaks when the programmer forgets to free the memory, causing the program to crash over time. Or trying to read from a freed memory, or freeing the same memory twice.

If you prefer a video version of this article, check out my youtube video on it.

Rust Ownership Model

Rust does things differently with its ownership model.

When we add to the heap, the pointer, which is the address of the memory is added to the stack since the size is known. It is 8 bytes for a 64-bit system and 4 bytes for a 32-bit system.

The variable then leads to that pointer in the stack and will be called the owner of the data.

When a heap variable goes out of scope, the pointer is popped off the stack, and whenever the pointer is popped off the stack, the data on the heap is cleared.

Rust’s ownership model ensures that there is only one pointer to a memory on the heap to prevent pointing to a freed memory. If there are two pointers to the same data on the heap, the pointers would be stored in the stack, and if one of the variables goes out of scope, the pointer will be popped off and the heap data will be cleared.

Trying to read the data from the other pointer will cause an error resulting in an unexpected behaviour or crashing the program.

When we assign a stack variable to a new variable the data is copied and pushed to the top of the stack. This process is cheap since their size and locations are already known. The process is called copying.

When we print the values of x and y, we get 3 for both.

let x = 3;

let y = x;

println!("x: {x}");
println!("y: {y}");

x: 3
y: 3

If we assign a heap variable to another variable, copying the data on the heap will be costly, since the memory allocator will have to first find a space on the heap, big enough to contain the data, before copying the values over to that address.

let x = String::from("hello");

let y = x;

On the stack, we can’t copy the pointer, since we will have two pointers to the same location on the heap. Instead, the pointer is moved to the top of the stack, the new variable then leads to that pointer, and the old variable becomes invalid.

The variable y now holds the string’s pointer and when we try to read variable x, we get an error.

println!("{x}");

error[E0382]: borrow of moved value: `x`
  --> main.rs:16:13
   |
12 |   let x = String::from("hello");
   |       - move occurs because `x` has type `String`, wh
ich does not implement the `Copy` trait
13 |
14 |   let y = x;
   |           - value moved here
15 |
16 |   println!("{x}");
   |             ^^^ value borrowed here after move

Likewise, when we pass values to a function’s arguments the variables on the stack that aren’t pointers are copied to the parameters and pushed to the stack while the variables that are pointers are moved, and the function parameter is the new owner. The old variable is now invalid and when we try to make use of it, we get an error at compile time.

fn main() {
  let s = vec![2, 4, 6, 8];

  let t = 1;

  // s is moved into the first parameter of the function
  // while t is copied
  get_elem(s, t);

  //s is invalid here, but t is valid
}

fn get_elem(v: Vec<i32>, u: usize) -> i32 {
  v[u]
}

When the scope is ended, the pointer is popped out and dropped.

We can transfer back ownership by returning the values and assigning them to the variables.

fn main() {
  let s = vec![2, 4, 6, 8];

  let t = 1;

  let (result, s) = get_elem(s, t);
}

fn get_elem(v: Vec<i32>, u: usize) -> (i32, Vec<i32>) {
  (v[u], v)
}

This approach is a bit tedious. If we want to keep ownership while using the values in a function, we make use of references.

References and Borrowing in Rust

References are special pointers that point to data and other pointers on the stack.

We modify the function to accept a reference of a vector, by adding an ampersand.

fn main() {
  let y = vec![2, 4, 6, 8];

  let x = 1;

  let result = get_elem(&y, x);
}

fn get_elem(v: &Vec<i32>, u: usize) -> i32 {
  v[u]
}

When we create a reference of a variable, a pointer is given to that variable and pushed to the stack. The compiler makes sure this reference will always point to valid data on the stack using a set of rules called the borrowing rules. The act of creating a reference to a variable is called borrowing.

Now when the function scope is ended, the reference is popped off the stack and not the actual value.

We can now use the variable y after the function.

fn main() {
  let y = vec![2, 4, 6, 8];

  let x = 1;

  let result = get_elem(&y, x);

  println!("{y}");
}

fn get_elem(v: &Vec<i32>, u: usize) -> i32 {
  v[u]
}

If a variable is moved all its references are invalidated. Here, the variable x contains a string data, and y references x.

let x = "hello".to_string();

let y = &x;

If we move x, into an inner scope and try to make use of y after the scope, we get an error. This is because when x is moved, its references are invalidated.

let x = "hello".to_string();

let y = &x;

{
  x;
}

// Here, all references of x are invalid
// Since x is invalid

To learn more about references and the borrowing rules check out this article

Thanks for reading.

An article from my website https://cudi.dev/articles/ownership_in_rust_explained

Rust number types explained

Augustine Madu — Sat, 17 Aug 2024 09:46:06 +0000

A number can either be an integer or a float. Numbers without fractional components are integers, while numbers with fractional components are called floats, which is short for a floating point number.

Integers in Rust may either be signed or unsigned. Signed integers as the name implies are integers that carry a sign. They can be negative, positive, or zero. Unsigned integers on the other hand are integers without a sign and are either positive or zero.

If you prefer a video explanation of this article, you can watch the embedded video below.

Signed and Unsigned Integers

Signed integers are labeled with an i followed by the size of the integer specified in bits. Unsigned integers are labeled with a u followed by the size of the integer.

//integers: signed / unsigned integers

//signed
let x: i8 = 2;

let y: i16 = -3;

let z: i32 = 0;

//unsigned
let a: u8 = 2;

let b: u16 = 3;

let c: u32 = 0;

We can specify the size and type of the integer by adding the label at the end of the number literal.

//integers: signed / unsigned integers

//signed
let x = 2_i8; // => i8

let y = -3_i16; // => i16

let z = 0_i32; // => i32

//unsigned
let a = 2_u8; // => u8

let b = 3_u16; // => u16

let c = 0_u32; // => u32

If we don’t specify the type of integer, the variable is given a signed 32-bit integer by default.

let x = 2; // => i32

let y = -3; // => i32

let z = 0; // => i32

There are 12 variants of the integer types in Rust and they are classified by sign and size. We have 8, 16, 32, 64, and 128-bit integers, which can be either signed or unsigned.

The isize and usize variants, their sizes depend on the architecture of the computer on which the program is running. For 32-bit systems, the isize becomes i32 and the usize becomes u32. Likewise, for 64-bit systems, the isize is i64 and u64 for usize. They are mostly used in indexing a collection, like arrays and vectors.

Each integer variant can only store integers of a certain range due to their size and sign. For signed integers i-n the range is between $2^{n-1}$ to $2^{n-1}-1$ inclusive. For unsigned integers u-n, its range is between $0$ to $2^n - 1$ .

So i8 can store integers from $2^7$ to $2^7 - 1$ which is $- 128$ to $127$ . While u8 can store integers from $127$ to $2^8 - 1$ , which equals $255$ . You can do this for other integer variants to get their ranges.

8 bits equals 1 byte, so an i8 and u8 integer takes up 1 byte in the memory, 16-bit integers take up 2 bytes, 32 take up 4, 64 take up 8, and so on.

To get the size of a data type, you can use the size_of function obtained from the mem module of the standard library.

use std::mem::size_of;

fn main() {
  println!("size of i8   : {}", size_of::<i8>());

  println!("size of i16  : {}", size_of::<i16>());

  println!("size of i32  : {}", size_of::<i32>());

  println!("size of isize: {}", size_of::<isize>());
}

size of i8   : 1
size of i16  : 2
size of i32  : 4
size of isize: 8

This also works for compound types like structs and tuples, even pointers and references.

Representing integer literals in Rust

There are several ways of writing a number literal. For large numbers, we can separate the numerals with an underscore for better readability.

//without underscore
let large_num = 12345678;

//with underscore
let large_num = 12_345_678;

Integers can be written in hexadecimal format, in octal, or in binary form. For hexadecimal format, we prefix the integer with 0x, 0o for octal, and 0b for binary.

//decimal
let x = 42;

//hex
let y = 0x2a;

//octal
let z = 0o52;

//binary
let w = 0b101010;

When the values of the integers are printed they will be displayed in their decimal format.

println!("x: {}", x);

println!("y: {}", y);

println!("z: {}", z);

println!("w: {}", w);

x: 42
y: 42
z: 42
w: 42

To display an integer in hexadecimal format, in the curly brackets, we specify we want the integer to be formatted to hexadecimal by including a colon : followed by an x. For octal, we use o instead of x, and for binary we use b.

println!("x: {}", x);

println!("y: {:x}", y);

println!("z: {:o}", z);

println!("w: {:b}", w);

x: 42
y: 2a
z: 52
w: 101010

Integer Overflow in Rust

One more thing to talk about before moving to a floating point number is an integer overflow. Since each integer variant can only store integers of a specific range. What happens when it overflows?

Here, we have a u8 integer whose value is 255. Since 255 is the largest u8 integer, if we add 1, it overflows.

// 255 is the max u8 integer
let x: u8 = 255;

// this will cause an overflow
let x: u8 = x + 1;

When we build this program, the program won’t compile since the compiler can detect the overflow.

If the variable comes from an external source, like the command line, the compiler can’t detect an overflow if we perform arithmetic operations on it.

Here, we have a program that reads two inputs from the command line and parses them to a u8 integer, then prints the sum of those 2 integers.

fn main() {
  println!("Enter first number: ");

  let mut input = String::new();

  std::io::stdin().read_line(&mut input);

  let first_num: u8 = input.trim().parse().expect("Enter a valid u8 integer");

  println!("Enter second number: ");

  let mut input = String::new();

  std::io::stdin().read_line(&mut input);

  let second_num: u8 = input.trim().parse().expect("Enter a valid u8 integer");

  let sum = first_num + second_num;

  println!("sum: {sum}");
}

If we run this program in debug mode and enter two integers whose sum is greater than 255, the program panics.

But if we build and run this program in release mode, for the first integer enter 255, and for the second enter 1.

Enter first number: 
255
Enter second number: 
1
sum: 0

The output is 0, this is because in release mode, instead of panicking, our program wraps it from the minimum. 256 becomes 0, 257 becomes 1, and so on.

256   257   258   259   260
 :     :     :     :     : 
 0     1     2     3     4

To handle the cases of overflow explicitly, you can use the wrapping add method, which wraps it from the minimum, 255 plus 2 equals 257, and since it’s greater than 255 the maximum unsigned 8-bit integer, it is then wrapped, and x becomes 1.

let x = 255_u8.wrapping_add(2);

println!("wrapping_add : {:}", x);

wrapping_add : 1

The overflowing add method wraps the sum but returns a tuple where the first element is the wrapped sum and the second element is a boolean indicating whether the sum was wrapped. In this case, it is true since 257 was wrapped to become 1.

let y = 255_u8.overflowing_add(2);

println!("overflowing_add : {:?}", y);

overflowing_add : (1, true)

The checked add method returns the None value if it overflows, and the saturating method saturates the value at the maximum or minimum depending on where it overflowed.

let z = 255_u8.checked_add(2);

let w = 255_u8.saturating_add(2);

println!("checked_add    : {:?}", z);

println!("saturating_add : {:?}", w);

checked_add    : None
saturating_add : 255

There are similar methods for other arithmetic operations like subtraction, multiplication, division, exponential and so on.

Floats

Floating point numbers are numbers with fractional components or decimal points. In Rust, a float can be either 32 bits or 64 bits in size.

64-bit floats have higher range and precision than 32-bit floats.

Floating point types are specified with an f followed by the number of bits.

// floats (32-bit or 64-bit)

// 32-bit
let x: f32 = 3.14;

let y: f32 = 2.00;

// 64-bit
let a: f64 = 3.14;

let b: f64 = 2.00;

We can specify the type of float after the variable name and a colon or at the end of the number literal.

// floats (32-bit or 64-bit)

// 32-bit
let x = 3.14_f32;

let y = 2.00_f32;

// 64-bit
let a = 3.14_f64;

let b = 2.00_f64;

If we do not specify the type of float, it is given an f64 by default.

let a = 3.14 // => f64

A 32-bit float is a bit faster and uses less memory than a 64-bit float but it comes with less range and precision.

Below are the minimum and maximum values a 32-bit and a 64-bit float can have.

f32::MIN ->          -3.40282347E+38  
f32::MAX ->           3.40282347E+38  

f64::MIN -> -1.7976931348623157E+308  
f64::MAX ->  1.7976931348623157E+308

32-bit floats are best used in graphics & video processing where memory usage is a primary concern and their range and precision are significant for the task.

64-bit floats on the other hand are used in scientific calculations and statistical analysis where precision is very necessary.

Byte Number Literal

There is also a kind of number literal called byte, which stores ASCII character literal as an 8-bit unsigned integer.

let a = b'A'; // => u8

If we print out the variable a, we get the numerical value of the ASCII character ‘A’.

println!("b'A = {a}");

b'A' = 65

Replacing the character literal with a string literal will result in an array of bytes, which is an array of u8 integers.

let a = b"Apple";

Printing out this variable we can see it’s an array containing the numerical value of each ASCII character.

println!("{a:?}");

[65, 112, 112, 108, 101]

Thanks for reading.

References:

https://cudi.dev/articles/rust_number_types_explained

How to run Rust on the browser with Web Assembly

Augustine Madu — Sat, 18 May 2024 20:01:40 +0000

Web assembly enables the use of code written in low-level languages on the browser for faster performance.

In the tutorial below, I created two prime number checker functions one with Rust and the other with Javascript, and compared their execution speed.

The video above will also teach you about compiling Rust code to Web Assembly and running it on the browser.

I hope you find this helpful.

Create a linked list in Rust: The RC smart pointer

Augustine Madu — Thu, 25 Apr 2024 22:35:40 +0000

Hey guys. In this tutorial, I implement a linked list in Rust utilizing the RC smart pointer. You will learn about the linked list data structure as well as the Box and RC smart pointers in Rust.

There are many other things to learn here, such as the Iterator trait, setting up a test in Rust, and much more.

Here are the key highlights of the video

Linked list explained
The Box smart pointer
Getting the head of a linked list list
Pushing an element to a linked list list
The RC smart pointer
Popping an element from a linked list list
Iterating through the elements in a linked list list
Verifying if an element is contained in a linked list list
Inserting an element in a linked list
Removing an element from a linked list
Reversing a linked list

You can code along with me while watching the video and remember to give your feedback in the comments. Thank you

All joins in PostgreSQL: Tutorial

Augustine Madu — Wed, 13 Mar 2024 23:31:28 +0000

This is a comprehensive guide on all the kinds of joins in Postgres and their use cases.

This will equip you with the knowledge to effectively retrieve data across multiple tables in your Postgres database.

What you'll learn:

Understanding the concept of joins in relational databases.
Types of joins: Inner Join, Left Join, Right Join, Full Outer Join, Self Join, Cross Join, and Natural Join.
Practical applications of each join type with real-world scenarios.
Writing SQL queries to perform various joins in Postgres.

Prerequisites:

Basic understanding of relational databases.
Familiarity with basic SQL syntax.

Video Highlights:

Introduction to Joins:
- Grasp the purpose of joins in retrieving data from multiple tables.
- Recognize the role of primary and foreign keys in establishing relationships.
Types of Joins Explained:
- Inner Join: Retrieve rows where a match exists in both tables based on the join condition.
- Left Join: Include all rows from the left table, even if no match is found in the right table (null values are added for unmatched columns).
- Right Join: Similar to left join, but prioritizes the right table.
- Full Outer Join: Combine both left and right joins, including unmatched rows from both tables with null values.
- Self Join: Join a table with itself to compare data within the same table.
- Cross Join: Produces a Cartesian product, listing all possible combinations of rows from two tables (often used in conjunction with other joins).
- Natural Join: Automatically joins tables based on columns with identical names.
Practical Examples:
- Employee-Department Database Scenario: Apply different join types to retrieve relevant employee information and their departments.
- Complex Queries: Explore using joins with multiple tables for intricate data analysis.

Build a CRUD REST API with Rust Axum | Tutorial

Augustine Madu — Wed, 13 Mar 2024 16:14:07 +0000

Do you want to learn how to create a powerful backend application using Rust?

This is a tutorial on building a CRUD (Create, Read, Update, Delete) application from scratch using the Axum framework and Postgres database.

Video Highlights:

1. Project Setup

Learn how to create a new Rust project using cargo new. Configure your development environment with necessary tools.

2. Database Connection

Establish a connection to your Postgres database. Create a table to store your data.

3. Axum Framework

Discover the Axum framework for building web applications in Rust. Understand how to handle routes and requests.

4. CRUD Operations

Implement logic for creating, reading, updating, and deleting data entries. Utilize SQLx for interacting with the Postgres database.

5. Error Handling

Learn how to gracefully handle potential errors during the development process.

JWT Authentication in Rust [Full Guide: Axum and Actix]

Augustine Madu — Wed, 13 Mar 2024 15:49:43 +0000

This is a tutorial on implementing JWT (JSON Web Token) based authentication in Rust using two popular web frameworks: Axum and Actix Web.

It demonstrates essential functionalities like

JWT encoding/decoding
User information extraction from tokens
Axum and Actix web request header extractors
Route handling in Axum and Actix Web
JSON response creation

While focusing on the implementation, the video also touches upon concepts like asynchronous programming, cargo workspaces, and dependency management in Rust.

Here's the github repo, you can view and star https://github.com/cudidotdev/JWT-Authentication-with-Rust-Axum-and-Actix.git

Manacher's Algorithm - Linear Time Solution for Longest Palindrome Problem

Augustine Madu — Wed, 01 Nov 2023 16:40:38 +0000

While solving some leetcode problems. I came across problem #5, which is to find the longest palindrome substring of a string.

A palindrome is a string that reads the same forward and backward. e.g. racecar, madam. So given a string abcacbbc, the longest palindrome substring in the case will be bcacb.

There are several ways to solve this, but they come with different time and space complexities. Here are the most common solutions:

Brute-force
Dynamic programming
Expand from centers
Manacher's algorithm

The brute-force approach has a time and space complexity of $O(n^3),$ $O (n)$ respectively. While the Dynamic programming approach has a time and space complexity of $O(n^2).$

My two favorites out of the four are Manacher's algorithm and the expand-from-centers approach.

The Expand from centers approach is the most intuitive in my opinion and it has a time complexity of $O(n^2),$ and a space complexity of $O (1) .$ It is a good stepping stone for understanding Manacher's algorithm.

The Manacher's algorithm, on the other hand, is a little more difficult but has a time and space complexity of $O (n)$ and it's most optimal solution there is for now, although I don't think there exists a solution in $n)O(\log \; n)$ or in constant time, since each character in the string needs to be examined (but anything is possible, right?).

I will showcase both the expanding and the Manacher's approach in this post but I will emphasize more on Manacher's algorithm.

Expand from centers approach

In this approach, we consider the length of the palindrome.

A palindrome can be of even length or odd length.

If the palindrome is even, it will have two-like characters at its center eg. ac'bb'ca.
While that of odd length will have a center character and its sides mirror each other eg. ac'b'ca.

So, as we iterate through each character of the string. We test for even and odd palindromes with the character as its center. At the end of the palindrome, we check if the length of the palindrome is bigger than the last biggest palindrome recorded and update if it is.

The expand-from-centers method is illustrated in the diagram below. We iterated through each character with $i,$ as its index and text for even and odd palindromes.

We traverse through the characters of the string abcacbbc, testing for even palindromes (arrows at the bottom) and odd (palindromes) while keeping track of the best left and best right indices. When a palindrome reaches its end, we compare the distance of its left and right with the best recorded left and right and update if it's bigger, before moving to the next character. If no palindrome can be made from both the odd and even perspective, no comparison is made.

After traversing, we take the substring starting from the best left to the best right (inclusive) as our longest palindrome.

Manacher's Algorithm

This is the major part of this article. I will explain, each step of the algorithm in detail with illustrations, and I will give a Rust lang implementation of the algorithm at the end. For exercise, you can try converting to your primary language using both the illustration and code as guidance.

Here we need to keep track of some important variables, which are:

i - This is the index of the character at the current iteration.
center - This is the index of the center of the outermost palindrome.
right - This is the index of the right side of the outermost palindrome.
p - This is the array that stores the length of a side of the palindrome centered at each character of the string.

Steps for using the Manacher's algorithm to find the longest palindrome substring of `abcacbbc`

In the following steps, I will demonstrate Manacher's algorithm by finding the longest palindrome substring of abcacbbc.

Step 1: Adding Separators

Recall that when using the expand from centers method, since even palindromes do not have a unique center, we took both odd and even cases into consideration. To skip the case of even and odd palindromes, we can modify the string by inserting a separator # in between each character before finding the palindrome substring.

When the string is modified in this manner, we can get a center of the palindrome for both even and odd lengths. If we have a palindrome of even lengths, such as ceec, when modified the string becomes #c#e#e#c#, the modified string has an odd length, and has the fifth character # as its center. For that of odd, if we have a palindrome as bcacb, after modifying the string, we have #b#c#a#c#b# and the character a as the center of the palindrome.

So given the string abcacbbc, we modify it to #a#b#c#a#c#b#b#c#.

Step 2: Initialize variables

The primary variables for the algorithm are i, center, right, and p. You can keep a variable max_p for the maximum number in the array p and max_p_index for its index.

After adding the separator in between each character the resulting string will have a length of $2 n + 1,$ where n is the length of the original string.

The array p keeps track of the length of the sides of each palindrome p[i] centered at the character with index i in the modified string. Initialize p as an array of length $2 n + 1$ and fill with the number 0.

p : [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

The traversal will start at index 2 i = 2 since the palindrome centered at the first two characters (index 0 & 1) can be determined.

By examining the string #a#b#c#a#c#b#b#c#, we can see that at index 1, the character a is the center of the palindrome #a#. The palindrome substring #a# has 1 character at each side of its center a, therefore we update p to contain 1 at index 1. p[1] = 1. Set variables center = 1 and right = 2.

The variables are initialized as follows:

org_string: abcacbbc
mod_string: #a#b#c#a#c#b#b#c#
p: [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
i: 2
center: 1
right: 2
max_p: 1 //maximum number in p
max_p_index: 1 //index of the maximum number in p

The diagram below illustrates the string and the array p. The center is marked as the dotted line, the right is marked with R and the current character being examined is marked with the red line.

Step 3: The Travesal

In this step, we perform the algorithm for checking palindromes. In Manacher's algorithm, the steps used for checking palindromes in the expand-from-centers method are reduced using mirroring.

Mirroring is a method of avoiding character checks when testing a character within an already discovered palindrome (which we refer to as the super palindrome), by calculating the minimum of the calculated size of the palindrome centered at its mirror and the right of the super palindrome. This is best illustrated using examples.

We'll go over the string's characters one by one. Every time we iterate, we carry out the subsequent procedures:

Apply mirroring if it's within a super palindrome.
Check for palindromes centered at the character or the mirrored portion, if mirroring was applied.
Update the center and right if a palindrome was found.

We shall demonstrate these procedures with the illustrations below.

At index 2, since # is at the boundary of the palindrome #A#, mirroring won't be applied (It needs to be within the palindrome). Following that, we check if the character is the center of a palindrome. However, because a!= b, there is no palindrome centered at #, therefore proceed to the next character.

At index 3, B is outside the last palindrome #A#, therefore mirroring won't be applied. We then check if the character is the center of a palindrome.

From B, we only need to move one step outwards to get to the end of its palindrome, therefore we have a palindrome #B# centered at B. And we update p[3] = 1.

Since we have found a palindrome at index 3, we update center = 3 and right = 4 (The index of the right end of the palindrome) and move to the next character.

At index 4, since # is at the boundary of the palindrome #B#, mirroring won't be applied. Following that, we check if the character is the center of a palindrome. However, because b!= c, there is no palindrome centered at #, therefore proceed to the next character.

At index 5, C is outside the last palindrome #B#, therefore mirroring won't be applied. We then check if the character is the center of a palindrome.

From C, we only need to move one step outwards to get to the end of its palindrome, therefore we have a palindrome #C# centered at C. And we update p[5] = 1.

Since we have found a palindrome at index 5, we update center = 5 and right = 6 (The index of the right end of the palindrome) and move to the next character.

At index 6, since # is at the boundary of the palindrome #C#, mirroring won't be applied. Following that, we check if the character is the center of a palindrome. However, because c!= a, there is no palindrome centered at #, therefore proceed to the next character.

At index 7, A is outside the last palindrome #C#, therefore mirroring won't be applied. We then check if the character is the center of a palindrome.

From A, if we move 5 steps outwards, we get to the end of its palindrome, therefore we have a palindrome #B#C#A#C#B# centered at A. And we update p[7] = 5.

Since we have found a palindrome at index 5, we update center = 7 and right = 12 (The index of the right end of the palindrome) and move to the next character.

At index 8, since # is within the last palindrome #B#C#A#C#B#, we apply mirroring. Considering the center of the last palindrome A, the mirror of # at index 8 is # at index 6. Therefore we update p[8] = min(p[6], right - 8). That is the minimum between the size of its mirror p[6] and the distance between the right of the super palindrome and index 8 right - 8. Since p[6] = 0, we update p[8] = min(0, 12 - 8) = min(0, 4) = 0.

The formula for obtaining the mirror of a character at index i is 2 * center - i.

Following that, we check if there is a palindrome centered around the mirrored portion #. However, because a!= c, there is no palindrome centered at #, therefore proceed to the next character.

At index 9, since C is within the last palindrome #B#C#A#C#B#, we apply mirroring. Considering the center of the last palindrome A, the mirror of C at index 9 is C at index 5 (2 * center - 9). Therefore we update p[9] = min(p[5], right - 9) = min(1, 12 - 9) = min(1, 3) = 1.

Therefore our mirrored portion is the area one step outwards of C.

Following that, we check if there is a palindrome centered around the mirrored portion #C#. However, because a!= b, there is no palindrome centered at #C#, therefore proceed to the next character.

At index 10, since # is within the last palindrome #B#C#A#C#B#, we apply mirroring. Considering the center of the last palindrome A, the mirror of # at index 10 is # at index 4 (2 * center - 10). Therefore we update p[10] = min(p[4], right - 10) = min(0, 12 - 10) = min(0, 2) = 0.

Following that, we check if there is a palindrome centered around the mirrored portion #. However, because c!= b, there is no palindrome centered at #, therefore proceed to the next character.

At index 11, since B is within the last palindrome #B#C#A#C#B#, we apply mirroring. Considering the center of the last palindrome A, the mirror of B at index 11 is B at index 3 (2 * center - 11). Therefore we update p[11] = min(p[3], right - 11) = min(1, 12 - 11) = min(1, 1) = 1.

Therefore our mirrored portion is the area one step outwards of B.

Following that, we check if there is a palindrome centered around the mirrored portion #B#. However, because c!= b, there is no palindrome centered at #B#, therefore proceed to the next character.

At index 12, # is at the boundary of the last palindrome, therefore mirroring won't be applied. We then check if the character is the center of a palindrome.

From #, if we move 4 steps outwards, we get to the end of its palindrome, therefore we have a palindrome #C#B#B#C# centered at #. And we update p[12] = 4.

Since we have found a palindrome at index 12, we update center = 12 and right = 16 (The index of the right end of the palindrome) and move to the next character.

At index 13, since B is within the last palindrome #C#B#B#C#, we apply mirroring. Considering the center of the last palindrome #, the mirror of B at index 13 is B at index 11 (2 * center - 13). Therefore we update p[13] = min(p[11], right - 13) = min(1, 16 - 13) = min(1, 3) = 1.

Therefore our mirrored portion is the area one step outwards of B.

Following that, we check if there is a palindrome centered around the mirrored portion #B#. However, because b != c, there is no palindrome centered at #B#, therefore proceed to the next character.

At index 14, since # is within the last palindrome, we apply mirroring. Considering the center of the last palindrome #, the mirror of # at index 14 is # at index 10 (2 * center - 14). Therefore we update p[14] = min(p[10], right - 14) = min(0, 16 - 14) = min(0, 2) = 0.

Following that, we check if there is a palindrome centered around the mirrored portion #. However, because b!= c, there is no palindrome centered at #, therefore proceed to the next character.

At index 15, since C is within the last palindrome, we apply mirroring. Considering the center of the last palindrome #, the mirror of C at index 15 is C at index 9 (2 * center - 15). Therefore we update p[15] = min(p[9], right - 15) = min(1, 16 - 15) = min(1, 1) = 1.

Therefore our mirrored portion is the area one step outwards of C.

Following that, we check if there is a palindrome centered around the mirrored portion #C#. But since we are at the end of the string, we end the iteration.

Step 4: Slice the Substring and Remove the Separators

During the iteration, you will need to keep track of the index of the maximum element of the array p. In our case, the maximum element is at index 7 and p[7] = 5.

Therefore we take the slice of the string starting from index 2 = 7 - 5 to index 12 = 7 + 5 including the last index. Hence our substring is #B#C#A#C#B#.

Finally, we filter out the separators # and we get our longest palindrome substring as BCACB

Thanks for reading. If you found this helpful, please support by liking and sharing with your friends and colleagues. This took me a lot of time to prepare. Thanks once more.

You can contact me via email at augustinemadu9@gmail.com. Follow me on X @CudiLala_.

Here is the Rust lang implementation of Manacher's algorithm.

pub fn longest_palindrome(s: String) -> String {
  //modify string by adding separators
  let s: Vec<u8> = s
    .bytes()
    .flat_map(|b| [b'#', b])
    .chain("#".bytes())
    .collect();

  let n = s.len();

  let mut p = vec![0; n];

  p[1] = 1;

  let mut i = 2;
  let mut center = 1;
  let mut right = 2;
  let mut max_p = 1;
  let mut max_p_index = 1;

  while i < n {
    //if the character is within the last palindrome
    if i < right {
      //mirroring

      //index of the mirror of the current character
      let i_mirror = 2 * center - i;

      //minimum of between the size of its mirror and the distance to the right
      p[i] = p[i_mirror].min(right - i);
    }

    //test for palindrome centered around the character or mirrored portion
    while i - p[i] > 0 && i + p[i] + 1 < n && s[i - p[i] - 1] == s[i + p[i] + 1] {
      p[i] += 1
    }

    //update center and right if palindrome is found
    if i + p[1] > right {
      center = i;
      right = i + p[i];
    }

    //update if the palindrome centered at the current character is bigger
    if p[i] > max_p {
      max_p = p[i];
      max_p_index = i;
    }
    i += 1;
  }

  //select substring and remove separators
  s.into_iter()
    .skip(max_p_index - max_p + 1)
    .take(2 * max_p - 1)
    .filter(|u| *u != b'#')
    .map(|u| u as char)
    .collect()
}

Have a nice day!

DEV Community: Augustine Madu

How to test Asynchronous Rust Programs with Tokio [TUTORIAL]

Lifetimes in Rust Explained with Examples

Example 1

Example 2

Example 3

Example 4

Example 5

Example 6

Static Lifetimes

Specifying Lifetimes in a Struct

Borrowing and References in Rust Explained

Recap on Rust Ownership Model

References and Borrowing in Rust

Mutable and Immutable References

Introduction to Lifetimes

Rust ownership System Explained

The Stack and Heap

Rust Ownership Model

References and Borrowing in Rust

Rust number types explained

Signed and Unsigned Integers

Representing integer literals in Rust

Integer Overflow in Rust

Floats

Byte Number Literal

How to run Rust on the browser with Web Assembly

Create a linked list in Rust: The RC smart pointer

All joins in PostgreSQL: Tutorial

Build a CRUD REST API with Rust Axum | Tutorial

Video Highlights:

1. Project Setup

2. Database Connection

3. Axum Framework

4. CRUD Operations

5. Error Handling

JWT Authentication in Rust [Full Guide: Axum and Actix]

Manacher's Algorithm - Linear Time Solution for Longest Palindrome Problem

Expand from centers approach

Manacher's Algorithm

Steps for using the Manacher's algorithm to find the longest palindrome substring of abcacbbc

Step 1: Adding Separators

Step 2: Initialize variables

Step 3: The Travesal

Step 4: Slice the Substring and Remove the Separators

Steps for using the Manacher's algorithm to find the longest palindrome substring of `abcacbbc`