Функции в 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);
    }
}

use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;

fn main() {
    // HashMap — ассоциативный массив
    let mut scores: HashMap> = HashMap::new();
    
    scores.entry("Алиса".to_string()).or_insert_with(Vec::new).push(5);
    scores.entry("Алиса".to_string()).or_insert_with(Vec::new).push(4);
    scores.entry("Боря".to_string()).or_insert_with(Vec::new).push(3);
    scores.entry("Боря".to_string()).or_insert_with(Vec::new).push(4);
    
    for (name, grades) in &scores {
        let avg: f64 = grades.iter().sum::() as f64 / grades.len() as f64;
        println!("{}: avg={:.2} grades={:?}", name, avg, grades);
    }
    
    // HashSet — уникальные значения
    let mut seen: HashSet = HashSet::new();
    let data = vec![1, 2, 2, 3, 3, 3, 4, 4, 4, 4];
    let mut unique = Vec::new();
    for &n in &data {
        if seen.insert(n) {
            unique.push(n);
        }
    }
    println!("Уникальные: {:?}", unique);
    
    // Пересечение и объединение множеств
    let set_a: HashSet<_> = [1, 2, 3, 4, 5].iter().collect();
    let set_b: HashSet<_> = [3, 4, 5, 6, 7].iter().collect();
    
    let intersection: Vec<_> = set_a.intersection(&set_b).collect();
    let union: Vec<_> = set_a.union(&set_b).collect();
    println!("Пересечение: {:?}", intersection);
    println!("Объединение: {:?}", union);
    
    // VecDeque — двусторонняя очередь
    let mut queue: VecDeque = VecDeque::new();
    queue.push_back(1);
    queue.push_back(2);
    queue.push_back(3);
    queue.push_front(0);
    println!("Очередь: {:?}", queue);
    println!("Извлекли спереди: {:?}", queue.pop_front());
}

use std::num::ParseIntError;
use std::fmt;

#[derive(Debug)]
enum AppError {
    ParseError(ParseIntError),
    ValidationError(String),
    NotFound(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::ParseError(e)       => write!(f, "Ошибка парсинга: {}", e),
            AppError::ValidationError(msg) => write!(f, "Ошибка валидации: {}", msg),
            AppError::NotFound(key)       => write!(f, "Не найдено: {}", key),
        }
    }
}

impl From for AppError {
    fn from(e: ParseIntError) -> Self { AppError::ParseError(e) }
}

fn parse_positive(s: &str) -> Result {
    let n: i32 = s.trim().parse()?;    // ? преобразует ParseIntError через From
    if n <= 0 {
        return Err(AppError::ValidationError(format!("{} не положительное", n)));
    }
    Ok(n as u32)
}

fn find_square_root(n: &str) -> Result {
    let num = parse_positive(n)?;
    Ok((num as f64).sqrt())
}

fn main() {
    let inputs = ["25", "-5", "abc", "100", "0"];
    for input in inputs {
        match find_square_root(input) {
            Ok(r)  => println!("√{} = {:.4}", input, r),
            Err(e) => println!("Ошибка для '{}': {}", input, e),
        }
    }
}

fn main() {
    let numbers = vec![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // Цепочка итераторов — ленивая, выполняется при collect/sum/etc
    let result: Vec = numbers.iter()
        .filter(|&&n| n % 2 == 0)       // только чётные: 2,4,6,8,10
        .map(|&n| n * n)                 // квадраты: 4,16,36,64,100
        .filter(|&n| n > 20)             // > 20: 36,64,100
        .map(|n| format!("{}²", (n as f64).sqrt() as i32)) // "6²", "8²", "10²"
        .collect();
    
    println!("{:?}", result);
    
    // zip — объединяем два итератора
    let names = vec!["Алиса", "Боря", "Вера"];
    let grades = vec![4.8, 3.9, 4.5];
    let combined: Vec<_> = names.iter().zip(grades.iter()).collect();
    for (name, grade) in &combined {
        println!("{}: {:.1}", name, grade);
    }
    
    // enumerate + zip
    let numbered: Vec<_> = names.iter()
        .zip(grades.iter())
        .enumerate()
        .map(|(i, (n, g))| format!("{}. {}: {}", i+1, n, g))
        .collect();
    println!("{:?}", numbered);
    
    // scan — промежуточные результаты (как fold, но возвращает итератор)
    let running_sum: Vec = (1..=5)
        .scan(0, |acc, x| { *acc += x; Some(*acc) })
        .collect();
    println!("Нарастающая сумма: {:?}", running_sum);  // [1, 3, 6, 10, 15]
    
    // flat_map — flatten + map
    let words = vec!["hello world", "foo bar baz"];
    let all_words: Vec<&str> = words.iter()
        .flat_map(|s| s.split_whitespace())
        .collect();
    println!("{:?}", all_words);
    
    // take и skip
    let first_5: Vec = (1..).take(5).collect();
    let skip_5: Vec = (1..=10).skip(5).collect();
    println!("take(5): {:?}", first_5);
    println!("skip(5): {:?}", skip_5);
}

use std::collections::HashMap;

#[derive(Debug, Clone)]
struct Student {
    name: String,
    class: String,
    grades: HashMap,
}

impl Student {
    fn new(name: &str, class: &str) -> Self {
        Student {
            name: name.to_string(),
            class: class.to_string(),
            grades: HashMap::new(),
        }
    }

    fn add_grade(&mut self, subject: &str, grade: f64) {
        self.grades.insert(subject.to_string(), grade);
    }

    fn gpa(&self) -> f64 {
        if self.grades.is_empty() { return 0.0; }
        self.grades.values().sum::() / self.grades.len() as f64
    }

    fn is_excellent(&self) -> bool {
        self.gpa() >= 4.5 && self.grades.values().all(|&g| g >= 4.0)
    }
}

struct Database {
    students: Vec,
}

impl Database {
    fn new() -> Self { Database { students: Vec::new() } }
    fn add(&mut self, student: Student) { self.students.push(student); }
    
    fn by_class(&self, class: &str) -> Vec<&Student> {
        self.students.iter().filter(|s| s.class == class).collect()
    }
    
    fn top_students(&self, n: usize) -> Vec<&Student> {
        let mut sorted: Vec<&Student> = self.students.iter().collect();
        sorted.sort_by(|a, b| b.gpa().partial_cmp(&a.gpa()).unwrap());
        sorted.into_iter().take(n).collect()
    }
    
    fn class_average(&self, class: &str) -> f64 {
        let class_students: Vec<_> = self.by_class(class);
        if class_students.is_empty() { return 0.0; }
        class_students.iter().map(|s| s.gpa()).sum::() / class_students.len() as f64
    }
}

fn main() {
    let mut db = Database::new();
    
    let mut alice = Student::new("Алиса", "6А");
    alice.add_grade("Математика", 5.0);
    alice.add_grade("Русский", 5.0);
    alice.add_grade("Английский", 4.0);
    
    let mut bob = Student::new("Боря", "6Б");
    bob.add_grade("Математика", 4.0);
    bob.add_grade("Русский", 3.0);
    bob.add_grade("Английский", 4.0);
    
    let mut vera = Student::new("Вера", "6А");
    vera.add_grade("Математика", 5.0);
    vera.add_grade("Русский", 5.0);
    vera.add_grade("Английский", 5.0);
    
    db.add(alice);
    db.add(bob);
    db.add(vera);
    
    println!("=== Класс 6А ===");
    for s in db.by_class("6А") {
        println!("{}: GPA={:.2} Отличник?{}", s.name, s.gpa(), s.is_excellent());
    }
    
    println!("\n=== Топ 2 студента ===");
    for s in db.top_students(2) {
        println!("{} ({}): {:.2}", s.name, s.class, s.gpa());
    }
    
    println!("\nСредний 6А: {:.2}", db.class_average("6А"));
    println!("Средний 6Б: {:.2}", db.class_average("6Б"));
}