Why are variables immutable by default in Rust?

Rust makes variables immutable by default to promote safety and predictable behavior. You must use the mut keyword to make a variable mutable.

What is the difference between an expression and a statement in Rust?

In Rust, expressions return values while statements do not. Adding a semicolon turns an expression into a statement.

Is Rust syntax difficult for beginners?

Rust syntax can feel strict at first due to its strong type system and ownership rules, but it becomes easier with practice and helps prevent common programming errors.

Rust Syntax

Q: Is Rust syntax similar to C++?

Yes, Rust syntax is similar to C++ in structure and use of curly braces, but Rust enforces stricter safety rules through ownership, borrowing, and strong type checking.

Q: Does Rust require semicolons?

Yes, most Rust statements require semicolons. However, the final expression in a function should not have a semicolon if it is being returned.

Rust Syntax – Complete Beginner Guide

If you’re starting your Rust journey, understanding Rust syntax is the first major step.

Rust has a clean, modern syntax — but it is also strict and type-safe. That strictness is what makes Rust powerful, fast, and memory-safe.

In this fully beginner guide, you’ll learn:

Basic Rust program structure
Variables and mutability
Data types
Comments
Functions
Control flow (if, loops)
Blocks and scope
Expressions vs statements
Structs and basic patterns
Common syntax mistakes

Let’s dive in

Basic Structure of a Rust Program

Every Rust program starts with a main function:

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

fn main() {

println!("Hello, Rust!");

}

Explanation:

fn → defines a function
main() → entry point
{} → block of code
println!() → macro to print text

Rust uses curly braces {} to define blocks.

Comments in Rust

Comments help explain code.

Single-line comment:

// This is a comment

Multi-line comment:

/*

 This is

 a multi-line comment

*/

Comments are ignored during compilation.

Variables in Rust

Rust uses let to declare variables.

let x = 10;

1	let x = 10;

Rust automatically infers type.

Immutable by Default

By default, variables are immutable:

let x = 5;
x = 10; // Error

1 2	let x = 5; x = 10; // Error

To make mutable:

let mut x = 5;
x = 10; // Works

1 2	let mut x = 5; x = 10; // Works

Rust encourages immutability for safety.

Data Types in Rust

Rust is statically typed.

Integer Types

let a: i32 = 10;
let b: u32 = 20;

1 2	let a: i32 = 10; let b: u32 = 20;

i32 → signed
u32 → unsigned

Floating-Point

let pi: f64 = 3.14;

1	let pi: f64 = 3.14;

Boolean

let is_active: bool = true;

1	let is_active: bool = true;

Character

let letter: char = 'A';

1	let letter: char = 'A';

Strings in Rust

Rust has two main string types:

String Literal (`&str`)

let name = "Rust";

1	let name = "Rust";

Owned String (`String`)

let mut name = String::from("Rust");
name.push_str(" Language");

1 2	let mut name = String::from("Rust"); name.push_str(" Language");

Understanding the difference is important.

Functions in Rust

Functions are declared using fn.

fn greet() {
println!("Hello!");
}

fn greet() {

println!("Hello!");

}

Function with Parameters

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

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

a + b

}

Key syntax rules:

Parameter types must be specified
Return type uses ->
Last expression returns value

Expressions vs Statements

Rust is expression-based.

Expression (returns value):

let x = 5 + 3;

1	let x = 5 + 3;

Statement (does not return value):

let x = 5;

1	let x = 5;

Important:

fn square(x: i32) -> i32 {
x * x // no semicolon
}

fn square(x: i32) -> i32 {

x * x // no semicolon

}

Adding semicolon turns it into a statement and causes error.

Control Flow – If Statement

let number = 10;

if number > 5 {
println!("Greater than 5");
} else {
println!("Less or equal");
}

let number = 10;

if number > 5 {

println!("Greater than 5");

} else {

println!("Less or equal");

}

Rust does not require parentheses around condition.

If as Expression

let result = if number > 5 { "Big" } else { "Small" };

1	let result = if number > 5 { "Big" } else { "Small" };

Both branches must return same type.

Loops in Rust

For Loop

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

for i in 1..5 {

println!("{}", i);

}

While Loop

let mut x = 5;

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

let mut x = 5;

while x > 0 {

println!("{}", x);

x -= 1;

}

Infinite Loop

loop {
println!("Running forever");
}

loop {

println!("Running forever");

}

Blocks and Scope

Rust uses {} for blocks.

{
let x = 10;
}

{

let x = 10;

}

Variable exists only inside block.

Shadowing

Rust allows shadowing:

let x = 5;
let x = x + 1;

1 2	let x = 5; let x = x + 1;

Each let creates new variable.

Different from mutability.

Struct Syntax

Struct defines custom type:

struct Person {
name: String,
age: u32,
}

struct Person {

name: String,

age: u32,

}

Create instance:

let user = Person {
name: String::from("Alice"),
age: 30,
};

let user = Person {

name: String::from("Alice"),

age: 30,

};

Access fields:

println!("{}", user.age);

1	println!("{}", user.age);

Match Statement

Rust’s pattern matching:

let number = 3;

match number {
1 => println!("One"),
2 => println!("Two"),
_ => println!("Other"),
}

let number = 3;

match number {

1 => println!("One"),

2 => println!("Two"),

_ => println!("Other"),

}

_ is default case.

Constants

Use const:

const MAX_POINTS: u32 = 100;

1	const MAX_POINTS: u32 = 100;

Rules:

Must specify type
Must be uppercase convention

Importing Modules

Use use keyword:

use std::io;

1	use std::io;

Rust uses module system for organization.

Visual Overview of Rust Syntax Structure

Common Beginner Syntax Mistakes

Forgetting semicolon
Adding semicolon to return expression
Forgetting mut keyword
Not specifying return type
Trying C-style syntax
Confusing String and &str

Rust compiler gives detailed error messages.

Why Rust Syntax Feels Strict

Rust enforces:

Type safety
Ownership rules
Borrow checking
Memory safety

This strictness reduces runtime errors.

Best Practices for Writing Clean Rust Syntax

Use descriptive variable names
Keep functions small
Prefer immutability
Use match instead of multiple if-else
Let compiler guide you

Frequently Asked Questions (FAQs)

1. Is Rust syntax similar to C++?

Yes, Rust syntax looks similar to C++, but it has stricter safety rules.

2. Why are variables immutable by default?

Rust promotes safety and predictable behavior.

3. Does Rust require semicolons?

Yes, most statements require semicolons.

4. What is the difference between expression and statement?

Expressions return values; statements do not.

5. Is Rust syntax hard to learn?

It can feel strict at first, but becomes clear with practice.

Conclusion

Rust syntax is:

Modern
Clean
Strict
Safe
Expression-based

You learned:

Variables
Data types
Functions
Control flow
Structs
Blocks and scope

Mastering Rust syntax builds a strong foundation for advanced topics like ownership, borrowing, and lifetimes.