Функции в Rust: синтаксис, замыкания и возврат значений

Функция — как рецепт: записываешь шаги один раз, используешь сколько угодно. В Rust функции — строительные блоки с интересными особенностями.

Объявление функции: fn

fn say_hello() {
    println!("Привет от функции!");
}

fn greet(name: &str, age: u32) {
    println!("Привет, {}! Тебе {} лет.", name, age);
}

fn add(a: i32, b: i32) -> i32 {
    a + b    // БЕЗ точки с запятой = возвращаем!
}

fn main() {
    say_hello();
    greet("Вася", 12);
    let r = add(5, 3);
    println!("5 + 3 = {}", r);
    println!("Прямо в println: {}", add(10, 20));
}

Выражения vs Утверждения

Утверждение — выполняет действие, НЕ возвращает значение: let x = 5;

Выражение — вычисляется и ВОЗВРАЩАЕТ значение: 5 + 3 → 8

fn main() {
    // Блок {} — это выражение!
    let y = {
        let x = 3;
        x * x + 1    // возвращается из блока (без ;)
    };
    println!("y = {}", y);  // 10

    fn square(n: i32) -> i32 {
        n * n   // выражение — возвращается автоматически
    }

    fn abs_val(n: i32) -> i32 {
        if n < 0 { return -n; }  // ранний выход
        n
    }

    // ЛОВУШКА: ; после возвращаемого значения = ошибка!
    // fn broken(n: i32) -> i32 {
    //     n * n;   // возвращает () — не i32!
    // }

    println!("5² = {}", square(5));
    println!("|-7| = {}", abs_val(-7));
}

Возврат нескольких значений через кортеж

fn min_max(nums: &[i32]) -> (i32, i32) {
    let mut min = nums[0];
    let mut max = nums[0];
    for &n in nums {
        if n < min { min = n; }
        if n > max { max = n; }
    }
    (min, max)
}

fn stats(nums: &[f64]) -> (f64, f64, f64) {
    let sum: f64 = nums.iter().sum();
    let avg = sum / nums.len() as f64;
    let min = nums.iter().cloned().fold(f64::INFINITY, f64::min);
    let max = nums.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
    (avg, min, max)
}

fn main() {
    let data = [5, 2, 8, 1, 9, 3];
    let (min, max) = min_max(&data);   // деструктурирование!
    println!("Мин: {}, Макс: {}", min, max);

    let grades = [4.5, 3.8, 5.0, 4.2];
    let (avg, lo, hi) = stats(&grades);
    println!("Avg={:.2}, Min={lo}, Max={hi}", avg);
}

Option и Result как возвращаемые значения

fn find_even(nums: &[i32]) -> Option {
    for &n in nums {
        if n % 2 == 0 { return Some(n); }
    }
    None
}

fn parse_age(s: &str) -> Result {
    match s.trim().parse::() {
        Ok(n) if n <= 150 => Ok(n),
        Ok(_)  => Err("Слишком большой".to_string()),
        Err(_) => Err(format!("'{}' не число", s)),
    }
}

fn main() {
    let nums = [3, 7, 5, 8, 2];
    match find_even(&nums) {
        Some(n) => println!("Первое чётное: {}", n),
        None    => println!("Чётных нет"),
    }

    for input in ["25", "abc", "200"] {
        match parse_age(input) {
            Ok(age) => println!("✅ {}", age),
            Err(e)  => println!("❌ {}", e),
        }
    }
}

Замыкания (Closures)

Аналогия: Шпаргалка с решением задачи. Написал, положил в карман, когда нужно — достал и использовал. Замыкание — функция в переменной.

fn main() {
    fn add_ten(x: i32) -> i32 { x + 10 }    // обычная функция
    let add_ten_cl = |x: i32| x + 10;        // замыкание — то же самое!
    println!("{} == {}", add_ten(5), add_ten_cl(5));

    let double = |x| x * 2;
    let square = |x: i32| x * x;
    println!("double(7)={}", double(7));
    println!("square(5)={}", square(5));

    // Многострочное замыкание
    let calc = |a: f64, b: f64| {
        let sum = a + b;
        let prod = a * b;
        (sum, prod)
    };
    let (s, p) = calc(3.0, 4.0);
    println!("3+4={}, 3×4={}", s, p);

    // ЗАХВАТ переменных из окружения!
    let bonus = 5;
    let add_bonus = |score| score + bonus;  // захватывает bonus
    for s in [85, 90, 78] {
        println!("{} + бонус = {}", s, add_bonus(s));
    }
}

Замыкания с итераторами

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // map — преобразование
    let doubled: Vec = numbers.iter().map(|&x| x * 2).collect();
    println!("{:?}", doubled);

    // filter — фильтрация
    let evens: Vec<&i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
    println!("{:?}", evens);

    // Цепочки
    let big_sq: Vec = numbers.iter()
        .filter(|&&x| x > 5)
        .map(|&x| x * x)
        .collect();
    println!("Квадраты > 5: {:?}", big_sq);

    // fold
    let sum = numbers.iter().fold(0, |acc, &x| acc + x);
    let product: u64 = (1u64..=10).fold(1, |acc, x| acc * x);
    println!("Сумма: {}, 10!: {}", sum, product);

    // any / all / find
    println!("Есть чётные: {}", numbers.iter().any(|&x| x % 2 == 0));
    println!("Все > 0: {}",     numbers.iter().all(|&x| x > 0));
    println!("Первое > 7: {:?}", numbers.iter().find(|&&x| x > 7));
}

Функции высшего порядка

fn apply_twice i32>(f: F, x: i32) -> i32 { f(f(x)) }

fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n   // move захватывает n по значению
}

fn make_multiplier(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x * n
}

fn main() {
    let double = |x| x * 2;
    println!("double дважды(3) = {}", apply_twice(double, 3));  // 12

    let add5 = make_adder(5);
    let triple = make_multiplier(3);
    println!("add5(7) = {}", add5(7));      // 12
    println!("triple(7) = {}", triple(7));  // 21

    let nums: Vec = (1..=5).map(|x| triple(x)).collect();
    println!("Утроенные: {:?}", nums);
}

Рекурсия

fn factorial(n: u64) -> u64 {
    match n { 0 | 1 => 1, n => n * factorial(n - 1) }
}

fn fib(n: u32) -> u64 {
    match n { 0 => 0, 1 => 1, n => fib(n-1) + fib(n-2) }
}

fn main() {
    for n in 0..=10 { println!("{}! = {}", n, factorial(n)); }
    print!("Фибоначчи: ");
    for i in 0..10 { print!("{} ", fib(i)); }
    println!();
}

Типичные ошибки

❌ Точка с запятой у возвращаемого значения

fn add(a: i32, b: i32) -> i32 {
    a + b;   // error: mismatched types (возвращает () вместо i32)
}
// Убери точку с запятой

❌ Несовместимый тип возврата

fn name() -> String { "Вася" }  // error: expected String, found &str
fn name() -> String { "Вася".to_string() }  // ✅

Итого

fn name(param: Type) -> ReturnType { ... } — объявление. Последнее выражение без ; — автоматически возвращается. return для раннего выхода.

Замыкания: |x| x * 2. Захватывают переменные из окружения. map, filter, fold, any, all — с итераторами. move |x| ... — захват по значению.

Дополнительные примеры для практики

Программирование — это навык, который улучшается только с практикой. Вот несколько задач для самостоятельной работы:

Задача 1: Числовые паттерны

fn main() {
    // Выведи пирамиду из звёздочек
    for i in 1..=5 {
        for _ in 0..i { print!("* "); }
        println!();
    }

    // Числа Фибоначчи итеративно (быстрее рекурсии)
    let mut a = 0u64;
    let mut b = 1u64;
    print!("Фибоначчи: ");
    for _ in 0..15 {
        print!("{} ", a);
        let c = a + b;
        a = b;
        b = c;
    }
    println!();

    // Простые числа через решето Эратосфена
    let n = 50usize;
    let mut is_prime = vec![true; n + 1];
    is_prime[0] = false;
    is_prime[1] = false;
    let mut i = 2;
    while i * i <= n {
        if is_prime[i] {
            let mut j = i * i;
            while j <= n {
                is_prime[j] = false;
                j += i;
            }
        }
        i += 1;
    }
    print!("Простые до {}: ", n);
    for k in 2..=n {
        if is_prime[k] { print!("{} ", k); }
    }
    println!();
}

Задача 2: Работа с данными

fn main() {
    let data = vec![
        ("Алиса", 85.0f64),
        ("Боря",  72.0),
        ("Вера",  91.0),
        ("Гриша", 68.0),
        ("Даша",  95.0),
    ];

    // Сортировка по убыванию
    let mut sorted = data.clone();
    sorted.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    println!("Топ учеников:");
    for (i, (name, score)) in sorted.iter().enumerate() {
        let medal = match i { 0 => "🥇", 1 => "🥈", 2 => "🥉", _ => "  " };
        println!("{} {} — {:.1}", medal, name, score);
    }

    let avg = data.iter().map(|(_, s)| s).sum::() / data.len() as f64;
    let above: Vec<_> = data.iter().filter(|(_, s)| *s > avg).collect();

    println!("
Средний балл: {:.2}", avg);
    println!("Выше среднего: {}", above.len());
}

Разбор типичных задач

// Палиндром
fn is_palindrome(s: &str) -> bool {
    let chars: Vec = s.chars().collect();
    let n = chars.len();
    for i in 0..n/2 {
        if chars[i] != chars[n-1-i] { return false; }
    }
    true
}

// FizzBuzz
fn fizzbuzz(n: u32) -> String {
    match (n % 3, n % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        _      => n.to_string(),
    }
}

// Подсчёт слов в тексте
fn word_frequencies(text: &str) -> std::collections::HashMap<&str, usize> {
    let mut freq = std::collections::HashMap::new();
    for word in text.split_whitespace() {
        *freq.entry(word).or_insert(0) += 1;
    }
    freq
}

fn main() {
    println!("'racecar' палиндром? {}", is_palindrome("racecar"));
    println!("'hello' палиндром? {}", is_palindrome("hello"));

    for n in 1..=20 { print!("{} ", fizzbuzz(n)); }
    println!();

    let text = "rust rust код код код программирование";
    let freq = word_frequencies(text);
    let mut pairs: Vec<_> = freq.iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(a.1));
    for (word, count) in pairs {
        println!("'{}': {}", word, count);
    }
}