Introduction to Functions in Rust

Functions are the fundamental building blocks of Rust programs. They encapsulate behavior, promote code reuse, and help organize code into logical, manageable pieces. Rust's function system combines elements from functional and systems programming, offering powerful features like pattern matching in parameters, multiple return values, and function pointers.

Key Concepts

• Function Declaration: Using the fn keyword
• Parameters: Typed inputs to functions
• Return Values: Explicit or implicit returns
• Statements vs Expressions: Understanding the difference
• Function Types: First-class functions and closures
• Safety: Borrowing rules apply to function boundaries

1. Basic Function Syntax

Simple Functions

// Basic function with no parameters and no return fn greet() { println!("Hello, world!"); } // Function with parameters fn greet_person(name: &str) { println!("Hello, {}!", name); } // Function with return value fn add(a: i32, b: i32) -> i32 { a + b // Implicit return (no semicolon) } // Function with explicit return fn multiply(a: i32, b: i32) -> i32 { return a * b; // Explicit return (with semicolon) } fn main() { greet(); greet_person("Alice"); let sum = add(5, 3); println!("Sum: {}", sum); let product = multiply(4, 7); println!("Product: {}", product); }

Function Ordering

// Functions can be defined after they're called fn main() { let result = calculate(10, 5); println!("Result: {}", result); call_before_definition(); // Works due to hoisting } // Definition after main fn calculate(x: i32, y: i32) -> i32 { x * y + y } fn call_before_definition() { println!("This works because functions are hoisted"); } // Nested functions (allowed) fn outer_function() { println!("Outer function"); fn inner_function() { println!("Inner function"); } inner_function(); // Can only be called within outer_function }

2. Parameters and Arguments

Parameter Patterns

// Basic parameters fn basic_params(x: i32, y: f64, z: &str) { println!("x: {}, y: {}, z: {}", x, y, z); } // Pattern matching in parameters fn print_coordinates(&(x, y): &(i32, i32)) { println!("Coordinates: ({}, {})", x, y); } // Destructuring structs struct Point { x: i32, y: i32, } fn print_point(Point { x, y }: &Point) { println!("Point at ({}, {})", x, y); } // Multiple patterns enum Message { Quit, Move { x: i32, y: i32 }, Write(String), } fn handle_message(msg: Message) { match msg { Message::Quit => println!("Quit"), Message::Move { x, y } => println!("Move to ({}, {})", x, y), Message::Write(text) => println!("Write: {}", text), } } fn main() { basic_params(10, 3.14, "hello"); let tuple = (5, 10); print_coordinates(&tuple); let point = Point { x: 15, y: 25 }; print_point(&point); handle_message(Message::Move { x: 10, y: 20 }); }

Reference Parameters

// Immutable reference fn calculate_length(s: &String) -> usize { s.len() } // Mutable reference fn append_world(s: &mut String) { s.push_str(", world"); } // Multiple references fn process_strings(s1: &String, s2: &String) -> String { format!("{} {}", s1, s2) } // Slice parameters fn first_word(s: &str) -> &str { let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } } &s[..] } fn main() { let s = String::from("hello"); let len = calculate_length(&s); println!("Length: {}", len); let mut s = String::from("hello"); append_world(&mut s); println!("Modified: {}", s); let s1 = String::from("hello"); let s2 = String::from("world"); let result = process_strings(&s1, &s2); println!("Combined: {}", result); let sentence = String::from("hello world"); let word = first_word(&sentence); println!("First word: {}", word); }

3. Return Values

Different Return Patterns

// Single return value fn square(x: i32) -> i32 { x * x } // Multiple return values via tuple fn divide(dividend: i32, divisor: i32) -> (i32, i32) { (dividend / divisor, dividend % divisor) } // Named return values (not like Go, just for documentation) fn get_coordinates() -> (x: i32, y: i32) { (10, 20) // Return tuple, names are for documentation only } // Returning references fn get_first_element(vec: &[i32]) -> Option<&i32> { vec.first() } // Returning Result fn safe_divide(numerator: f64, denominator: f64) -> Result<f64, String> { if denominator == 0.0 { Err("Division by zero".to_string()) } else { Ok(numerator / denominator) } } // Returning Option fn find_in_vector(vec: &[i32], target: i32) -> Option<usize> { vec.iter().position(|&x| x == target) } fn main() { println!("Square: {}", square(5)); let (quotient, remainder) = divide(17, 5); println!("17 / 5 = {} remainder {}", quotient, remainder); let (x, y) = get_coordinates(); println!("Coordinates: ({}, {})", x, y); let numbers = vec![1, 2, 3, 4, 5]; if let Some(first) = get_first_element(&numbers) { println!("First element: {}", first); } match safe_divide(10.0, 2.0) { Ok(result) => println!("Division result: {}", result), Err(e) => println!("Error: {}", e), } match find_in_vector(&numbers, 3) { Some(pos) => println!("Found at position: {}", pos), None => println!("Not found"), } }

4. Statements vs Expressions

Understanding the Difference

// Statements perform actions but don't return values // Expressions evaluate to a value fn demonstrate_statements_expressions() { // Statement: variable declaration let x = 5; // Expression: 5 + 3 evaluates to 8 let y = 5 + 3; // Statement: println! macro call println!("x = {}, y = {}", x, y); // Block as expression let z = { let a = 10; let b = 20; a + b // This is an expression (no semicolon) }; println!("z = {}", z); // If as expression let condition = true; let result = if condition { 100 // Expression } else { 200 // Expression }; println!("result = {}", result); // Match as expression let number = 3; let description = match number { 1 => "one", 2 => "two", _ => "other", }; println!("description = {}", description); // Loop as expression let mut counter = 0; let loop_result = loop { counter += 1; if counter == 5 { break counter * 2; // Expression returning value } }; println!("loop_result = {}", loop_result); }

Function Bodies as Expressions

// Function body is a block expression fn add_v1(a: i32, b: i32) -> i32 { a + b // Expression (no semicolon) -> implicit return } fn add_v2(a: i32, b: i32) -> i32 { return a + b; // Statement with explicit return } fn complex_computation(x: i32) -> i32 { // The entire function body is one big expression let y = { let temp = x * 2; temp + 5 }; let z = if y > 10 { y * 3 } else { y * 2 }; match z { 0..=20 => z + 10, 21..=40 => z * 2, _ => z - 10, } // This is the return value (no semicolon) } fn main() { println!("add_v1: {}", add_v1(5, 3)); println!("add_v2: {}", add_v2(5, 3)); println!("complex: {}", complex_computation(7)); }

5. Function Overloading (Not Supported)

// Rust doesn't support traditional function overloading // But you can achieve similar results with traits or generics // Using generics instead of overloading fn print_value<T: std::fmt::Display>(value: T) { println!("Value: {}", value); } // Using different function names fn add_i32(a: i32, b: i32) -> i32 { a + b } fn add_f64(a: f64, b: f64) -> f64 { a + b } // Using enum for different types enum Input { Integer(i32), Float(f64), Text(String), } fn process_input(input: Input) -> String { match input { Input::Integer(i) => format!("Integer: {}", i), Input::Float(f) => format!("Float: {}", f), Input::Text(s) => format!("Text: {}", s), } } fn main() { print_value(42); print_value(3.14); print_value("hello"); println!("i32 sum: {}", add_i32(5, 3)); println!("f64 sum: {}", add_f64(5.5, 3.3)); println!("{}", process_input(Input::Integer(42))); println!("{}", process_input(Input::Float(3.14))); println!("{}", process_input(Input::Text("hello".to_string()))); }

6. Generic Functions

Basic Generics

// Generic function with one type parameter fn identity<T>(value: T) -> T { value } // Generic with multiple type parameters fn swap<A, B>(a: A, b: B) -> (B, A) { (b, a) } // Generic with trait bounds fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest } // Generic with where clause fn print_display<T>(value: T) where T: std::fmt::Display, { println!("Display: {}", value); } fn print_debug<T>(value: T) where T: std::fmt::Debug, { println!("Debug: {:?}", value); } fn main() { let x = identity(42); let y = identity("hello"); println!("x: {}, y: {}", x, y); let swapped = swap(5, "hello"); println!("swapped: {:?}", swapped); let numbers = vec![34, 50, 25, 100, 65]; println!("Largest number: {}", largest(&numbers)); let chars = vec!['y', 'm', 'a', 'q']; println!("Largest char: {}", largest(&chars)); print_display(42); print_debug(vec![1, 2, 3]); }

Advanced Generics

use std::fmt::Display; use std::ops::Add; // Generic with multiple bounds fn compare_and_print<T: PartialOrd + Display>(a: T, b: T) { if a > b { println!("{} is greater than {}", a, b); } else if a < b { println!("{} is less than {}", a, b); } else { println!("{} equals {}", a, b); } } // Generic with associated types trait Container { type Item; fn add(&mut self, item: Self::Item); fn get(&self, index: usize) -> Option<&Self::Item>; } impl<T> Container for Vec<T> { type Item = T; fn add(&mut self, item: T) { self.push(item); } fn get(&self, index: usize) -> Option<&T> { self.get(index) } } // Generic with const generics fn sum_array<const N: usize>(arr: [i32; N]) -> i32 { let mut sum = 0; for i in 0..N { sum += arr[i]; } sum } // Generic with custom trait trait Double { fn double(self) -> Self; } impl Double for i32 { fn double(self) -> Self { self * 2 } } impl Double for f64 { fn double(self) -> Self { self * 2.0 } } fn double_value<T: Double>(value: T) -> T { value.double() } fn main() { compare_and_print(10, 5); compare_and_print(3.14, 2.71); let mut vec = Vec::new(); vec.add(1); vec.add(2); println!("vec[0]: {:?}", vec.get(0)); let arr = [1, 2, 3, 4, 5]; println!("Sum of array: {}", sum_array(arr)); println!("Double i32: {}", double_value(21)); println!("Double f64: {}", double_value(3.14)); }

7. Higher-Order Functions

Functions as Parameters

// Function that takes a function as parameter fn apply_twice<F>(f: F, x: i32) -> i32 where F: Fn(i32) -> i32, { f(f(x)) } // Function that returns a function fn create_adder(x: i32) -> impl Fn(i32) -> i32 { move |y| x + y } // Using function pointers fn add_one(x: i32) -> i32 { x + 1 } fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 { f(arg) + f(arg) } // Function with different Fn traits fn call_fn<F>(f: F) where F: Fn(), { f(); } fn call_fn_mut<F>(mut f: F) where F: FnMut(), { f(); f(); } fn call_fn_once<F>(f: F) where F: FnOnce(), { f(); } fn main() { // Passing closure let result = apply_twice(|x| x * 2, 5); println!("apply_twice: {}", result); // (5*2)*2 = 20 // Using returned function let add_five = create_adder(5); println!("add_five(3): {}", add_five(3)); // Function pointer let result = do_twice(add_one, 5); println!("do_twice: {}", result); // 6 + 6 = 12 // Different Fn traits let x = 5; let print_x = || println!("x = {}", x); // Fn call_fn(print_x); let mut count = 0; let mut increment = || { count += 1; println!("count = {}", count); }; // FnMut call_fn_mut(increment); let s = String::from("hello"); let consume = move || { println!("s = {}", s); }; // FnOnce call_fn_once(consume); }

Common Higher-Order Functions

fn main() { let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Map let squares: Vec<i32> = numbers.iter().map(|&x| x * x).collect(); println!("Squares: {:?}", squares); // Filter let evens: Vec<i32> = numbers.iter().filter(|&&x| x % 2 == 0).copied().collect(); println!("Evens: {:?}", evens); // Fold (reduce) let sum: i32 = numbers.iter().fold(0, |acc, &x| acc + x); println!("Sum: {}", sum); // Any let has_negative = numbers.iter().any(|&x| x < 0); println!("Has negative: {}", has_negative); // All let all_positive = numbers.iter().all(|&x| x > 0); println!("All positive: {}", all_positive); // Find let first_even = numbers.iter().find(|&&x| x % 2 == 0); println!("First even: {:?}", first_even); // Position let position_of_5 = numbers.iter().position(|&x| x == 5); println!("Position of 5: {:?}", position_of_5); // Chain multiple operations let result: i32 = numbers .iter() .filter(|&&x| x % 2 == 0) .map(|&x| x * x) .fold(0, |acc, x| acc + x); println!("Sum of squares of evens: {}", result); }

8. Closures

Basic Closures

fn main() { // Simple closure let add_one = |x| x + 1; println!("add_one(5): {}", add_one(5)); // Closure with type annotations let multiply = |x: i32, y: i32| -> i32 { x * y }; println!("multiply(3, 4): {}", multiply(3, 4)); // Closure capturing environment let x = 5; let add_x = |y| x + y; println!("add_x(3): {}", add_x(3)); // Closure with multiple statements let complex = |x| { let y = x * 2; let z = y + 5; z * 3 }; println!("complex(5): {}", complex(5)); // Returning closure let create_adder = |x| move |y| x + y; let add_ten = create_adder(10); println!("add_ten(7): {}", add_ten(7)); }

Capture Modes

fn main() { // By reference (Fn) let s1 = String::from("hello"); let print_ref = || println!("s1: {}", s1); print_ref(); println!("Still have s1: {}", s1); // By mutable reference (FnMut) let mut s2 = String::from("hello"); let mut append_world = || { s2.push_str(", world"); println!("s2: {}", s2); }; append_world(); // append_world(); // Can call multiple times println!("s2 after: {}", s2); // By value (FnOnce) let s3 = String::from("hello"); let consume = || { let s = s3; println!("s: {}", s); }; consume(); // consume(); // Can't call twice // println!("s3: {}", s3); // s3 moved // Mixing capture modes let a = String::from("a"); let mut b = String::from("b"); let c = String::from("c"); let mixed = || { println!("a: {}", a); // by reference b.push_str("b"); // by mutable reference drop(c); // by value (FnOnce) }; // mixed(); // This would be FnOnce due to drop(c) }

Closures and Move

fn main() { // Move semantics in closures let v1 = vec![1, 2, 3]; let v2 = vec![4, 5, 6]; // Without move - captures by reference let print_v1 = || { println!("v1: {:?}", v1); }; print_v1(); println!("Still have v1: {:?}", v1); // With move - captures by value let take_v2 = move || { println!("v2: {:?}", v2); }; take_v2(); // println!("v2: {:?}", v2); // Error: v2 moved // Practical use: spawning threads let data = vec![1, 2, 3, 4, 5]; std::thread::spawn(move || { println!("Thread data: {:?}", data); }).join().unwrap(); // Can't use data here - it's moved // println!("Main data: {:?}", data); }

9. Function Pointers

Using Function Pointers

// Function pointer type fn add(a: i32, b: i32) -> i32 { a + b } fn subtract(a: i32, b: i32) -> i32 { a - b } fn multiply(a: i32, b: i32) -> i32 { a * b } // Function taking function pointer fn calculate(op: fn(i32, i32) -> i32, a: i32, b: i32) -> i32 { op(a, b) } // Function returning function pointer fn get_operation(op_name: &str) -> Option<fn(i32, i32) -> i32> { match op_name { "add" => Some(add), "sub" => Some(subtract), "mul" => Some(multiply), _ => None, } } // Array of function pointers fn main() { let ops: [fn(i32, i32) -> i32; 3] = [add, subtract, multiply]; for (i, op) in ops.iter().enumerate() { let result = op(10, 5); println!("Operation {}: {}", i, result); } println!("add(5, 3) = {}", calculate(add, 5, 3)); println!("subtract(5, 3) = {}", calculate(subtract, 5, 3)); if let Some(op) = get_operation("add") { println!("Dynamic operation: {}", op(15, 7)); } // Function pointers vs closures let closure = |a: i32, b: i32| a * b; // Closure that doesn't capture can be coerced to fn pointer let fn_ptr: fn(i32, i32) -> i32 = |a, b| a + b; println!("Closure as fn pointer: {}", fn_ptr(5, 3)); // But capturing closures cannot let x = 5; // let capturing: fn(i32) -> i32 = |a| a + x; // Error }

10. Diverging Functions

Functions that Never Return

// Diverging function (returns never type !) fn forever() -> ! { loop { println!("This will never end!"); std::thread::sleep(std::time::Duration::from_secs(1)); } } fn panic_and_die() -> ! { panic!("This function always panics"); } // Useful in match arms fn process_number(num: Option<i32>) -> i32 { match num { Some(n) => n, None => panic!("No value provided"), // panic! returns ! } } // The never type in generic contexts fn either<T>(value: Option<T>) -> T { match value { Some(val) => val, None => forever(), // forever() returns !, which coerces to any type } } fn main() { // These functions never return normally // panic_and_die(); // forever(); let result = process_number(Some(42)); println!("Result: {}", result); // The following would panic // let result = process_number(None); // Using never type with loop let x = loop { break 5; // loop with break returns value }; println!("x: {}", x); // Infinite loop with break let y = loop { if true { break 10; } }; println!("y: {}", y); }

11. Methods

Associated Functions and Methods

struct Rectangle { width: u32, height: u32, } impl Rectangle { // Associated function (doesn't take self) fn new(width: u32, height: u32) -> Rectangle { Rectangle { width, height } } // Associated function that creates a square fn square(size: u32) -> Rectangle { Rectangle { width: size, height: size, } } // Method (takes &self) fn area(&self) -> u32 { self.width * self.height } // Method (takes &mut self) fn set_width(&mut self, width: u32) { self.width = width; } // Method that takes ownership (rare) fn destroy(self) { println!("Destroying rectangle: {}x{}", self.width, self.height); } // Getter fn width(&self) -> u32 { self.width } // Method with multiple parameters fn can_hold(&self, other: &Rectangle) -> bool { self.width > other.width && self.height > other.height } } fn main() { // Call associated functions with :: let rect = Rectangle::new(30, 50); let square = Rectangle::square(20); // Call methods with . println!("Area: {}", rect.area()); println!("Can hold square: {}", rect.can_hold(&square)); let mut rect2 = Rectangle::new(10, 10); rect2.set_width(15); println!("New width: {}", rect2.width()); // rect2.destroy(); // Uncomment to move ownership // println!("{:?}", rect2); // Error: rect2 moved }

Method Chaining

struct Calculator { value: i32, } impl Calculator { fn new() -> Self { Calculator { value: 0 } } fn add(mut self, x: i32) -> Self { self.value += x; self } fn subtract(mut self, x: i32) -> Self { self.value -= x; self } fn multiply(mut self, x: i32) -> Self { self.value *= x; self } fn get(self) -> i32 { self.value } } // Builder pattern struct PersonBuilder { name: Option<String>, age: Option<u32>, email: Option<String>, } impl PersonBuilder { fn new() -> Self { PersonBuilder { name: None, age: None, email: None, } } fn name(mut self, name: &str) -> Self { self.name = Some(name.to_string()); self } fn age(mut self, age: u32) -> Self { self.age = Some(age); self } fn email(mut self, email: &str) -> Self { self.email = Some(email.to_string()); self } fn build(self) -> Person { Person { name: self.name.expect("Name is required"), age: self.age.unwrap_or(0), email: self.email, } } } struct Person { name: String, age: u32, email: Option<String>, } fn main() { // Method chaining let result = Calculator::new() .add(5) .multiply(2) .subtract(3) .add(10) .get(); println!("Calculator result: {}", result); // Builder pattern let person = PersonBuilder::new() .name("Alice") .age(30) .email("[email protected]") .build(); println!("Person: {} ({} years old)", person.name, person.age); }

12. Function Attributes

Inline and Other Attributes

#![allow(dead_code)] // Inline attribute - hint to compiler to inline function #[inline] fn small_function(x: i32) -> i32 { x * 2 } // Always inline #[inline(always)] fn very_small(x: i32) -> i32 { x + 1 } // Never inline #[inline(never)] fn large_function(x: i32) -> i32 { // Complex computation let mut result = x; for i in 0..10 { result += i; } result } // Deprecated function #[deprecated(since = "1.2.0", note = "Use new_function instead")] fn old_function() { println!("This is old"); } // Conditional compilation #[cfg(target_os = "linux")] fn linux_specific() { println!("This runs only on Linux"); } #[cfg(not(target_os = "linux"))] fn linux_specific() { println!("This runs on non-Linux systems"); } // Testing attribute #[test] fn test_small_function() { assert_eq!(small_function(5), 10); } // Ignored test #[test] #[ignore] fn expensive_test() { // This test won't run by default } // Must-use attribute #[must_use] fn important_calculation() -> i32 { 42 } fn main() { println!("Small: {}", small_function(5)); println!("Very small: {}", very_small(10)); println!("Large: {}", large_function(5)); old_function(); linux_specific(); let result = important_calculation(); println!("Important: {}", result); // Warning if we don't use result }

13. Recursive Functions

Basic Recursion

// Simple recursive function fn factorial(n: u64) -> u64 { match n { 0 | 1 => 1, _ => n * factorial(n - 1), } } // Tail recursion (optimized by compiler) fn factorial_tail(n: u64, acc: u64) -> u64 { match n { 0 | 1 => acc, _ => factorial_tail(n - 1, acc * n), } } // Fibonacci fn fibonacci(n: u64) -> u64 { match n { 0 => 0, 1 => 1, _ => fibonacci(n - 1) + fibonacci(n - 2), } } // More efficient Fibonacci with memoization use std::collections::HashMap; fn fibonacci_memo(n: u64, memo: &mut HashMap<u64, u64>) -> u64 { if let Some(&result) = memo.get(&n) { return result; } let result = match n { 0 => 0, 1 => 1, _ => fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo), }; memo.insert(n, result); result } // Tree traversal with recursion #[derive(Debug)] struct TreeNode<T> { value: T, left: Option<Box<TreeNode<T>>>, right: Option<Box<TreeNode<T>>>, } impl<T: std::fmt::Debug> TreeNode<T> { fn new(value: T) -> Self { TreeNode { value, left: None, right: None, } } fn insert_left(&mut self, value: T) { self.left = Some(Box::new(TreeNode::new(value))); } fn insert_right(&mut self, value: T) { self.right = Some(Box::new(TreeNode::new(value))); } fn traverse_preorder(&self) { println!("{:?}", self.value); if let Some(left) = &self.left { left.traverse_preorder(); } if let Some(right) = &self.right { right.traverse_preorder(); } } } fn main() { println!("Factorial of 5: {}", factorial(5)); println!("Tail factorial of 5: {}", factorial_tail(5, 1)); println!("Fibonacci of 10: {}", fibonacci(10)); let mut memo = HashMap::new(); println!("Memoized Fibonacci of 10: {}", fibonacci_memo(10, &mut memo)); // Tree example let mut root = TreeNode::new(1); root.insert_left(2); root.insert_right(3); if let Some(left) = &mut root.left { left.insert_left(4); left.insert_right(5); } println!("Tree traversal:"); root.traverse_preorder(); }

14. Function Safety and Best Practices

Safety Considerations

// Function with preconditions fn divide_safe(numerator: f64, denominator: f64) -> Option<f64> { if denominator == 0.0 { None } else { Some(numerator / denominator) } } // Function with invariants struct PositiveInteger(i32); impl PositiveInteger { fn new(value: i32) -> Option<Self> { if value > 0 { Some(PositiveInteger(value)) } else { None } } fn value(&self) -> i32 { self.0 } } // Unsafe function unsafe fn dangerous_operation(ptr: *const i32) -> i32 { *ptr } // Safe wrapper around unsafe code fn safe_operation(value: &i32) -> i32 { *value } // Function with explicit panics fn get_element_at_index<T>(vec: &[T], index: usize) -> &T { if index >= vec.len() { panic!("Index out of bounds: {} >= {}", index, vec.len()); } &vec[index] } fn main() { // Safe division match divide_safe(10.0, 2.0) { Some(result) => println!("Result: {}", result), None => println!("Division by zero"), } // Positive integer if let Some(num) = PositiveInteger::new(5) { println!("Positive integer: {}", num.value()); } // Unsafe requires unsafe block let x = 42; let ptr = &x as *const i32; unsafe { println!("Dangerous: {}", dangerous_operation(ptr)); } // Panic on invalid index let vec = vec![1, 2, 3]; // println!("{}", get_element_at_index(&vec, 5)); // Panics println!("{}", get_element_at_index(&vec, 1)); // Works }

Function Design Best Practices

// 1. Keep functions focused (single responsibility) fn process_user_data(data: &str) -> Result<ProcessedData, Error> { // Only process, don't validate or save Ok(ProcessedData::new(data)) } // 2. Use meaningful names // Bad fn f(x: i32) -> i32 { x * 2 } // Good fn double(value: i32) -> i32 { value * 2 } // 3. Limit number of parameters // Bad fn create_user_bad(name: &str, age: i32, email: &str, phone: &str, address: &str, active: bool) {} // Good - use struct struct UserConfig { name: String, age: i32, email: String, phone: Option<String>, address: Option<String>, active: bool, } fn create_user_good(config: UserConfig) {} // 4. Return meaningful errors fn read_file_safe(path: &str) -> Result<String, std::io::Error> { std::fs::read_to_string(path) } // 5. Document functions /// Calculates the area of a rectangle. /// /// # Arguments /// /// * `width` - The width of the rectangle /// * `height` - The height of the rectangle /// /// # Returns /// /// The area of the rectangle as a `u32` /// /// # Examples /// /// ``` /// let area = rectangle_area(5, 10); /// assert_eq!(area, 50); /// ``` fn rectangle_area(width: u32, height: u32) -> u32 { width * height } struct ProcessedData { content: String, } impl ProcessedData { fn new(content: &str) -> Self { ProcessedData { content: content.to_string(), } } } #[derive(Debug)] struct Error; fn main() { let config = UserConfig { name: "Alice".to_string(), age: 30, email: "[email protected]".to_string(), phone: None, address: None, active: true, }; create_user_good(config); println!("Area: {}", rectangle_area(5, 10)); }

Conclusion

Rust's function system provides powerful and flexible tools for organizing code:

Key Takeaways

1. Function Declaration: fn keyword with explicit parameter and return types
2. Statements vs Expressions: Understanding the difference for implicit returns
3. Parameters: Pattern matching, references, and borrowing
4. Return Values: Single values, tuples, Result, Option, and references
5. Generics: Type-parameterized functions for code reuse
6. Higher-Order Functions: Functions as parameters and return values
7. Closures: Anonymous functions that capture environment
8. Methods: Functions associated with types
9. Function Pointers: References to functions
10. Diverging Functions: Functions that never return (!)

Best Practices

• Keep functions focused on a single task
• Use meaningful names that describe purpose
• Limit the number of parameters (consider structs)
• Document public functions with doc comments
• Handle errors appropriately with Result/Option
• Use generics to avoid code duplication
• Prefer expressions over statements when appropriate
• Follow Rust naming conventions (snake_case for functions)

Function Traits Summary

Trait	Description	Called
Fn	Immutably captures environment	Multiple times
FnMut	Mutably captures environment	Multiple times
FnOnce	Consumes captured variables	Once

Rust's function system combines the best of procedural and functional programming, providing both performance and expressiveness while maintaining strong safety guarantees through the type system and borrow checker.