Forem: Sivakumar

Rust: Working with Regular Expressions

Sivakumar — Tue, 02 May 2023 14:21:37 +0000

Regular Expressions is a way to describe sets of characters using syntactic rules. Like many programming languages, Rust also has a great support of regular expressions.

A regular expression processor is used for processing a regular expression statement in terms of a grammar in a given formal language, and with that examines a text string.

Crate regex

This crate provides a library for parsing, compiling, and executing regular expressions. Its syntax is similar to Perl-style regular expressions, but lacks a few features like look around and backreferences. In exchange, all searches execute in linear time with respect to the size of the regular expression and search text.

Let us see some of the examples

Parsing Integers

With regex, it is pretty easy to check if given input contains valid integers

    let re_int = Regex::new(r"\d").unwrap();
    println!("Is 100 is valid integer? {}", re_int.is_match("100"));
    println!("Is HelloWorld is valid integer? {}", re_int.is_match("HelloWorld"));

This code generates below output

Is 100 is valid integer? true
Is HelloWorld is valid integer? false

Parsing String

If we need to check if given input contains only alphabets, it is very easy to check using [[:alpha]] expression

    let re_str = Regex::new(r"[[:alpha]]").unwrap();
    println!("Is 100 is valid alphabet? {}", re_str.is_match("100"));
    println!("Is HelloWorld is valid alphabet? {}", re_str.is_match("HelloWorld"));

This code generates below output

Is 100 is valid alphabet? false
Is HelloWorld is valid alphabet? true

Parsing Date

This is one of a quite common use case where we need to verify user inputted date is a valid or not

    let re_ymd = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
    println!("Is 2023-01-01 matching against YYYY-MM-DD? {}", re_ymd.is_match("2023-01-01"));
    println!("Is 01-01-2023 matching against YYYY-MM-DD? {}", re_ymd.is_match("01-01-2023"));

This code generates below output

Is 2023-01-01 matching against YYYY-MM-DD? true
Is 01-01-2023 matching against YYYY-MM-DD? false

Supported Expressions

regex crate supports wide variety of expression patterns. Let us explore them here

Matching one character

.             any character except new line (includes new line with s flag)
\d            digit (\p{Nd})
\D            not digit
\pX           Unicode character class identified by a one-letter name
\p{Greek}     Unicode character class (general category or script)
\PX           Negated Unicode character class identified by a one-letter name
\P{Greek}     negated Unicode character class (general category or script)

Character classes

[xyz]         A character class matching either x, y or z (union).
[^xyz]        A character class matching any character except x, y and z.
[a-z]         A character class matching any character in range a-z.
[[:alpha:]]   ASCII character class ([A-Za-z])
[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])
[x[^xyz]]     Nested/grouping character class (matching any character except y and z)
[a-y&&xyz]    Intersection (matching x or y)
[0-9&&[^4]]   Subtraction using intersection and negation (matching 0-9 except 4)
[0-9--4]      Direct subtraction (matching 0-9 except 4)
[a-g~~b-h]    Symmetric difference (matching `a` and `h` only)
[\[\]]        Escaping in character classes (matching [ or ])

Composites

xy    concatenation (x followed by y)
x|y   alternation (x or y, prefer x)

Repetitions

x*        zero or more of x (greedy)
x+        one or more of x (greedy)
x?        zero or one of x (greedy)
x*?       zero or more of x (ungreedy/lazy)
x+?       one or more of x (ungreedy/lazy)
x??       zero or one of x (ungreedy/lazy)
x{n,m}    at least n x and at most m x (greedy)
x{n,}     at least n x (greedy)
x{n}      exactly n x
x{n,m}?   at least n x and at most m x (ungreedy/lazy)
x{n,}?    at least n x (ungreedy/lazy)
x{n}?     exactly n x

Empty matches

^     the beginning of text (or start-of-line with multi-line mode)
$     the end of text (or end-of-line with multi-line mode)
\A    only the beginning of text (even with multi-line mode enabled)
\z    only the end of text (even with multi-line mode enabled)
\b    a Unicode word boundary (\w on one side and \W, \A, or \z on other)
\B    not a Unicode word boundary

Grouping and flags

(exp)          numbered capture group (indexed by opening parenthesis)
(?P<name>exp)  named (also numbered) capture group (names must be alpha-numeric)
(?<name>exp)   named (also numbered) capture group (names must be alpha-numeric)
(?:exp)        non-capturing group
(?flags)       set flags within current group
(?flags:exp)   set flags for exp (non-capturing)

Escape sequences

\*          literal *, works for any punctuation character: \.+*?()|[]{}^$
\a          bell (\x07)
\f          form feed (\x0C)
\t          horizontal tab
\n          new line
\r          carriage return
\v          vertical tab (\x0B)
\123        octal character code (up to three digits) (when enabled)
\x7F        hex character code (exactly two digits)
\x{10FFFF}  any hex character code corresponding to a Unicode code point
\u007F      hex character code (exactly four digits)
\u{7F}      any hex character code corresponding to a Unicode code point
\U0000007F  hex character code (exactly eight digits)
\U{7F}      any hex character code corresponding to a Unicode code point

ASCII character classes

[[:alnum:]]    alphanumeric ([0-9A-Za-z])
[[:alpha:]]    alphabetic ([A-Za-z])
[[:ascii:]]    ASCII ([\x00-\x7F])
[[:blank:]]    blank ([\t ])
[[:cntrl:]]    control ([\x00-\x1F\x7F])
[[:digit:]]    digits ([0-9])
[[:graph:]]    graphical ([!-~])
[[:lower:]]    lower case ([a-z])
[[:print:]]    printable ([ -~])
[[:punct:]]    punctuation ([!-/:-@\[-`{-~])
[[:space:]]    whitespace ([\t\n\v\f\r ])
[[:upper:]]    upper case ([A-Z])
[[:word:]]     word characters ([0-9A-Za-z_])
[[:xdigit:]]   hex digit ([0-9A-Fa-f])

Hope this blog post gives you deep dive view of regular expressions and how to use them in rust. You can get the code samples from this link

Please feel free to share your comments if any

Happy reading!!!

Pattern Matching using Match Construct

Sivakumar — Mon, 01 May 2023 11:41:40 +0000

In this blog post, let us see one of a powerful feature of Rust match. Rust has an extremely powerful control flow construct called match that allows you to compare a value against a series of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable names, wildcards, and many other things. The power of match comes from the expressiveness of the patterns and the fact that the compiler confirms that all possible cases are handled.

Syntax

match VALUE {
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
}

Matching Literals

match construct can be used to check literals.

    let x = 10;

    match x {
        10 => println!("Ten"),
        20 => println!("Twenty"),
        30 => println!("Thirty"),
        _ => println!("Others"),
    }

Matching Named Variables

match construct starts a new scope variables declared as part of a pattern inside the match expression will shadow those with the same name outside the match construct, as is the case with all variables. In the below example, we declare a variable named a with the value Some(1) and a variable b with the value 2. We then create a match expression on the value a.

    let x = Some(1);
    let y = 2;

    match x {
        Some(10) => println!("We got the value 10"),
        Some(y) => println!("Matched, y = {y}"),
        _ => println!("Default case, x = {:?}", x),
    }

    println!("Out of the match construct: x = {:?}, y = {y}", x);

The above code produces below output

We got the value 1
Out of the match construct: x = Some(1), y = 2

Matching Multiple Patterns

match construct supports matching multiple patterns using the | syntax, which is the pattern or operator. Lets check this below example

    let a = 10;

    match a {
        10 | 20 => println!("Ten or Twenty"),
        3 => println!("Thirty"),
        _ => println!("Not in the range"),
    }

In the above code we match the value of a against the match arms, the first of which has an or option, meaning if the value of a matches either of the values in that arm. The above code produces below output

Ten or Twenty

Matching Ranges of Values with ..=

match construct supports the ..= syntax which allows us to match to an inclusive range of values.

    let a = 10;

    match a {
        1..=9 => println!("Between one to nine"),
        10..=20 => println!("Between ten to twenty"),
        _ => println!("Not in the range"),
    }

In the above code, when a pattern matches any of the values within the given range, that arm will execute. The above code produces below output

Between ten to twenty

Matching Structs

match construct also works with struct. In the below code, we have a Point struct with two fields named x and y. When the match arm matches any or all of the values, the corresponding arm will get executed. In the below example, we've a point struct with field values x=0 and y=10 hence the 2nd match arm Point { x: 0, y } gets executed.

    let p = Point { x: 0, y: 10 };

    match p {
        Point { x, y: 0 } => println!("On the x axis at {x}"),
        Point { x: 0, y } => println!("On the y axis at {y}"),
        Point { x, y } => {
            println!("On neither axis: ({x}, {y})");
        }
    }

The above code produces below output

On the y axis at 10

Matching Enums

match construct also works with enum like struct. We can deconstruct enum using match construct. Let us see an example below

    enum Message {
        Exit,
        Point { x: i32, y: i32 },
        Print(String),
       RGB (i32, i32, i32),
    }

    let m = Message::Print(String::from("Hello World"));
    match m {
        Message::Exit => {
            println!("Exit Enum");
        }
        Message::Point { x, y } => {
            println!("Point with x axis {x} and y axis {y}");
        }
        Message::Print(text) => {
            println!("Printing message: {text}");
        }
        Message::RGB(r, g, b) => {
            println!("Red {r}, Green {g}, and Blue {b}",)
        }
    }

In the above code, we have Message enum with Print variant. When we deconstruct this enum using match, the corresponding arm gets executed and produces below output

Printing message: Hello World

Ignoring Values in Match Pattern

We've seen that it’s sometimes useful to ignore values in a pattern, such as in the last arm of a match, to get a catchall that doesn’t actually do anything but does account for all remaining possible values. There are a few ways to ignore entire values or parts of values in a pattern: using the _ pattern, using the _ pattern within another pattern, using a name that starts with an underscore, or using .. to ignore remaining parts of a value. Let’s explore how and why to use each of these patterns.

Ignoring an Entire Value with _

It is possible to ignore entire value using _. In the below example, we have two variables a and b. We're checking if the values ofbhas an exact match ignoring whatever the values ofa`.

`
let a = 5;
let b = 10;

match (a, b) {
    (_, 10) => println!("Ignored a but matched b which is having value 10"),
    _ => println!("All othe cases")
}

Ignoring Remaining Parts of a Value with ..

We can use .. to ignore remaining parts of value in the match.

`
let x = 1;
let y = 2;
let z = 3;

match (x, y, z) {
    (1, ..) => println!("x is 1 but ignored the other values"),
    _ => println!("All other cases")
}

Extra Conditionals with Match Guards

A match guard is an additional if condition, specified after the pattern in a match arm, that must also match for that arm to be chosen. Match guards are useful for expressing more complex ideas than a pattern alone allows.

`
let number = 50;

match number {
    x if x % 10 == 0 => println!("{x} is divisable by 10"),
    x if x % 3 == 0 => println!("{x} is divisable by 3"),
    _ => println!("All other cases")
}

In the above code example, we've match arm with extra condition to test more specific case.

Hope this blog post gives you detailed insight of enum construct. You can get the code samples from this link

Please feel free to share your comments if any

Happy reading!!!

Rust Macros

Sivakumar — Sun, 05 Mar 2023 12:05:21 +0000

In this blog post, let us explore more in detail how to work with Macros in Rust

What are Macros?

Macros are a way of writing code that writes other code, which is known as metaprogramming

Metaprogramming is useful for reducing the amount of code you write and maintain, which is also one of the roles of functions. However, macros have some additional powers that functions don’t.

Types of Macros

There are two kinds of macros: Declarative and Procedural

Declarative Macros

It is a most used form of macros in Rust. Also referred to as “macros by example”, “macro_rules! macros”. Allows you to write something similar to match expression

To define a macro, we use macro_rules! Construct. We use #[macro_export] annotation to indicate that this macro should be made available whenever the crate in which the macro is defined is brought into scope.

Declarative Macros Syntax

#[macro_export]
macro_rules! <name of macro> {
    ( $( $x:expr ),* ) => {
        {
            <implementation>
        }
    };
}

Procedural Macros

It acts more like a function (and is a type of procedural)

Accepts some code as an input, operates on that code, and produces some code as an output rather than matching against patterns and replacing the code with other code as declarative macros do.

Three kinds of procedural macros:

Derive

Derive macros define new inputs for the derive attribute. These macros can create new items given the token stream of a struct, enum, or union. They can also derive macro helper attributes.

Derive Procedural Macros Syntax

extern crate proc_macro;
use proc_macro::TokenStream;

#[proc_macro_derive(<Name of Derive Macro>)]
pub fn derive_macro(_item: TokenStream) -> TokenStream {
    <Implementation>
}

Attribute-like

Attribute macros define new outer attributes which can be attached to items, including items in extern blocks, inherent and trait implementations, and trait definitions.

Attribute Procedural Macros Syntax

extern crate proc_macro;
use proc_macro::TokenStream;

#[proc_macro_attribute] 
pub fn <Attribute Name>(_attr: TokenStream, item: TokenStream) -> TokenStream { 
<Implementation> 
}

Function-like

Function-like procedural macros are procedural macros that are invoked using the macro invocation operator (!)

Function-like Procedural Macros Syntax

extern crate proc_macro;
use proc_macro::TokenStream;

#[proc_macro]
pub fn <Macro Name>(_item: TokenStream) -> TokenStream {
    <Implementation>
}

Macros vs Functions

Macros are more complex to implement than function definitions because we’re writing Rust code that writes Rust code.

Macro definitions are generally more difficult to read, understand and maintain than function definitions

Macros must define first or bring them into scope before you call in a file, as opposed to functions you can define anywhere and call anywhere

Please feel free to share your comments if any

Happy reading!!!

Slices in Rust

Sivakumar — Sun, 05 Feb 2023 13:33:51 +0000

In this short blog post, we'll explore about Slice in Rust

Slice

A dynamically-sized view into a contiguous sequence. Contiguous here means that elements are laid out so that every element is the same distance from its neighbors
Slices are a view into a block of memory represented as a pointer and a length
Slices are either mutable or shared. The shared slice type is &T, while mutable slice type is &mut T, where T represents the element type
As slices store the length of the sequence they refer to, they have twice the size of pointers to Sized types (i.e., types with a constant size known at compile time)

Slice Examples

In this below example, we're creating an integer array and then getting slice out of it

    // Declaring integer array
    let i_arr = [1, 2, 3, 4, 5, 6];

    // Getting slice array from main array 
    let i_slice_arr = &i_arr[..];

    // Using slice, iterating through all the elements of sliced integers
    i_slice_arr.iter().for_each(|x| print!("{x}, "));

It is possible get sub-set of an array as slice. We need to provide start and end index as below. In this example, we're getting elements from index 2 and 4.

    // it is possible to slice out sub-set of it
    i_slice_arr[2..5].iter().for_each(|x| print!("{x}, "));

If you want to get get element including end-index, we need to add = sign as below.

    // it is possible to slice out sub-set of it
    i_slice_arr[2..=5].iter().for_each(|x| print!("{x}, "));

It will be a panic, in case if the index goes out-of-range

    // it is possible to slice out sub-set of it
    i_slice_arr[2..=8].iter().for_each(|x| print!("{x}, "));

If we need to mutate the values of an array using slicing operation, we can get mutable iterator using iter_mut method as below. Prior to get mutable iterator, we must declare the underlying array as mutable using mut

    // Declaring integer array
    let mut i_arr = [1, 2, 3, 4, 5, 6];

    // Getting slice array from main array 
    let i_slice_arr = &mut i_arr[..];

    // Using slice, mutably iterating through the elements and change its values of the sliced integers
    // When we iterate mutably, underlying variable must be declared with mut keyword
    i_slice_arr.iter_mut().map(|x| *x * 2).for_each(|x| print!("{x}, "));

It is possible to have windows operation over slice. We can use windows or chunks method to iterate slice. In the below example, we use chunks method. On each iteration, we get a chunk size of 2 which is apparently a integer array

    i_slice_arr.chunks(2).for_each(|x| print!("{x:?}"));

Like Arrays, we can also slice over String. In the below example, we iterator over str slice, which is a char array, filter the elements that matches a given condition and then printing the same

    let s = String::from("Rust is awesome");
    let _ = &s[4..10].chars().filter(|c| c.is_ascii_lowercase()).for_each(|x| print!("{x}, "));

You can get the full source code from this link

Please feel free to share your comments if any

Happy reading!!!

Rust: Expect vs Unwrap vs ?

Sivakumar — Tue, 24 Jan 2023 14:12:21 +0000

In the previous posts about Option and Result type in Rust language, we have seen the various ways to extract values from them. In this blog post, we're going to explore the difference between expect, unwrap and ? operator in Rust

Expect method

expect method can be used in Option or Result to provide user-defined message when in case of panic

    // Declaring variable with Ok() variant of Result type
    let a: Result<i32, &str> = Ok(100);

    // expect() method panics with a provided custom message
    println!("Value of variable a => {}", a.expect("Variable cannot be empty"));

Unwrap method

unwrap method can be used in Option or Result to return generic system-defined message when in case of panic

    // Declaring variable with Ok() variant of Result type
    let a: Result<i32, &str> = Ok(100);

    // unwrap() method panics with a generic message
    println!("Value of variable a => {}", a.unwrap());

? Operator

? operator can be used only for Result type. When there are too many function calls that returns Result type, error handling will be tedious tasks if you would like to propagate errors up to the call stack. In such case, using ? manages some of the boilerplate of propagating errors.

In this code example, let us see how to propagate errors without using ? operator.

fn print_me(n: i32) -> Result<i32, String> {
    if n < 5 {
        Ok(n)
    } else {
        Err(format!("Given input {n} is invalid!!!"))
    }
}

fn main() -> Result<(), String> {
    // Declaring variable with Ok() variant of Result type
    let a: Result<i32, &str> = Ok(100);

    // expect() method panics with a provided custom message
    println!("Value of variable a => {}", a.expect("Variable cannot be empty"));

    // unwrap() method panics with a generic message
    println!("Value of variable a => {}", a.unwrap());

    // When there is no ? operator to propagate errors
    let r = print_me(2);
    if let Err(x) = r {
        return Err(x)
    }

    let r = print_me(30);
    if let Err(x) = r {
        return Err(x)
    }
    return Ok(())
}

If you notice, for every function call print_me, we are doing error handling and when in case of Err variant, we're propagating errors up to the call stack.

In contrast, let us see how to propagate errors by using ? operator.

fn print_me(n: i32) -> Result<i32, String> {
    if n < 5 {
        Ok(n)
    } else {
        Err(format!("Given input {n} is invalid!!!"))
    }
}

fn main() -> Result<(), String> {
    // Declaring variable with Ok() variant of Result type
    let a: Result<i32, &str> = Ok(100);

    // expect() method panics with a provided custom message
    println!("Value of variable a => {}", a.expect("Variable cannot be empty"));

    // unwrap() method panics with a generic message
    println!("Value of variable a => {}", a.unwrap());

    // Propagate errors using ? operator
    print_me(2)?;
    print_me(30)?;
    return Ok(())
}

I hope you've enjoyed reading this blog post and it helps to understand the differences between expect, unwrap and ? operator usages in Rust language.

You can access the code example used in this blog post from this link.

Please feel free to share your comments if any.

Happy reading!!!

Result type in Rust

Sivakumar — Tue, 24 Jan 2023 13:15:53 +0000

In this blog post, we're going to see how to work with Result type in Rust

Result

Result is a type used for returning and propagating errors in Rust. It is an Enum type which has 2 variants such as Ok' andErr'. Ok represents success and containing value and Err representing error and containing an error value

Variable Initiation

    // Declaring variable with Ok() variant of Result type
    let a: Result<i32, &str> = Ok(100);

    // Declaring variable with Err() variant of Result type
    let b: Result<i32, &str> = Err("Invalid input provided");

Extracting Values from Result

Extracting values from Result can be done using various ways

if-let statement

    // Get value of Result type's Ok() variant
    if let Ok(x) = a {
        println!("Extracted value from 'a' is => {x}");
    }

    // Get value of Result type's Err() variant
    if let Err(x) = b {
        println!("Extracted value from 'b' is => {x}");
    }

match expression

    match a {
        Ok(x) => println!("Extracted Ok() variant's value from 'a' is => {x}"),
        Err(x) => println!("Extracted Err() variant's value from 'a' is => {x}"),
    }

    match b {
        Ok(x) => println!("Extracted Ok() variant's value from 'b' is => {x}"),
        Err(x) => println!("Extracted Err() variant's value from 'b' is => {x}"),
    }

expect method

expect method panics with a provided custom message when the variable is of Err variant

    println!("Value of variable a => {}", a.expect("Variable cannot be empty"));

unwrap method

unwrap method panics with a generic message when the variable is of Err variant

    println!("Value of variable a => {}", a.unwrap());

unwrap_or method

unwrap_or method returns value of Ok() variant OR specified value

    println!("Value of variable a => {}", a.unwrap_or(0));

unwrap_or_default method

unwrap_or_default method returns value of Ok() variant OR default value of underlying type

    println!("Value of variable a => {}", a.unwrap_or_default());

unwrap_or_else method

unwrap_or_else method returns value of Ok() variant OR returns the value of the function argument

    println!("Value of variable a => {}", a.unwrap_or_else(|x| x.len() as i32));

expect_err method

expect_err method panics with a provided custom message

    println!("Value of variable a => {}", b.expect_err("Variable cannot be empty"));

unwrap_err method

unwrap_err method panics with a generic message

    println!("Value of variable a => {}", b.unwrap_err());

Comparing Result Variables

It is possible to compare 2 Result variables in Rust

    if a > b {
        println!("Variable value a is greater than value of variable b");
    } else {
        println!("Variable value a is less than value of variable b");
    }

Iterating over Result

A Result can be iterated over. It is possible to call FromIterator trait's method on a Result. In case if a Result array contains Err, the resulted operation would be Err as well.

In this below example, we're creating a Result array having mixed of Ok and Err variants

    let r_arr = [Ok(10), Ok(20), Err("Invalid user input"), Ok(30)];

Collecting elements from Result array

We'll apply FromIterator trait's into_iter method and call collect method on it. This will result in Err variant

    let result_1: Result<Vec<i32>, &str> = r_arr.into_iter().collect();
    println!("Collect the elements => {result_1:?}");

Filter Result array and collect elements

We'll apply FromIterator trait's filter method and call collect method on it. This time, the result will be Result<Vec<i32>>

    let result_2: Result<Vec<i32>, &str> = r_arr.into_iter().filter(|x| x.is_ok()).collect();
    println!("Filter & collect the elements => {result_2:?}");

Sum method on Result array

We'll apply FromIterator trait's sum method and as it is having Err variant, the result will be of Err variant

    let result_3: Result<i32, &str> = r_arr.into_iter().sum();
    println!("Sum of all elements without filter => {result_3:?}");

Product method on Result array

We'll apply FromIterator trait's product method and as it is having Err variant, the result will be of Err variant

    let result_4: Result<i32, &str> = r_arr.into_iter().product();
    println!("Product of all elements without filter => {result_4:?}");

Filter & Sum method on Result array

Filter the option array and then call FromIterator trait's sum method. The result will be of Result<i32, &str> type

    let result_3: Result<i32, &str> = r_arr.into_iter().filter(|x| x.is_ok()).sum();
    println!("Sum of all elements after filter => {result_3:?}");

Filter & Product method on Result array

Filter the option array and then call FromIterator trait's product method. The result will be of Result<i32, &str> variant

    let result_4: Result<i32, &str> = r_arr.into_iter().filter(|x| x.is_ok()).product();
    println!("Product of all elements after filter => {result_4:?}");

I hope this blog post gives you a brief overview about Result type.

All the code examples can be found in this link.

Please feel free to share your feedback.

Happy reading!!!

Options in Rust

Sivakumar — Tue, 24 Jan 2023 10:43:09 +0000

In this blog post, we're going to see how to work with Options in Rust

Options

Since Rust doesn't support Nulls instead it has Optional value. Option is an Enum type which has 2 variants such as Some and None

Use cases

Following are some of the use cases with Option in Rust

Variable Initiation
Function return values
Return values for otherwise reporting simple errors
Optional struct fields
Optional functional arguments

Variable Initiation

    // Declaring variable with None
    let a: Option<i32> = None;

    // Declaring variable with Some(100)
    let b: Option<i32> = Some(100);

Extracting Values from Option

Extracting values from Option can be done using various ways

if-let statement

    if let Some(x) = a {
        println!("Value of variable a => {x}");
    }

match expression

    match b {
        Some(x) => println!("Value of variable b => {x}"),
        None => println!("Value of variable b => None"),
    }

expect method

expect method panics with a provided custom message when the variable is of None variant

    println!("Value of variable a => {}", b.expect("Variable cannot be empty"));

unwrap method

unwrap method panics with a generic message when the variable is of None variant

    println!("Value of variable a => {}", b.unwrap());

unwrap_or method

unwrap_or method returns value of variable OR specified value

    println!("Value of variable a => {}", a.unwrap_or(0));

unwrap_or_default method

unwrap_or_default method returns value of variable OR default value of underlying type

    println!("Value of variable a => {}", a.unwrap_or_default());

unwrap_or_else method

unwrap_or_else method returns value of variable OR returns the value of the function argument

    println!("Value of variable a => {}", a.unwrap_or_else(|| 10));

Comparing Option Variables

It is possible to compare 2 option variables in Rust

    if a > b {
        println!("Variable value a is greater than value of variable b");
    } else {
        println!("Variable value a is less than value of variable b");
    }

Iterating over Option

An Option can be iterated over. It is possible to call FromIterator trait's method on an Option. In case if an Option array contains None, the resulted operation would be None as well.

In this below example, we're creating an Option array having mixed of Some and None variants

  let o_arr = [Some(10), Some(20), None, Some(30)];

Collecting elements from an Option array

We'll apply FromIterator trait's into_iter method and call collect method on it. This will result in None variant

    let result_1: Option<Vec<i32>> = o_arr.into_iter().collect();
    println!("Collect the elements => {result_1:?}");

Filter Option array and collect elements

We'll apply FromIterator trait's filter method and call collect method on it. This time, the result will be Some<Vec<i32>>

    let result_2: Option<Vec<i32>> = o_arr.into_iter().filter(|x| x.is_some()).collect();
    println!("Filter & collect the elements => {result_2:?}");

Sum method on an Option array

We'll apply FromIterator trait's sum method and as it is having None variant, the result will be of None variant

    let result_3: Option<i32> = o_arr.into_iter().sum();
    println!("Sum of all elements without filter => {result_3:?}");

Product method on an Option array

We'll apply FromIterator trait's product method and as it is having None variant, the result will be of None variant

    let result_4: Option<i32> = o_arr.into_iter().product();
    println!("Product of all elements without filter => {result_4:?}");

Filter & Sum method on an Option array

Filter the option array and then call FromIterator trait's sum method. The result will be of Some<i32> variant

    let result_3: Option<i32> = o_arr.into_iter().filter(|x| x.is_some()).sum();
    println!("Sum of all elements after filter => {result_3:?}");

Filter & Product method on an Option array

Filter the option array and then call FromIterator trait's product method. The result will be of Some<i32> variant

    let result_4: Option<i32> = o_arr.into_iter().filter(|x| x.is_some()).product();
    println!("Product of all elements after filter => {result_4:?}");

I hope this blog post gives you a brief overview about Options.

All the code examples can be found in this link.

Please feel free to share your feedback.

Happy reading!!!

Working with Enums in Rust

Sivakumar — Tue, 24 Jan 2023 07:12:01 +0000

In this blog post, we're going to see how to work with Enums in Rust

Enums

Enum is a type that can be any one of several variants. It is also called as Algebraic Data Types (ADT). Unlike other programming languages (ex: C), Enums in Rust can store data with it.

Enums helps to keep the code more concise. It eliminates the necessity to create multiple structs.

Declaring Enums

Enums can be declared using various ways.

Standard Enums

In this approach, declaring Enums just like any other programming language

enum Ack {
    ExactlyOnce,
    AtMostOnce,
    AtLeastOnce
}

Complex Enums

If you would like to store data with Enum, you can use this approach. In this below example, we're creating an Enum which store variety of types with its variants

enum EnhancedAck {
    ExactlyOnce,
    AtMostOnce(String),
    AtLeastOnce(i32, String)
}

Empty Enums

It is possible to create Empty Enums in Rust. This is also called as Zero-Sized Types. The main use case for an Empty Enum is type-level unreachability. For instance, suppose an API needs to return a Result in general, but a specific case actually is infallible.

enum Void {
}

Instantiating Standard Enums

Let us see how to instantiate Standard Enums. Instantiating Enum variants involves explicitly using the Enum’s name as its namespace, followed by one of its variants.

    let a = Ack::ExactlyOnce;
    println!("Received acknowledge {a:#?}");

Instantiating Complex Enums

When we've complex Enums like EnhancedAck Enum we've seen above, we need to specify the values as if we pass function arguments.

In case if you would like to access the data stored along with Enum variant, we can make use of if let statement to retrieve the values as below

    let b = EnhancedAck::ExactlyOnce;
    println!("Received Acknowledge: {b:?}");

    let c = EnhancedAck::AtMostOnce(String::from("Hello Rust"));
    println!("Received Acknowledge: {c:?}");
    if let EnhancedAck::AtMostOnce(c1) = c {
        println!("Extracted data from Enum --> Message: {}", c1);
    }

    let d = EnhancedAck::AtLeastOnce(100, String::from("Hello Rust Again"));
    println!("Received Acknowledge: {d:?}");
    if let EnhancedAck::AtLeastOnce(d1, d2) = d {
        println!("Extracted data from Enum --> Number: {}, Message: {}", d1, d2);
    }

I hope this blog post gives you a brief overview about Enums.

All the code examples can be found in this link.

Please feel free to share your feedback.

Happy reading!!!

REST API Implementation in Rust

Sivakumar — Sat, 21 Jan 2023 04:44:18 +0000

In this blog post, let us see how to build a simple REST API in Rust.

Pre-requisites

Cargo
PostgreSQL
Environment variable DATABASE_URL configured with postgres database URL

Crates used in this example project

Following crates are used in this project

actix_rt: Tokio-based single threaded async runtime for the Actix ecosystem
actix_web: Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust
serde: A generic serialization/deserialization framework
serde_json: A JSON serialization file format
chrono: Data and time library
uuid: A library to generate and parse UUID
env_logger: A logging implementation for ==log== which is configured via an environment variable
diesel: A safe, extensible ORM framework and Query builder
r2d2: A generic connection pool
r2d2-diesel: r2d2 support for Diesel ORM

Setup

PostgreSQL Table schema

I am creating below tables in test schema in PostgreSQL DB. In case if you intend to use different schema, please use that as well. Make sure to specify correct schema in DATABASE_URL environment variable as well.

Ex:

set DATABASE_URL=postgres://postgres:postgres@localhost:5432/testdb?options=-c%20search_path%3Dtest

I am going to create 2 tables. One for storing Tweets and another one is to keep tracking the likes for each Tweet. Create table scripts for the 2 tables as below:

create table test.tweets (
id uuid not null primary key, 
created_at timestamp not null, 
message varchar(500)
);

create table test.likes (
id uuid not null primary key, 
created_at timestamp not null, 
tweet_id uuid not null references test.tweets(id));

Checkout the sample project

You can do git clone this project to your local machine

git clone https://github.com/sivakumar-sivaprakasam/simple_twitter_rest_api.git

Launch the application

Once the pre-requisites are well configured, please run cargo run to launch the application. You can use below CURL commands to test the application

Post a tweet

curl -X POST -d "{\"message\": \"This is a tweet\"}" -H "Content-type: application/json" http://localhost:9090/tweets

Retrieve all tweets

curl http://localhost:9090/tweets

Get a specific tweet

curl http://localhost:9090/tweets/{id}

Like a tweet

curl -X POST http://localhost:9090/tweets/{id}/likes

Unlike a tweet

curl -X DELETE http://localhost:9090/tweets/{id}/likes

Delete a tweet

curl -X DELETE http://localhost:9090/tweets/{id}

Please feel free to share your comments.

Happy exploring rust !!!

Rust Traits

Sivakumar — Sat, 21 Jan 2023 03:52:12 +0000

In this blog post, let us see how to work with Traits in Rust

Traits

Traits is equivalent to Interfaces in Java. Traits can be made up of three varieties of associated items such as:

Functions and Methods
Constants
Types

When a type implements a trait it can be treated abstractly as that trait using generics or trait objects.

Create Traits

Traits can be created by using trait keyword.

trait TypeUtils {
    fn is_in_range(&self) -> bool;
}

Implement Traits for a type

It is possible to implement traits for a specific type (primitive or custom types)

In this below example, we can see how to implement TypeUtils trait for some of standard library types

impl TypeUtils for String {
    fn is_in_range(&self) -> bool {
        false
    }
}

impl TypeUtils for i32 {
    fn is_in_range(&self) -> bool {
        true
    }
}

impl TypeUtils for str {
    fn is_in_range(&self) -> bool {
        true
    }
}

It is also possible to implement Trait for custom types such as Structs. In this below example, we're creating an Employee Struct and implementing TypeUtils trait

struct Employee {
    name: String,
    age: i32,
}

impl TypeUtils for Employee {
    fn is_in_range(&self) -> bool {
        true
    }
}

Call traits methods implemented for a type

After declaring Traits and implementing them for type, let us see how to call the trait methods

fn main() {
    let s: String = String::from("Rust");
    let i: i32 = 100;
    let s1: &str = "Rust is awesome";
    let e: Employee = Employee::new(String::from("John"), 30);
    println!("Is '{s}' within range?: {}", s.is_in_range());
    println!("Is '{i}' within range?: {}", i.is_in_range());
    println!("Is '{s1}' within range?: {}", s1.is_in_range());
    println!("Is {e:#?} within range?: {}", e.is_in_range());
}

I hope this blog post gives you a brief overview about Traits.

All the code examples can be found in this link.

Please feel free to share your feedback.

Happy reading!!!

Working with Struct in Rust

Sivakumar — Sun, 15 Jan 2023 09:54:39 +0000

In this blog post, let us explore how to work with Struct in Rust

Create Struct type

Struct is equivalent to Class in Java language. It is a type composed of other types. There are 3 different ways we can create Struct in Rust

Named fields

This is more common approach we create Struct. Each field defined has a name and a type. It is possible to declare a field with pub and those such fields are visible to other modules

struct Employee {
    name: String,
    age: i32,
    dept: String,
}

Tuple Structs

It is similar to regular structs except they don't have any defined name. The fields can be accessible by using its index position starting with 0

struct TupleStruct(String, i32, String);

Unit Structs

Unit Structs as name implies, it doesn't have any fields and has zero-size and they are commonly used as markers. This can be instantiated. It is useful when you need to implement a trait but don't want to store any data inside it.

struct UnitStruct;

Constructor method for Struct

Struct can be initialized by assigning values to each of its member fields or add constructor method named new. This method takes argument values and returns itself.

impl Employee {
    pub fn new(name: String, age: i32, dept: String) -> Self {
        Self { name, age, dept }
    }
}

Add Behaviors to Struct

Struct without any methods doesn't make any sense. It is possible to add methods to Struct. Struct can also implement Trait's methods

In this below example, we're implementing Debug and Display trait for our Struct

impl fmt::Debug for Employee {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Employee")
            .field("Name", &self.name)
            .field("Age", &self.age)
            .field("Department", &self.dept)
            .finish()
    }
}

impl Display for Employee {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Employee [Name: {}, Age: {}, Department: {}]",
            self.name, self.age, self.dept
        )
    }
}

All the code examples can be found in this link

Please feel free to share your feedback.

Happy reading!!!

Rust Formatting

Sivakumar — Sun, 15 Jan 2023 00:36:08 +0000

In this post, let us explore different ways to format integers, decimal, strings using format specifiers

Formatting Integers

Just to format integers as it-is, we have to pass integers as argument to format macro

    println!("{}", format!("{}", 100));

To zero-pad integers with specific number of digits, in the format macro, specify the length. In this below example, we'll have zero-padded integer with max 10 digits

    println!("{}", format!("{:010}", 5));

Convert number into binary-formatted, just specify #b in format macro as below

    println!("{}", format!("{:#b}", 50));

Convert number into octal-formatted, just specify #o in format macro as below

    println!("{}", format!("{:#o}", 50));

Convert number into hex-formatted, just specify #x or #X in format macro as below

    println!("{}", format!("{:#x}", 50));

If you would like to have 1000 specifier as per locale, it can be achieved using num_format crate. The below example, will format the number 1 billion in US locale

    println!("{}", 1_000_000_000.to_formatted_string(&num_format::Locale::en));

Formatting the number 1 billion in French locale

    println!("{}", 1_000_000_000.to_formatted_string(&num_format::Locale::fr));

Formatting the number 1 billion in Indian locale

    println!("{}", 1_000_000_000.to_formatted_string(&num_format::Locale::en_IN));

Formatting Decimals

To format decimal numbers with specific precision, we can use below specifiers

    println!("{}", format!("{:.5}", 100.02));

In case if the decimal number exceeds the given precision, the number will get rounded-off at nth precision. The below code outputs 100.02782

    println!("{}", format!("{:.5}", 100.02781839));

Formatting String

To format string in left-aligned, we can use below specifier in the macro

    println!("{}", format!("{:<20}", "Rust is awesome"));

To align string in center within given length, we can use below specifier in the macro

    println!("{}", format!("{:^20}", "Rust is awesome"));

To right-align string within given length, we can use below specifier in the macro

    println!("{}", format!("{:>20}", "Rust is awesome"));

In case if you would like to fill the white-space with specific character, we just need to specify the specific character before the respective symbol (^, >, <) in the specifier

    println!("{}", format!("{:*^20}", "Rust is awesome"));

We can use the above specifiers to align integers as well.

All the code examples can be found in this link

Please feel free to share your feedback.

Happy reading!!!