Introduction to Functions in Rust

Functions are fundamental building blocks in Rust, allowing you to organize code into reusable, named blocks. Rust's function system combines elements from functional and systems programming, offering powerful features like pattern matching in parameters, multiple return types, and closure support while maintaining performance and safety.

Key Concepts

• Function Declaration: Defined with fn keyword
• Parameters: Typed inputs to functions
• Return Values: Functions always return something (even if implicitly)
• Statements vs Expressions: Understanding the distinction
• Ownership: Functions are boundaries for ownership transfer
• Generic Functions: Write code that works with multiple types

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  // Note: no semicolon means this is the return value
}
// Function with explicit return statement
fn multiply(a: i32, b: i32) -> i32 {
return a * b;  // Explicit return (less idiomatic)
}
fn main() {
greet();
greet_person("Alice");
let sum = add(5, 3);
println!("Sum: {}", sum);
let product = multiply(4, 2);
println!("Product: {}", product);
}

Statements vs Expressions

// Statements are instructions that don't return a value
fn statements_example() {
let x = 5;  // Statement
let y = {
let z = 10;  // Statement
z * 2        // Expression (returns value)
};  // The entire block is an expression that returns 20
println!("y = {}", y);
// if expressions
let condition = true;
let result = if condition { 5 } else { 6 };  // Expression
println!("result = {}", result);
// match expressions
let number = 3;
let description = match number {
1 => "one",
2 => "two",
_ => "other",
};  // Expression
println!("description = {}", description);
}
fn main() {
statements_example();
}

Function with Multiple Statements

fn complex_calculation(x: i32, y: i32) -> i32 {
// Multiple statements
let sum = x + y;
let product = x * y;
// Some conditional logic
if sum > product {
println!("Sum is larger");
sum
} else {
println!("Product is larger or equal");
product
}  // This is the return value
}
fn main() {
let result = complex_calculation(5, 3);
println!("Result: {}", result);
let result2 = complex_calculation(1, 10);
println!("Result: {}", result2);
}

2. Function Parameters

Basic Parameters

// Parameters with different types
fn print_info(name: &str, age: u32, height: f64) {
println!("Name: {}, Age: {}, Height: {:.2}", name, age, height);
}
// Multiple parameters of same type
fn sum(a: i32, b: i32, c: i32) -> i32 {
a + b + c
}
// Default values? Rust doesn't have default parameters
// Instead, use Option or create multiple functions
fn greet_with_title(name: &str, title: Option<&str>) {
match title {
Some(t) => println!("Hello, {} {}!", t, name),
None => println!("Hello, {}!", name),
}
}
fn main() {
print_info("Alice", 30, 5.8);
println!("Sum: {}", sum(1, 2, 3));
greet_with_title("Bob", Some("Dr."));
greet_with_title("Charlie", None);
}

Passing by Value vs Reference

// Pass by value (ownership moves)
fn take_ownership(s: String) {
println!("Took ownership of: {}", s);
} // s dropped here
// Pass by reference (borrowing)
fn borrow_string(s: &String) {
println!("Borrowed: {}", s);
} // s not dropped
// Pass by mutable reference
fn modify_string(s: &mut String) {
s.push_str(" world");
}
fn main() {
// By value
let s1 = String::from("hello");
take_ownership(s1);
// println!("{}", s1); // Error: s1 moved
// By reference
let s2 = String::from("hello");
borrow_string(&s2);
println!("Still have: {}", s2); // OK
// By mutable reference
let mut s3 = String::from("hello");
modify_string(&mut s3);
println!("Modified: {}", s3);
}

Pattern Matching in Parameters

// Destructuring tuples in parameters
fn print_tuple((x, y): (i32, i32)) {
println!("Tuple: ({}, {})", x, y);
}
// Destructuring structs
struct Point {
x: i32,
y: i32,
}
fn print_point(Point { x, y }: Point) {
println!("Point: ({}, {})", x, y);
}
// Destructuring with pattern matching
fn process_option(opt: Option<i32>) {
match opt {
Some(x) => println!("Got: {}", x),
None => println!("Got nothing"),
}
}
fn main() {
print_tuple((10, 20));
let p = Point { x: 5, y: 15 };
print_point(p);
process_option(Some(42));
process_option(None);
}

3. Return Values

Different Return Patterns

// Single return value
fn square(x: i32) -> i32 {
x * x
}
// Multiple return values using tuples
fn divide(dividend: i32, divisor: i32) -> (i32, i32) {
(dividend / divisor, dividend % divisor)
}
// Return Result for error handling
fn safe_divide(dividend: f64, divisor: f64) -> Result<f64, String> {
if divisor == 0.0 {
Err(String::from("Division by zero"))
} else {
Ok(dividend / divisor)
}
}
// Return Option for nullable values
fn find_index(vec: &[i32], target: i32) -> Option<usize> {
for (i, &val) in vec.iter().enumerate() {
if val == target {
return Some(i);
}
}
None
}
fn main() {
println!("Square: {}", square(5));
let (q, r) = divide(17, 5);
println!("Quotient: {}, Remainder: {}", q, r);
match safe_divide(10.0, 2.0) {
Ok(result) => println!("Division: {}", result),
Err(e) => println!("Error: {}", e),
}
let numbers = vec![1, 2, 3, 4, 5];
match find_index(&numbers, 3) {
Some(i) => println!("Found at index: {}", i),
None => println!("Not found"),
}
}

Unit Type and Diverging Functions

// Unit type () - functions that don't return anything meaningful
fn do_something() {
println!("Doing something");
} // Implicitly returns ()
// Explicit unit return
fn do_something_else() -> () {
println!("Doing something else");
()
}
// Diverging functions (never return)
fn panic_forever() -> ! {
panic!("This function never returns");
}
// Loop that never ends
fn infinite_loop() -> ! {
loop {
println!("Running forever...");
}
}
// Using ! type in match
fn process_optional(x: Option<i32>) -> i32 {
match x {
Some(val) => val,
None => panic!("No value!"), // panic! returns !
}
}
fn main() {
let result = do_something();
println!("Result: {:?}", result); // ()
// This would never return:
// infinite_loop();
println!("Processing: {}", process_optional(Some(42)));
// println!("{}", process_optional(None)); // This would panic
}

4. Function Overloading and Generic Functions

Generic Functions

// Generic function with type parameter T
fn identity<T>(x: T) -> T {
x
}
// Generic with multiple type parameters
fn swap<T, U>(pair: (T, U)) -> (U, T) {
(pair.1, pair.0)
}
// Generic with trait bounds
use std::fmt::Display;
fn print_and_return<T: Display>(x: T) -> T {
println!("Value: {}", x);
x
}
// 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 {
println!("{} is less than or equal to {}", a, b);
}
}
fn main() {
let x = identity(42);
let y = identity("hello");
println!("x: {}, y: {}", x, y);
let swapped = swap((1, "hello"));
println!("Swapped: {:?}", swapped);
let printed = print_and_return(3.14);
println!("Printed and returned: {}", printed);
compare_and_print(10, 5);
compare_and_print("abc", "def");
}

Generic Struct Methods

struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn new(x: T, y: T) -> Self {
Point { x, y }
}
fn x(&self) -> &T {
&self.x
}
fn y(&self) -> &T {
&self.y
}
}
// Specialized implementation for f64
impl Point<f64> {
fn distance_from_origin(&self) -> f64 {
(self.x.powi(2) + self.y.powi(2)).sqrt()
}
}
// Generic with different types
struct MixedPoint<T, U> {
x: T,
y: U,
}
impl<T, U> MixedPoint<T, U> {
fn new(x: T, y: U) -> Self {
MixedPoint { x, y }
}
}
fn main() {
let int_point = Point::new(5, 10);
let float_point = Point::new(3.0, 4.0);
println!("int_point x: {}", int_point.x());
println!("distance: {}", float_point.distance_from_origin());
let mixed = MixedPoint::new(5, 3.14);
}

5. Higher-Order Functions

Functions as Parameters

// Function that takes a function as parameter
fn apply_twice<T, F>(f: F, x: T) -> T 
where 
F: Fn(T) -> T,
{
f(f(x))
}
// Function returning a function
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
move |y| x + y
}
// Function taking different kinds of closures
fn process<F>(f: F) 
where
F: FnOnce() -> String,  // FnOnce can be called once
{
println!("Result: {}", f());
}
fn main() {
let double = |x| x * 2;
let quadruple = apply_twice(double, 5);
println!("Quadruple: {}", quadruple);
let add_five = make_adder(5);
println!("Add 5 to 10: {}", add_five(10));
let name = String::from("Alice");
let greet = move || format!("Hello, {}!", name); // name moved into closure
process(greet);
// println!("{}", name); // Error: name moved
}

Common Higher-Order Functions

fn main() {
let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// map: transform each element
let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
println!("Doubled: {:?}", doubled);
// filter: keep elements that satisfy condition
let evens: Vec<&i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
println!("Evens: {:?}", evens);
// fold (reduce): accumulate values
let sum: i32 = numbers.iter().fold(0, |acc, &x| acc + x);
println!("Sum: {}", sum);
// Chaining higher-order functions
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);
// any and all
let has_negative = numbers.iter().any(|&x| x < 0);
let all_positive = numbers.iter().all(|&x| x > 0);
println!("Has negative: {}, All positive: {}", has_negative, all_positive);
// find
if let Some(first_even) = numbers.iter().find(|&&x| x % 2 == 0) {
println!("First even: {}", first_even);
}
}

6. Closures

Basic Closure Syntax

fn main() {
// Basic 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(10): {}", add_x(10));
// move closure - takes ownership
let s = String::from("hello");
let consume_s = move || {
println!("{}", s);
};
consume_s();
// println!("{}", s); // Error: s moved
// Different Fn traits
let fn_once = || {
println!("FnOnce");
};
fn_once(); // Can be called multiple times despite name
let mut counter = 0;
let mut fn_mut = || {
counter += 1;
println!("Counter: {}", counter);
};
fn_mut();
fn_mut();
}

Closure Capture Modes

fn main() {
// Immutable borrow
let s1 = String::from("hello");
let borrow = || println!("{}", s1);
borrow();
borrow();
println!("Still have s1: {}", s1); // OK
// Mutable borrow
let mut s2 = String::from("hello");
let mut mutate = || {
s2.push_str(" world");
};
mutate();
mutate();
println!("Now s2 is: {}", s2);
// Take ownership
let s3 = String::from("hello");
let take = move || {
let s = s3;
println!("Took ownership of: {}", s);
};
take();
// println!("{}", s3); // Error: s3 moved
// Multiple captures in different modes
let x = 5;
let mut y = 10;
let z = String::from("z");
let complex = || {
println!("x: {}", x); // immutable borrow
y += 5; // mutable borrow
println!("z: {}", z); // immutable borrow
};
complex();
println!("y now: {}", y);
}

Closures as Return Values

fn create_counter() -> impl FnMut() -> i32 {
let mut count = 0;
move || {
count += 1;
count
}
}
fn create_adder(x: i32) -> impl Fn(i32) -> i32 {
move |y| x + y
}
fn create_multiplier(factor: i32) -> Box<dyn Fn(i32) -> i32> {
Box::new(move |x| x * factor)
}
fn create_processor(kind: &str) -> Box<dyn Fn(i32) -> i32> {
match kind {
"double" => Box::new(|x| x * 2),
"square" => Box::new(|x| x * x),
"negate" => Box::new(|x| -x),
_ => Box::new(|x| x),
}
}
fn main() {
let mut counter = create_counter();
println!("Counter: {}", counter());
println!("Counter: {}", counter());
println!("Counter: {}", counter());
let add_five = create_adder(5);
println!("Add 5 to 10: {}", add_five(10));
let multiplier = create_multiplier(3);
println!("3 * 7 = {}", multiplier(7));
let processor = create_processor("square");
println!("Square of 5: {}", processor(5));
}

7. Function Pointers

Function Pointers vs Closures

fn add_one(x: i32) -> i32 {
x + 1
}
fn do_twice(f: fn(i32) -> i32, x: i32) -> i32 {
f(f(x))
}
// Function that can accept either function pointer or closure
fn process<F>(f: F, x: i32) -> i32 
where 
F: Fn(i32) -> i32,
{
f(x)
}
fn main() {
// Function pointer
let fn_ptr: fn(i32) -> i32 = add_one;
println!("fn_ptr(5): {}", fn_ptr(5));
// Pass function pointer to function
let result = do_twice(add_one, 5);
println!("do_twice: {}", result);
// Function pointer from closure without capture
let closure_ptr: fn(i32) -> i32 = |x| x * 2;
println!("closure_ptr(5): {}", closure_ptr(5));
// Process with different callables
println!("process(add_one, 5): {}", process(add_one, 5));
println!("process(|x| x * 2, 5): {}", process(|x| x * 2, 5));
// Array of function pointers
let operations: [fn(i32, i32) -> i32; 4] = [
|a, b| a + b,
|a, b| a - b,
|a, b| a * b,
|a, b| a / b,
];
let a = 10;
let b = 5;
for (i, op) in operations.iter().enumerate() {
println!("Operation {}: {}", i, op(a, b));
}
}

Function Pointers in Structs

struct Calculator {
operation: fn(i32, i32) -> i32,
}
impl Calculator {
fn new(op: fn(i32, i32) -> i32) -> Self {
Calculator { operation: op }
}
fn calculate(&self, a: i32, b: i32) -> i32 {
(self.operation)(a, b)
}
}
// Command pattern using function pointers
struct Command {
name: String,
action: fn() -> (),
}
impl Command {
fn execute(&self) {
println!("Executing command: {}", self.name);
(self.action)();
}
}
fn hello() {
println!("Hello!");
}
fn goodbye() {
println!("Goodbye!");
}
fn main() {
let add = Calculator::new(|a, b| a + b);
let multiply = Calculator::new(|a, b| a * b);
println!("Add: {}", add.calculate(5, 3));
println!("Multiply: {}", multiply.calculate(5, 3));
let commands = vec![
Command { name: "greet".to_string(), action: hello },
Command { name: "farewell".to_string(), action: goodbye },
Command { name: "custom".to_string(), action: || println!("Custom!") },
];
for cmd in commands {
cmd.execute();
}
}

8. Method Functions

Defining Methods

struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
// Method that borrows self immutably
fn area(&self) -> u32 {
self.width * self.height
}
// Method that borrows self mutably
fn set_width(&mut self, width: u32) {
self.width = width;
}
// Method that takes ownership
fn destroy(self) {
println!("Destroying rectangle: {}x{}", self.width, self.height);
}
// Associated function (no self)
fn square(size: u32) -> Rectangle {
Rectangle {
width: size,
height: size,
}
}
// Getter
fn width(&self) -> u32 {
self.width
}
// Setter with validation
fn set_height(&mut self, height: u32) -> Result<(), String> {
if height == 0 {
Err("Height must be positive".to_string())
} else {
self.height = height;
Ok(())
}
}
// Method with multiple parameters
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
// Method that returns a reference
fn dimensions(&self) -> (u32, u32) {
(self.width, self.height)
}
}
fn main() {
let mut rect = Rectangle {
width: 30,
height: 50,
};
println!("Area: {}", rect.area());
println!("Width: {}", rect.width());
rect.set_width(40);
println!("New width: {}", rect.width());
if let Err(e) = rect.set_height(0) {
println!("Error: {}", e);
}
let square = Rectangle::square(20);
println!("Square area: {}", square.area());
println!("Can rect hold square? {}", rect.can_hold(&square));
// rect.destroy(); // Uncomment to take ownership
// println!("{:?}", rect.width()); // Error: rect moved
}

Method Chaining

struct StringBuilder {
content: String,
}
impl StringBuilder {
fn new() -> Self {
StringBuilder {
content: String::new(),
}
}
fn append(mut self, text: &str) -> Self {
self.content.push_str(text);
self
}
fn append_line(mut self, text: &str) -> Self {
self.content.push_str(text);
self.content.push('\n');
self
}
fn build(self) -> String {
self.content
}
}
struct Calculator2 {
value: i32,
}
impl Calculator2 {
fn new(value: i32) -> Self {
Calculator2 { value }
}
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 result(self) -> i32 {
self.value
}
}
fn main() {
let result = StringBuilder::new()
.append("Hello")
.append_line(", World!")
.append("This is a ")
.append("chained method call")
.build();
println!("{}", result);
let calc = Calculator2::new(10)
.add(5)
.multiply(2)
.subtract(3)
.result();
println!("Calculation result: {}", calc);
}

9. Recursive Functions

Basic Recursion

fn factorial(n: u64) -> u64 {
if n <= 1 {
1
} else {
n * factorial(n - 1)
}
}
fn fibonacci(n: u64) -> u64 {
match n {
0 => 0,
1 => 1,
_ => fibonacci(n - 1) + fibonacci(n - 2),
}
}
// Tail recursive factorial
fn factorial_tail(n: u64, acc: u64) -> u64 {
if n <= 1 {
acc
} else {
factorial_tail(n - 1, n * acc)
}
}
fn main() {
println!("Factorial of 5: {}", factorial(5));
println!("Factorial of 5 (tail): {}", factorial_tail(5, 1));
println!("Fibonacci of 10: {}", fibonacci(10));
// Be careful with deep recursion (stack overflow)
// let result = factorial(10000); // Might overflow stack
}

Recursive Data Structures

#[derive(Debug)]
enum BinaryTree<T> {
Empty,
Node {
value: T,
left: Box<BinaryTree<T>>,
right: Box<BinaryTree<T>>,
},
}
impl<T: PartialOrd + Clone> BinaryTree<T> {
fn new() -> Self {
BinaryTree::Empty
}
fn insert(&mut self, value: T) {
match self {
BinaryTree::Empty => {
*self = BinaryTree::Node {
value,
left: Box::new(BinaryTree::Empty),
right: Box::new(BinaryTree::Empty),
}
}
BinaryTree::Node { value: v, left, right } => {
if value < *v {
left.insert(value);
} else if value > *v {
right.insert(value);
}
// Equal values are ignored
}
}
}
fn contains(&self, value: &T) -> bool {
match self {
BinaryTree::Empty => false,
BinaryTree::Node { value: v, left, right } => {
if value == v {
true
} else if value < v {
left.contains(value)
} else {
right.contains(value)
}
}
}
}
fn size(&self) -> usize {
match self {
BinaryTree::Empty => 0,
BinaryTree::Node { left, right, .. } => 1 + left.size() + right.size(),
}
}
}
fn main() {
let mut tree = BinaryTree::new();
for value in [5, 3, 7, 1, 4, 6, 8] {
tree.insert(value);
}
println!("Tree size: {}", tree.size());
println!("Contains 4? {}", tree.contains(&4));
println!("Contains 9? {}", tree.contains(&9));
}

10. Function Attributes and Macros

Function Attributes

// Inline attribute
#[inline]
fn small_function(x: i32) -> i32 {
x + 1
}
// Always inline
#[inline(always)]
fn always_inline(x: i32) -> i32 {
x * 2
}
// Never inline
#[inline(never)]
fn never_inline(x: i32) -> i32 {
x / 2
}
// Conditional compilation
#[cfg(target_os = "linux")]
fn os_specific() {
println!("Running on Linux");
}
#[cfg(target_os = "windows")]
fn os_specific() {
println!("Running on Windows");
}
// Deprecated function
#[deprecated(since = "1.2.0", note = "Use new_function instead")]
fn old_function() {
println!("This is old");
}
// Test function
#[test]
fn test_addition() {
assert_eq!(2 + 2, 4);
}
// Benchmark function
#[bench]
fn bench_addition(b: &mut test::Bencher) {
b.iter(|| 2 + 2);
}
fn main() {
println!("{}", small_function(5));
println!("{}", always_inline(5));
println!("{}", never_inline(5));
os_specific();
old_function(); // Compiler will warn
}

Function-like Macros

// Simple macro
macro_rules! say_hello {
() => {
println!("Hello!");
};
}
// Macro with parameters
macro_rules! create_function {
($func_name:ident, $input:ident, $body:expr) => {
fn $func_name($input: i32) -> i32 {
$body
}
};
}
create_function!(double, x, x * 2);
create_function!(square, x, x * x);
// Macro with repetition
macro_rules! vec_of_strings {
($($x:expr),*) => {
vec![$(String::from($x)),*]
};
}
// Macro for logging
macro_rules! log {
($level:expr, $($arg:tt)*) => {
println!("[{}] {}", $level, format_args!($($arg)*));
};
}
fn main() {
say_hello!();
println!("Double 5: {}", double(5));
println!("Square 5: {}", square(5));
let strings = vec_of_strings!["a", "b", "c"];
println!("Strings: {:?}", strings);
log!("INFO", "Application started");
log!("ERROR", "Something went wrong: {}", 404);
}

11. Advanced Function Features

Variadic Functions (via macros)

// Rust doesn't have variadic functions, but macros can simulate them
macro_rules! sum {
($($x:expr),*) => {
{
let mut total = 0;
$(total += $x;)*
total
}
};
($($x:expr,)*) => {
sum!($($x),*)
};
}
macro_rules! print_all {
($($arg:expr),*) => {
$(
print!("{} ", $arg);
)*
println!();
};
}
fn main() {
let s = sum!(1, 2, 3, 4, 5);
println!("Sum: {}", s);
let s = sum!(1, 2, 3);
println!("Sum: {}", s);
print_all!("Hello", "world", "from", "Rust");
print_all!(1, 2, 3, 4, 5);
}

Function with Default Parameters (using Option)

struct Config {
host: String,
port: u16,
timeout: Option<u64>,
}
fn connect(host: &str, port: u16, timeout: Option<u64>) -> Result<(), String> {
println!("Connecting to {}:{}", host, port);
if let Some(t) = timeout {
println!("With timeout: {}s", t);
}
Ok(())
}
// Builder pattern for functions with many parameters
struct ConnectionBuilder {
host: String,
port: u16,
timeout: Option<u64>,
retries: u32,
ssl: bool,
}
impl ConnectionBuilder {
fn new(host: &str) -> Self {
ConnectionBuilder {
host: host.to_string(),
port: 80,
timeout: None,
retries: 3,
ssl: false,
}
}
fn port(mut self, port: u16) -> Self {
self.port = port;
self
}
fn timeout(mut self, timeout: u64) -> Self {
self.timeout = Some(timeout);
self
}
fn retries(mut self, retries: u32) -> Self {
self.retries = retries;
self
}
fn ssl(mut self, ssl: bool) -> Self {
self.ssl = ssl;
self
}
fn connect(self) -> Result<(), String> {
println!("Connecting to {}:{}", self.host, self.port);
println!("SSL: {}, Retries: {}", self.ssl, self.retries);
if let Some(t) = self.timeout {
println!("Timeout: {}s", t);
}
Ok(())
}
}
fn main() {
// Using Option for default parameters
connect("localhost", 8080, None).unwrap();
connect("localhost", 8080, Some(30)).unwrap();
// Using builder pattern
ConnectionBuilder::new("example.com")
.port(443)
.ssl(true)
.timeout(60)
.retries(5)
.connect()
.unwrap();
}

Function with Variable Number of Arguments (using slices)

fn sum_slice(numbers: &[i32]) -> i32 {
numbers.iter().sum()
}
fn concatenate_strings(strings: &[&str]) -> String {
let mut result = String::new();
for s in strings {
result.push_str(s);
}
result
}
// Using IntoIterator for flexibility
fn sum_iterable<I>(numbers: I) -> i32
where
I: IntoIterator<Item = i32>,
{
numbers.into_iter().sum()
}
fn main() {
let numbers = [1, 2, 3, 4, 5];
println!("Sum: {}", sum_slice(&numbers));
println!("Sum: {}", sum_slice(&[1, 2, 3]));
println!("Concatenated: {}", concatenate_strings(&["Hello", " ", "World"]));
// Using IntoIterator
println!("Sum from array: {}", sum_iterable(vec![1, 2, 3]));
println!("Sum from range: {}", sum_iterable(1..=5));
}

12. Error Handling in Functions

Result and Option Return Types

use std::num::ParseIntError;
fn parse_number(s: &str) -> Result<i32, ParseIntError> {
s.parse()
}
fn divide_safe(a: f64, b: f64) -> Option<f64> {
if b == 0.0 {
None
} else {
Some(a / b)
}
}
fn process_file(filename: &str) -> Result<String, std::io::Error> {
std::fs::read_to_string(filename)
}
// Using ? operator
fn read_and_parse(filename: &str) -> Result<i32, Box<dyn std::error::Error>> {
let content = std::fs::read_to_string(filename)?;
let number = content.trim().parse::<i32>()?;
Ok(number)
}
// Custom error type
#[derive(Debug)]
enum AppError {
Io(std::io::Error),
Parse(ParseIntError),
InvalidData(String),
}
impl std::fmt::Display for AppError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
AppError::Io(e) => write!(f, "IO error: {}", e),
AppError::Parse(e) => write!(f, "Parse error: {}", e),
AppError::InvalidData(s) => write!(f, "Invalid data: {}", s),
}
}
}
impl std::error::Error for AppError {}
// Conversions from other error types
impl From<std::io::Error> for AppError {
fn from(error: std::io::Error) -> Self {
AppError::Io(error)
}
}
impl From<ParseIntError> for AppError {
fn from(error: ParseIntError) -> Self {
AppError::Parse(error)
}
}
fn process_with_custom_error(filename: &str) -> Result<i32, AppError> {
let content = std::fs::read_to_string(filename)?; // Converts io::Error to AppError
let number = content.trim().parse::<i32>()?; // Converts ParseIntError to AppError
if number < 0 {
return Err(AppError::InvalidData("Number must be positive".to_string()));
}
Ok(number)
}
fn main() {
match parse_number("42") {
Ok(n) => println!("Parsed: {}", n),
Err(e) => println!("Error: {}", e),
}
match divide_safe(10.0, 2.0) {
Some(r) => println!("Division: {}", r),
None => println!("Division by zero"),
}
// Using ? operator in main with Box<dyn Error>
fn inner_main() -> Result<(), Box<dyn std::error::Error>> {
let num = read_and_parse("number.txt")?;
println!("Number: {}", num);
Ok(())
}
if let Err(e) = inner_main() {
println!("Error: {}", e);
}
// Using custom error
match process_with_custom_error("number.txt") {
Ok(n) => println!("Processed: {}", n),
Err(e) => println!("App error: {}", e),
}
}

Conclusion

Functions in Rust provide a powerful and flexible way to organize code:

Key Takeaways

1. Function Declaration: Use fn keyword with explicit parameter and return types
2. Statements vs Expressions: Understand the difference for return values
3. Ownership: Functions are ownership boundaries with move semantics
4. Generics: Write type-safe code that works with multiple types
5. Closures: Anonymous functions that capture environment
6. Higher-Order Functions: Functions that take or return functions
7. Methods: Functions associated with types
8. Attributes: Control compilation and behavior
9. Error Handling: Return Result and Option for fallible operations

Best Practices

1. Keep functions focused: Each function should do one thing well
2. Use descriptive names: Function names should describe what they do
3. Prefer expressions over statements: More idiomatic Rust
4. Document public functions: Use doc comments (///)
5. Handle errors appropriately: Use Result for recoverable errors
6. Use generics judiciously: Don't over-abstract
7. Prefer immutability: Default to immutable parameters
8. Use type aliases: For complex function signatures

Common Patterns

• Builder Pattern: For functions with many parameters
• Strategy Pattern: Using function pointers/closures
• Command Pattern: Encapsulating operations
• Callback Pattern: For asynchronous operations
• Pipeline Pattern: Chaining function calls

Functions are the primary way to structure Rust code, and mastering them is essential for writing clean, maintainable, and efficient Rust programs.