Day 2: Rust Syntax Basics and Your First Rust Program
Now that you’ve set up Rust on your machine, it’s time to dive into the basics of Rust syntax. Rust’s syntax is clean and expressive, making it easy to learn for beginners while still being powerful enough for advanced use cases.
1. Basic Rust Syntax
Rust’s syntax is similar to other C-like languages, but it has some unique features. Let’s break it down:
Here's a simple Rust "Hello, World!" program:
fn main() {
println!("Hello, World!");
}
Explanation:
fn main() {}
:This defines the main function, which is the entry point of a Rust program.
fn
stands for "function," andmain
is the default function name where execution begins.
println!("Hello, World!");
:println!
is a Rust macro (indicated by the!
at the end).It prints the given text to the console.
The text inside the parentheses is a string enclosed in double quotes (
"Hello, World!"
).The semicolon (
;
) marks the end of the statement.
Running the Program:
Save the file as
main.rs
.Open a terminal and navigate to the file's directory.
Run:
rustc main.rs ./main
rustc
compiles the Rust file../main
executes the compiled program.
Variables and Mutability
Variables in Rust are immutable by default. Use the
mut
keyword to make them mutable.let x = 5; // immutable let mut y = 10; // mutable y = 15; // allowed // x = 20; // this would cause a compile-time error
Data Types
Rust is a statically typed language, meaning the type of every variable must be known at compile time.
Common data types:
Integers:
i32
,u32
,i64
, etc.Floats:
f32
,f64
Booleans:
bool
Characters:
char
Tuples:
(i32, f64, char)
Arrays:
[i32; 5]
(fixed-size)
Example:
let num: i32 = 42;
let pi: f64 = 3.14;
let is_rust_fun: bool = true;
let letter: char = 'R';
let tuple: (i32, f64, char) = (42, 3.14, 'R');
let array: [i32; 3] = [1, 2, 3];
Functions
Functions are defined using the
fn
keyword.The return type is specified after an arrow
->
.Example:
fn add(a: i32, b: i32) -> i32 { a + b // no semicolon means this is the return value }
Control Flow
If-Else:
let number = 7; if number < 5 { println!("Condition was true"); } else { println!("Condition was false"); }
Loops:
let mut count = 0; loop { count += 1; if count == 3 { break; } }
2. Writing Your First Rust Program
Let’s write a simple program that demonstrates the basics of Rust syntax. This program will:
Declare variables.
Use a function to perform a calculation.
Print the result.
fn main() {
// Declare variables
let a = 10;
let b = 20;
// Call a function
let result = add(a, b);
// Print the result
println!("The sum of {} and {} is {}", a, b, result);
}
// Function to add two numbers
fn add(x: i32, y: i32) -> i32 {
x + y
}
Output:
The sum of 10 and 20 is 30
3. Why Is This Important for Web3?
Understanding Rust’s syntax is the foundation for building Web3 applications. For example:
Smart Contracts: You’ll use Rust’s syntax to write secure and efficient smart contracts on platforms like Solana.
Blockchain Protocols: Rust’s performance and safety features make it ideal for building blockchain protocols.
Decentralized Apps (dApps): Rust’s concurrency model helps you build scalable dApps.
4. What’s Next?
In Day 3, we’ll explore Rust’s Ownership Model, one of the most unique and powerful features of Rust. This will help you understand how Rust ensures memory safety without a garbage collector, which is crucial for building secure Web3 applications.
Call to Action
If you’re enjoying this series, share your progress in the comments! Let me know if you have any questions about Rust syntax or Web3. Stay tuned for Day 3! 🚀