Rust stuff. For more info, read Program's comments., Rust

Language: Layout:

/*
This program demonstrates 
    i -how to make 'classes' that are actually structs: 
   ii - Implementing methods for those structs.
  iii - Creating 'objects'.
   iv - Output.
    v - String formatting.
   vi - Calling functions while passing in Functions.
  vii - Recursion for calculating factorial.
 viii - Conditional 'if' statements as well.
   ix - Comments (Multiline and single-line)
    x - Variable declaration
   xi - Returning values from functions.

Thank you for looking at my program.
    PROGRAM BY 'JAMES COLLINS'
*/

struct Arithmetic{}

impl Arithmetic
{
    pub fn new() -> Self 
    { 
        Arithmetic{} // Returning an instance of this struct.
    }
    pub fn add(&self, num1: i32, num2: i32) -> i32 // The returning value is of the type 'int' for other mainstream languages. In this language it is reffered to as i32 because it's 32 bit-integer.
    {
        return num1 + num2; // Returning the sum.
    }
    pub fn diff(&self, num1: i32, num2: i32) -> i32 // The returning value is of the type 'int' for other mainstream languages. In this language it is reffered to as i64 because it's 32 bit-integer.
    {
        let ret_val = num1 - num2; // calculating the difference.
        return if ret_val < 0 {-ret_val} else {ret_val}; // Getting the absolute value.
    }
    pub fn multi(&self, num1: i32, num2: i32) -> i64 // The returning value is of the type 'long' for other mainstream lanuages. In this language it is reffered to as i64 because it's 64 bit-integer.
    { 
        return (num1 * num2) as i64;
    }
    pub fn div(&self, num1: i32, num2: i32) -> f32 // The returning value is of the type 'float' for other mainstream langauges. In this language it is reffered to as f32, as it's floating-point number of 32 bits.
    {
        return num1 as f32 / num2 as f32; 
    }
    pub fn factorial(&self, num: i32) -> i64 // The returning value is of the type 'long' for other mainstream languages. In this language it is reffered to as i64 because it's 64 bit-integer.
    {
        if num <= 1
        {
            return 1;
        }
        else
        {
            return num as i64 * Arithmetic::factorial(self, num - 1); // recursing.
        }
    }
}

fn main() {
    let first_object = Arithmetic::new();
    println!("Sum: {}", first_object.add(1, 2));
    println!("Difference: {}", first_object.diff(10, 50));
    println!("Product: {}", first_object.multi(10, 10));
    println!("Quotient: {}", first_object.div(1, 2));
    println!("Factorial: {}", first_object.factorial(5));
    //println!();
}

// PROGRAM BY 'JAMES COLLINS'

Show compiler warnings [ + ] Show input