1 tháng học Rust - Closure

Vấn đề

Trong JavaScript, Closure để chỉ một hàm có thể nhớ và truy cập các biến trong phạm vi bên ngoài của nó, ngay cả sau khi phạm vi bên ngoài đó đã kết thúc. Nói ngắn gọn, khi một hàm được định nghĩa bên trong một hàm khác, nó truy cập các biến từ hàm cha thì closure được tạo ra.

Ví dụ:

function makeCounter() {
  let count = 0; // biến trong phạm vi của makeCounter

  return function() {
    count++; // closure truy cập biến count
    return count;
  };
}

const counter1 = makeCounter(); // Tạo closure
console.log(counter1()); // 1
console.log(counter1()); // 2

count chỉ tồn tại trong makeCounter, nhưng hàm trả về (return) vẫn truy cập được nó. Bằng chứng là mỗi lần gọi counter1() thì count tăng dần.

Trong Rust, closure cũng tương tự như trong JavaScript, nó có thể ghi nhớ và sử dụng biến từ phạm vi bên ngoài nơi nó được định nghĩa. Tuy vậy, closure trong Rust phức tạp hơn JavaScript rất nhiều.

Closure trong Rust

Closure trong Rust là các hàm ẩn danh mà bạn có thể lưu trong một biến hoặc truyền dưới dạng đối số cho các hàm khác. Bạn có thể tạo closure ở một nơi rồi gọi closure ở nơi khác.

Không giống như các hàm, closure có thể nắm bắt các giá trị từ phạm vi mà chúng được định nghĩa. Lấy một ví dụ để so sánh giữa hàm với closure.

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    println!("{}", add(1, 2));
}

Để gọi add, buộc phải truyền vào 2 tham số a và b, hàm trả về tổng của 2 số đó.

Trong khi đó closure được viết như sau.

fn main() {
    let a = 1;
    let add = |b| a + b;

    println!("{}", add(2)); // 3
}

add là một hàm closure, khi gọi add nó có thể truy cập được vào biến a từ môi trường bên ngoài.

Closure có thể được khai báo bằng cách gán vào một biến hoặc gọi trực tiếp từ nơi thực thi. |b| a + b là cách viết rút gọn của closure. Cách viết đầy đủ trông giống như:

fn main() {
  let a = 1;
  let add = |b: u32| -> u32 {
    a + b
  };

  println!("{}", add(2)); // 3
}

Quyền sở hữu

Closure có thể nắm bắt các giá trị từ môi trường của chúng theo ba cách:

• Mượn bất biến.

• Mượn có thể thay đổi.

• Chiếm quyền sở hữu.

Closure sẽ quyết định sử dụng cách nào trong số này dựa trên phần xử lý trong thân hàm closure.

Ví dụ.

fn main() {
    let list = vec![1, 2, 3];
    println!("Before defining closure: {list:?}");

    let only_borrows = || println!("From closure: {list:?}");

    println!("Before calling closure: {list:?}");
    only_borrows();
    println!("After calling closure: {list:?}");
}

only_borrows chỉ đơn giản là in ra danh sách trong list, vì vậy closure này chỉ mượn bất biến.

Xem tiếp ví dụ dưới đây.

fn main() {
    let mut list = vec![1, 2, 3];
    println!("Before defining closure: {list:?}");

    let mut borrows_mutably = || list.push(7);

    borrows_mutably();
    println!("After calling closure: {list:?}");
}

borrows_mutably gọi một hàm push vào list, nó làm thay đổi list ban đầu cho nên closure này mượn có thể thay đổi.

Closure chiếm quyền sở hữu như ở trong ví dụ dưới đây.

use std::thread;

fn main() {
    let list = vec![1, 2, 3];
    println!("Before defining closure: {list:?}");

    thread::spawn(move || println!("From thread: {list:?}"))
        .join()
        .unwrap();
}

Fn, FnMut, FnOnce

Sau khi closure đã nắm bắt được tham chiếu hoặc nắm bắt được quyền sở hữu giá trị từ môi trường nơi closure được định nghĩa, mã trong phần thân của closure sẽ xác định những gì xảy ra với các tham chiếu hoặc giá trị khi closure được chạy. Closure có thể thực hiện bất kỳ hành động nào sau đây: di chuyển giá trị đã nắm bắt ra khỏi closure, thay đổi giá trị hoặc không gây ra ảnh hưởng gì cả.

Vì vậy có tổng cộng 3 kiểu closure triển khai trait là Fn, FnMut và FnOnce tương ứng với 3 cách mà closure "đối xử" với quyền sở hữu của các giá trị từ môi trường mà nó nắm bắt: bất biến, có thể thay đổi và chiếm quyền.

Tại sao phải triển khai 3 kiểu này vì nó quyết định cách sử dụng closure trong một số trường hợp nhất định. Ví dụ phương thức sort_by_key dùng để sắp xếp lại danh sách chỉ có thể sử dụng clousure triển khai Fn.

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];

    list.sort_by_key(|r| r.width);
    println!("{list:#?}");
}

Nếu cố tình sử dụng một closure có kiểu triển khai khác như FnMut thì chương trình không thể chạy được. Ví dụ chương trình dưới đây sẽ báo lỗi cannot move out of value, a captured variable in an FnMut closure.

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];

    let mut sort_operations = vec![];
    let value = String::from("closure called");

    list.sort_by_key(|r| {
        sort_operations.push(value);
        r.width
    });
    println!("{list:#?}");
}

Tổng kết

Closure trong Rust mặc dù tương tự về khái niệm với JavaScript nhưng lại phức tạp hơn rất nhiều. Nó cho phép nắm bắt giá trị từ phạm vi bên ngoài thông qua ba cách: mượn bất biến, mượn có thể thay đổi và chiếm quyền sở hữu, tùy thuộc vào cách sử dụng trong thân closure. Điều này được kiểm soát thông qua ba trait chính là Fn, FnMut, và FnOnce, mỗi loại phù hợp với các tình huống khác nhau. Điểm khác biệt này không chỉ giúp closure trong Rust linh hoạt hơn mà còn đảm bảo an toàn bộ nhớ và quản lý quyền sở hữu chặt chẽ, một yếu tố cốt lõi trong thiết kế của Rust.