// Scalar Types
fn scalar_types_demo() {
    // Integers
    let a: i32 = 10;
    let b: u64 = 1000;

    // Floating-point numbers
    let x: f64 = 3.14159;
    let y: f32 = 2.71828;

    // Booleans
    let is_active: bool = true;

    // Characters
    let letter: char = 'A';

    println!("Integer a: {}", a);
    println!("Unsigned integer b: {}", b);
    println!("Floating point x: {}", x);
    println!("Floating point y: {}", y);
    println!("Boolean is_active: {}", is_active);
    println!("Character letter: {}", letter);
}

// Compound Types (Tuples and Arrays)
fn compound_types_demo() {
    // Tuple: Can hold multiple data types
    let tup: (i32, f64, char) = (500, 6.4, 'a');
    let (x, y, z) = tup;
    println!("Tuple values: x = {}, y = {}, z = {}", x, y, z);

    // Array: Fixed size and same data type
    let arr: [i32; 3] = [1, 2, 3];
    println!("Array values: {:?}", arr);
}

// Custom Types (Structs and Enums)
struct Rectangle {
    width: u32,
    height: u32,
}

fn area(rect: &Rectangle) -> u32 {
    rect.width * rect.height
}

enum Direction {
    North,
    South,
    East,
    West,
}

fn describe_direction(direction: Direction) {
    match direction {
        Direction::North => println!("Going North!"),
        Direction::South => println!("Going South!"),
        Direction::East => println!("Going East!"),
        Direction::West => println!("Going West!"),
    }
}

// Functions: Basic and with Return
fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn multiply(x: i32, y: i32) -> i32 {
    x * y
}

fn main() {
    // Demo for scalar and compound types
    scalar_types_demo();
    compound_types_demo();

    // Custom Types demo (Struct and Enum)
    let rect = Rectangle { width: 30, height: 50 };
    println!("Area of rectangle: {}", area(&rect));

    let direction = Direction::North;
    describe_direction(direction);

    // Function call with return value
    let sum = add(10, 20);
    let product = multiply(10, 20);
    println!("Sum: {}", sum);
    println!("Product: {}", product);
}
by

Rust online compiler

Write, Run & Share Rust code online using OneCompiler’s Rust online compiler for free. It’s a fast, interactive, and powerful environment to learn and experiment with the Rust programming language. OneCompiler runs the latest stable version of Rust.

About Rust

Rust is a systems programming language developed by Mozilla that focuses on performance, memory safety, and concurrency. It guarantees memory safety without a garbage collector and is widely used for system-level programming, web assembly, and command-line tools. Rust's compiler enforces strict compile-time checks, making code safer and more predictable.

Sample Code

The following is a simple Rust program that prints a greeting:

fn main() {
    println!("Hello, OneCompiler!");
}

Taking inputs (stdin)

OneCompiler’s Rust editor supports stdin. Here’s a sample program that reads a line of input and prints it:

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    println!("Hello, {}", input.trim());
}

Syntax Basics

Variables

let name = "OneCompiler";        // Immutable
let mut age = 25;                // Mutable

Data Types

TypeDescription
i32, i64Signed integers
f32, f64Floating-point numbers
booltrue or false
charSingle character
StringGrowable string

Conditionals

let score = 85;
if score >= 50 {
    println!("Pass");
} else {
    println!("Fail");
}

Loops

For loop

for i in 1..=5 {
    println!("{}", i);
}

While loop

let mut i = 1;
while i <= 5 {
    println!("{}", i);
    i += 1;
}

Loop (infinite with break)

let mut count = 0;
loop {
    if count == 3 {
        break;
    }
    println!("{}", count);
    count += 1;
}

Functions

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

This guide provides a quick reference to Rust programming syntax and features. Start coding in Rust using OneCompiler’s Rust online compiler today!