Nhóm cộng đồng Rust Việt Nam
FB: https://www.facebook.com/groups/546307380433651
Telegram: https://t.me/rust_vn
Nếu có bất gì ý kiến hoặc đóng góp xin gửi đến thùng thư:
Tuan Phung [email protected]
Rất mong nhận được sự đóng góp của cộng đồng để mọi ngôn ngữ Rust trở nên phổ cập hơn và là nguồn tài liệu bổ ích cho những người đã và sẽ yêu thích ngôn ngữ này.
Ngôn ngữ lập trình Rust
Steve Klabnik và Carol Nichols, cùng với sự đóng góp của cộng đồng Rust
Phiên bản của tài liệu sử dụng với Rust 1.59 (ngày ra mắt 2022-02-24) trở lên. Xem phần “Installation” của Chương 1 để cài đặt hoặc cập nhật Rust.
Tài liệu định dạng HTML trực tuyến có sẵn tại
https://doc.rust-lang.org/stable/book/
và ngoại tuyến với các bản cài đặt của Rust được thực hiện bởi rustup
; chạy câu lệnh rustup docs --book
để mở.
Những bản dịch với một số ngôn ngữ có sẵn.
Tài liệu này có sẵn ở paperback and ebook format from No Starch Press.
Lời tựa
Rust không phải là ngôn ngữ quá tường minh và dễ học đối với người mới, nhưng về cơ bản nó sẽ trao quyền - tạo cảm giác làm chủ ngôn ngữ cho người sử dụng: bất kể bạn đang lập trình ngôn ngữ nào hiện tại, Rust sẽ cho phép bạn vươn xa hơn, tự tin lập trình trong nhiều lĩnh vực rộng hơn so với những gì bạn làm trước đây.
Lấy ví dụ đối với lập trình hệ thống, làm việc với ngôn ngữ lập trình bậc thấp trong việc quản lý bộ nhớ, biểu diễn dữ liệu, lập trình song song và đồng thời. Theo truyền thống, lĩnh vực lập trình này được coi là phức tạp, chỉ một số ít người với trình độ chuyên môn cao cùng với đó là sự tận tâm dành nhiều năm nghiên cứu mới tránh được những rủi ro nguy hiểm mà nó đem lại. Và ngay cả với những người học, tiếp cận với nó cũng phải làm việc hết sức thận trọng nếu không mã nguồn của họ có thể dễ dàng bị khai thác, làm hỏng hóc hay phá hủy hệ thống.
Rust phá vỡ những rào cản này bằng việc loại bỏ những rủi ro cũ và cung cấp một bộ công cụ thân thiện, được cải thiện hàng giờ để giúp bạn trong suốt quá trình sử dụng. Các lập trình viên cần đi sâu vào kiểm soát hệ thống cũng có thể làm đối với Rust mà không phải chịu những rủi ro thông thường về sự cố hỏng chương trình, lỗ hổng bảo mật, ... Hơn thế nữa, Rust được thiết kế để hướng dẫn bạn một cách tự nhiên, hiệu quả với mã nguồn đáng tin cậy, hiệu quả về tốc độ và sử dụng bộ nhớ.
Những lập trình viên đã và đang làm việc thuần thục với ngôn ngữ lập trình cấp thấp có thể sử dụng Rust để nâng cao hiệu quả làm việc của họ. Ví dụ đối với lập trình song song (parallelism) trong Rust là công việc rủi ro tương đối thấp: trình biên dịch sẽ bắt các lỗi cổ điển cho bạn. Do đó bạn có thể tối ưu hóa mã nguồn của mình và tự tin rằng sẽ không vô tình tạo ra những sự cố hay lỗ hổng bảo mật mới.
Nhưng Rust không giới hạn trong việc lập trình hệ thống ở mức thấp. Nó đủ đủ khả năng và sự tiện dụng để viết các ứng dụng CLI, máy chủ web và nhiều loại mã thông dụng khác - bạn sẽ tìm thấy trong các ví dụ trong phần sau của cuốn sách. Làm việc với Rust cho phép bạn xây dựng các kỹ năng chuyển đổi giữa các nền tảng; bạn có thể học Rust bằng cách viết một ứng dụng web, sau đó áp dụng các kỹ năng tương tự đó để phát triển tiếp các mục tiêu của bạn.
Cuốn sách này khai thác toàn bộ tiềm năng của Rust để trao quyền kiểm soát và sử dụng cho người dùng. Đây là một tài liệu thân thiện và dễ hiểu, dễ học nhằm giúp bạn nâng cao không chỉ kiến thức về Rust mà còn là về khả năng tiếp cận và sự tự tin của bạn với tư cách là là một lập trình viên nói chung. Vì vậy, hãy tham gia, sẵn sàng học hỏi - và chào mừng bạn đến với cộng đồng Rust!
— Nicholas Matsakis và Aaron Turon
Giới thiệu
Note: This edition of the book is the same as The Rust Programming Language available in print and ebook format from No Starch Press.
Chào mừng bạn đến với The Rust Programming Language, một cuốn sách giới thiệu về Rust. Ngôn ngữ lập trình Rust giúp bạn viết phần mềm nhanh hơn, đáng tin cậy hơn. High-level ergonomics(Thiết kế tối ưu mức cao) and low-level control(Điều khiển mức thấp) thường mâu thuẫn nhau trong thiết kế ngôn ngữ lập trình; Rust thách thức xung đột đó. Thông qua việc cân bằng giữa năng lực kỹ thuật mạnh mẽ và kinh nghiệm tuyệt vời của nhà phát triển, Rust cho bạn tùy chọn để kiểm soát các chi tiết cấp thấp (chẳng hạn như sử dụng bộ nhớ) mà không gặp phải mọi rắc rối truyền thống liên quan đến việc kiểm soát như vậy.
Rust dành cho đối tượng nào ?
Rust là phù hợp cho nhiều mục đích lập trình khác nhau và cho nhiều nhóm đối tượng Hãy xem xét một số nhóm đối tượng chính:
Nhóm các developer
Rust đang chứng tỏ là một công cụ hiệu quả để cộng tác giữa các nhóm developer lớn với các cấp độ khác nhau về kiến thức lập trình hệ thống. Code cấp thấp dễ mắc phải nhiều bugs tinh vi, mà ở hầu hết các ngôn ngữ khác chỉ có thể gặp phải thông qua thử nghiệm rộng rãi và xem xét code cẩn thận những developer có kinh nghiệm. Trong Rust, trình biên dịch đóng vai trò người gác cổng bằng cách từ chối biên dịch code với các bugs khó nắm bắt này, bao gồm các bug đồng thời. Bằng cách làm việc cùng với trình biên dịch, nhóm có thể dành thời gian tập trung vào logic của chương trình hơn là tìm kiếm các bug.
Rust cũng mang các công cụ dành cho nhà phát triển vào thế giới lập trình hệ thống:
- Cargo, công cụ bao gồm việc xây dựng và quản lý dependency, giúp việc thêm, biên dịch và quản lý các dependency trở nên dễ dàng và nhất quán trên toàn bộ hệ sinh thái Rust.
- Rustfmt đảm bảo coding style nhất quán giữa các developer.
- Máy chủ Ngôn ngữ Rust hỗ trợ tích hợp Môi trường Phát triển Tích hợp (Integrated Development Environment, IDE) cho việc hoàn thiện code và thông báo lỗi nội tuyến.
Bằng cách sử dụng những công cụ này và các công cụ khác trong hệ sinh thái Rust, các developer có thể làm việc hiệu quả trong khi viết code cấp hệ thống.
Sinh viên
Rust dành cho sinh viên, những người mà quan tâm tìm hiểu các khái niệm hệ thống. Sử dụng Rust, nhiều người đã học về các chủ đề như phát triển hệ điều hành. Cộng đồng rất hoan nghênh và sẵn lòng trả lời các câu hỏi của các bạn sinh viên. Thông qua những nỗ lực chẳng hạn như quyển sách này, nhóm Rust muốn làm cho các khái niệm hệ thống trở trên dễ tiếp cận hơn với nhiều người, đặc biệt nhất là những người mới lập trình.
Các công ty
Hàng trăm công ty, lớn và nhỏ, sử dụng Rust trong sản xuất cho nhiều nhiệm vụ khác nhau. Những tác vụ đó bao gồm công cụ dòng lệnh, dịch vụ web, DevOps tooling, thiết bị nhúng, phân tích và chuyển mã âm thanh và video, tiền điện tử, bioinformatics, công cụ tìm kiếm, các ứng dụng Internet of Things, machine learning, và thậm chí các phần chính của trình duyệt Firefox.
Các developer mã nguồn mở
Rust dành cho những người muốn xây dựng ngôn ngữ lập trình Rust, cộng đồng, công cụ nhà phát triển, và các thư viện. Chúng tôi muốn bạn đóng góp cho ngôn ngữ Rust.
Những người coi trọng tốc độ và sự ổn định
Rust dành cho những ai khao khát tốc độ và sự ổn định trong một ngôn ngữ. Với tốc độ, chúng tôi muốn nói đến tốc độ của chương trình mà bạn có thể tạo ra bằng Rust và tốc độ mà Rust cho phép bạn viết chúng. Các kiểm tra của trình biên dịch Rust đảm bảo tính ổn định thông qua việc bổ sung tính năng và tái cấu trúc. Điều này trái ngược với the brittle legacy code trong các ngôn ngữ không có các kiểm tra này, mà các developer thường e ngại sửa đổi. Bằng cách cố gắng tạo ra các tính năng cấp cao hơn, trừu tượng không tốn chi phí có thể biên dịch thành code cấp thấp hơn nhanh như code được viết thủ công, Rust cũng nỗ lực làm cho code an toàn trở thành code nhanh.
Ngôn ngữ Rust cũng hi vọng sẽ hỗ trợ nhiều người dùng khác; những người được đề cập ở đây chỉ là một số bên liên quan lớn nhất. Nhìn chung, tham vọng lớn nhất của Rust là loại bỏ những đánh đổi mà các lập trình viên đã chấp nhận trong hàng thập kỷ bằng cách cung cấp sự an toàn và năng suất, tốc độ và ergonomics. Hãy thử Rust và xem liệu các lựa chọn của nó có phù hợp với bạn không.
Cuốn sách này dành cho ai
Cuốn sách này giả định bạn đã viết code bằng một ngôn ngữ lập trình khác nhưng không đưa ra bất kỳ giả định nào về ngôn ngữ lập trình đó là ngôn ngữ nào. Chúng tôi đã cố gắng làm cho tài liệu có thể tiếp cận rộng rãi với những người từ nhiều nền tảng lập trình khác nhau. Chúng tôi không dành nhiều thời gian nói về lập trình là gì hoặc cảm nghĩ về nó. Nếu bạn là hoàn toàn mới về lập trình, bạn sẽ được phục vụ tốt hơn bằng cách đọc một quyển sách giới thiệu cụ thể về lập trình.
Làm thế nào để sử dụng cuốn sách này
Nói chung, cuốn sách này giả định bạn đang đọc nó theo thứ tự từ trước đến sau. Các chương sau xây dựng dựa trên các khái niệm trong các chương trước đó và các chương trước đó có thể không đi sâu vào chi tiết một chủ đề, chúng ta thường xem lại chủ đều trong chương sau.
Bạn sẽ tìm thấy hai loại chương trong quyển sách này: các chương về khái niệm và các chương dự án. Trong các chương khái niệm, bạn sẽ tìm hiểu về một khía cạnh của Rust. Trong các chương dự án, chúng ta sẽ xây dựng các chương trình nhỏ cùng nhau, áp dụng những gì bạn đã được học cho đến nay. Các chương 2, 12 và 20 là các chương về dự án; phần còn lại là các chương về khái niệm.
Chương 1 giải thích cách cài đặt Rust, cách viết chương trình “Hello, world!” và cách sử dụng Cargo, công cụ xây dựng và quản lý package của Rust. Chương 2 là phần giới thiệu thực tế về ngôn ngữ Rust. Ở đây chúng ta đề cập các khái niệm ở cấp độ cao và các chương sau sẽ cung cấp thêm chi tiết. Nếu bạn muốn bẩn tay ngay lập tức, Chương 2 chính là nơi dành cho điều đó. Lúc đầu, bạn thậm chí sẽ muốn bỏ qua Chương 3, bao gồm các tính năng Rust tương tự như các ngôn ngữ lập trình khác và đi thẳng tới Chương 4 để tìm hiểu về hệ thống quyền sở hữu (ownership) của Rust. Tuy nhiên, nếu bạn là một người học đặc biệt tỉ mỉ, thích tìm hiểu mọi chi tiết trước khi chuyển qua phần tiếp theo, bạn có thể bỏ qua Chương 2 và đi thẳng đến Chương 3, trở lại Chương 2 khi bạn muốn làm việc trên một dự án ứng dụng những chi tiết bạn đã được học.
Chương 5 thảo luận về structs và phương thức, và Chương 6 nói về enums, biểu thức match
,
và cấu trúc control flow if let
. Bạn sẽ sử dụng structs và enums để tạo ra các kiểu tùy
chọn trong Rust.
Trong Chương 7, bạn sẽ tìm hiểu về hệ thống module của Rust và về các nguyên tắc bảo mật để tổ chức code của bạn và Giao diện Lập trình Ứng dụng (Application Programming Interface, API) công khai của nó. Chương 8 thảo luận về một số cấu trúc dữ liệu collection phổ biến mà thư viện chuẩn cung cấp, như vectors, strings, và hash maps. Chương 9 khám phá triết lý và kỹ thuật xử lý error của Rust.
Chương 10 đào sâu vào generics, traits, và lifetimes, cung cấp cho bạn sức mạnh để định nghĩa
code ứng dụng cho nhiều loại dữ liệu. Chương 11 nói về testing, mà ngay cả với các đảm bảo an
toàn của Rust cần thiết để đảm bảo logic chương trình của bạn là chính xác. Trong Chương 12,
chúng ta sẽ xây dựng cách triển khai của riêng mình với một nhóm chức năng từ công cụ dòng lệnh
grep
tìm kiếm đoạn text trong file. Đối với điều này, chúng ta sẽ sử dụng các khái niệm mà
chúng ta đã thảo luận trong các chương trước.
Chương 13 khám phá về closures và iterators: các tính năng của Rust đến từ ngôn ngữ lập trình chức năng. Trong Chương 14, chúng ta sẽ xem xét Cargo sâu hơn và nói về các phương pháp hay nhất để chia sẻ thư viện của bạn với những người khác. Chương 15 thảo luận về smart pointers mà thư viện chuẩn cung cấp và traits để kích hoạt chức năng của chúng.
Trong Chương 16, chúng ta sẽ đi qua các mô hình lập trình đồng thời khác nhau và nói về cách Rust giúp bạn lập trình đa luồng một cách dễ dàng. Chương 17 xem xét cách Rust idioms so sánh với các nguyên tắc lập trình hướng đối tượng mà bạn có thể quen thuộc.
Chương 18 là tài liệu tham khảo về patterns và pattern matching, đây là các cách mạnh mẽ thể hiện ý tưởng trong suốt chương trình Rust. Chương 19 chứa một loạt các chủ đề nâng cao được quan tâm, bao gồm Rust không an toàn, macros, và nhiều hơn nữa về lifetimes, traits, types, functions và closures.
Trong Chương 20, chúng ta sẽ hoàn thành một dự án trong đó chúng ta sẽ triển khai một máy chủ web đa luồng cấp thấp!
Cuối cùng, một số phụ lục chứa thông tin hữu ích về ngôn ngữ trong một định dạng giống như tham khảo hơn. Phụ lục A bao gồm các từ khóa của Rust, Phụ lục B bao gồm các toán tử và ký hiệu của Rust, Phụ lục C bao gồm các derivable traits được cung cấp bởi thư viện chuẩn, Phụ lục D bao gồm một số công cụ phát triển hữu ích và Phụ lục E giải thích các phiên bản Rust.
Mọi phương pháp đọc cuốn sách này đều đúng: nếu bạn muốn bỏ qua chương nào đó, hãy làm điều đó. Bạn có thể phải quay lại các chương trước đó nếu bạn gặp bất kỳ sự khó hiểu nào. Nhưng hãy làm bất cứ điều gì có ích cho bạn.
Một phần quan trọng của quá trình học Rust là học cách đọc thông báo lỗi mà trình biên dịch hiển thị: chúng sẽ hướng dẫn bạn cách làm việc với code. Do đó, chúng tôi sẽ cung cấp nhiều ví dụ minh họa không biên dịch cùng với thông báo lỗi mà trình biên dịch sẽ hiển thị cho bạn trong mỗi tình huống. Biết rằng nếu bạn nhập và chạy một ví dụ ngẫu nhiên, nó có thể sẽ không biên dịch! Đảm bảo rằng bạn đọc đoạn text xung quanh để xem liệu ví dụ bạn đang cố chạy có bị lỗi hay không. Ferris cũng sẽ giúp bạn phân biệt code không hoạt động:
Ferris | Meaning |
---|---|
This code does not compile! | |
This code panics! | |
This code does not produce the desired behavior. |
Trong hầu hết các tình huống, chúng tôi sẽ dẫn bạn đến phiên bản chính xác của bất kỳ đoạn code nào không biên dịch được.
Source Code
Bạn có thể tìm thấy các file nguồn mà cuốn sách này được tạo nên trên GitHub.
[]
Thuật ngữ
Chương này không có trong Rust book. Mình tạo ra để mô tả các thuật ngữ để tiện tra cứu:
Bắt đầu
Bắt đầu hành trình vào thế giới của Rust Trong chương này chúng ta sẽ nói về:
- Cài đặt Rust trên Linux, macOs và Windows
- Viết chương trình
Hello world
bằng Rust - Sử dụng
cargo
- hệ thống build và quản lý thư viện của Rust
Cài đặt
Đầu tiên chúng ta phải cài Rust. Cách cài đặt đơn giản là sử dụng rustup
- Command line tool
quản lý phiên bản Rust và các công cụ liên quan.
Note: Nếu bạn không muốn dùng
rustup
, hãy truy cập Other Rust Installation Methods page để có xem các lựa chọn khác.
Các bước sau cài phiên bản ổn định mới nhất của trình biên dịch Rust (Rust compiler). Phiên bản ổn định của Rust đảm bảo các ví dụ trong sách có thể biên dịch với phiên bản Rust mới hơn. Tuy nhiên ouput có thể khác 1 chút giữa các phiên bản, bởi vì Rust thường xuyên cải thiện các message lỗi và cảnh báo.
Cài đặt rustup
trên Linux và macOS
Nếu bạn đang sử dụng Linux hay macOs, mở terminal và nhập lệnh sau
$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
Câu lệnh trên sẽ tải 1 đoạn script và bắt đầu cài đặt rustup
, nó cài đặt phiên bản ổn định và mới
nhất của Rust. Nếu cài đặt thành công, terminal sẽ hiển thị:
Rust is installed now. Great!
Bạn cũng sẽ cần một linker - một chương trình Rust dùng để ghi complied outputs vào 1 file. Nếu bạn gặp linker errors, bạn nên cài C compiler (đã bao gồm linker). Bên cạnh đó, một số Rust packages được viết bằng ngôn ngữ C và cần C compiler để biên dịch
Trên macOS, bạn có thể cài C compiler bằng lệnh sau:
$ xcode-select --install
Người dùng linux nên cài GCC hoặc Clang
Cài đặt rustup
trên Windows
Trên Windows, truy cập https://www.rust-lang.org/tools/install và làm theo hướng dẫn để cài Rust. Bạn cũng sẽ cần C++ build tools cho Visual Studio 2013 hoặc mới hơn. Cách dễ nhất là cài Build Tools for Visual Studio 2019. Hãy đảm bảo “C++ build tools” được chọn.
Cập nhật và gỡ cài đặt
Sau khi cài Rust bằng rustup
, bạn có thể cập nhật phiên bản mới nhất bằng lệnh:
$ rustup update
Để gỡ cài đặt Rust và rustup
, chạy dòng lệnh:
$ rustup self uninstall
Xử lý sự cố (Troubleshouting)
Để kiểm tra bạn đã cài đặt Rust đúng chưa:
$ rustc --version
Bạn sẽ thấy phiên bản, commit hash, và ngày commit cho phiên bản bạn đã cài đặt
rustc x.y.z (abcabcabc yyyy-mm-dd)
Nếu bạn thấy thông tin trên, bạn đã cài đặt Rust thành công! Nếu không thấy trên Window,
hãy kiểm tra Rust đã được thêm trong %PATH%
ở system variable hay chưa.
Nếu gặp lỗi hãy tham gia nhóm facebook Cộng đồng Rust Việt Nam. Mọi người sẽ nhiệt tình giúp đỡ
Hello, World!
Sau khi cài đặt Rust, hãy viết chương trình Rust đầu tiên hiển thị Hello, world!
Tạo một chương trình - Thư mục chương trình
Bạn sẽ bắt đầu bằng tạo một thư mục để lưu trữ Rust code. Bạn có thể lưu trữ nó ở bất kì đâu, tuy nhiên cho các bài tập trong sách này, bạn nên để đường dẫn ở thư mục home.
Mở terminal và nhập những lệnh sau để tạo thư mục projects và thư mục “Hello, world!” bên trong thư mục projects
Với Linux, macOS, và PowerShell trên Windows:
$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world
Với Windows CMD:
> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world
Viết và chạy một chương trình Rust
Tiếp theo, tạo một file tên main.rs. Rust file luôn kết thúc với đuôi .rs. Nếu có hai từ trong tên file, hãy thêm dấu gạch dưới để tách nó. Ví dụ, dùng hello_world.rs thay vì helloworld.rs.
Bây giờ mở file main.rs và nhập đoạn code ở Mục 1-1.
Filename: main.rs
fn main() { println!("Hello, world!"); }
Mục 1-1: Chương trình in ra Hello, world!
Lưu file và mở terminal. Trên Linux hoặc macOS, nhập lệnh sau để chạy file:
$ rustc main.rs
$ ./main
Hello, world!
Trên Windows, nhập lệnh .\main.exe
thay vì ./main
:
> rustc main.rs
> .\main.exe
Hello, world!
Dòng Hello, world!
sẽ được in ra ở terminal.
Nếu bạn không thấy hãy tham gia nhóm facebook Cộng đồng Rust Việt Nam để được mọi người giúp đỡ.
Phân tích một chương trình Rust
Hãy xem lại chi tiết chương trình “Hello, world!”. Đây là phần đầu tiên:
fn main() { }
Dòng code khai báo một hàm trong Rust. Hàm main
là hàm đặc biệt: nó luôn là đoạn code chạy đầu tiên trong tất cả
chương trình Rust. Dòng đầu khai báo một hàm tên main
, nó không có tham số truyền vào và không trả về giá trị.
Nếu có tham số truyền vào, hãy đặt nó trong ()
.
Thân hàm được viết trong cặp ngoặc {}
. Bạn nên đặt dấu mở ngoặc trên cùng dòng với tên hàm
và có dấu cách ở giữa
Nếu bạn muốn format code theo phong cách chuẩn, bạn có thể sử dụng tool format code rustfmt
.
Tool này đã được cài đặt cùng với rustc
.
Trong hàm main
có dòng code:
#![allow(unused)] fn main() { println!("Hello, world!"); }
Dòng này in ra một đoạn text trên màn hình. Có 4 điều cần lưu ý:
Thứ nhất, Rust style là thụt lề với bốn dấu cách, không phải là một tab
Thứ hai, println!
gọi một Rust macro. Nếu gọi một hàm sẽ là println
(không có !
).
Chúng ta sẽ bàn luận chi tiết về Rust macros trong Chương 19.
Bây giờ, bạn chỉ cần biết là sử dụng !
nghĩa là bạn đang gọi một macro thay vì một hàm thông thường.
Thứ ba, bạn thấy chuỗi kí tự "Hello, world!"
. Chúng ta sẽ truyền chuỗi này như một tham số vào macro println!
,
và đoạn kí tự sẽ được in ra màn hình.
Thứ tư, chúng ta kết thúc dòng với dấu chấm phẩy (;
), nó chỉ ra một expression kết thúc. Hầu hết các dòng code Rust
đều kết thúc với dấu chấm phẩy
Biên dịch và Chạy chương trình là hai bước riêng
Bạn vừa mới chạy một chương trình vừa tạo, hãy xem từng bước
Trước khi chạy một chương trình Rust, bạn phải biên dịch bằng Rust compiler với lệnh rustc
. Ví dụ:
$ rustc main.rs
Sau khi biên dịch thành công, Rust sinh ra một file binary có thể thực thi
Trên Linux, macOS, và PowerShell trên Windows, bạn có thể thấy file bằng lệnh ls
.
Trên Linux và macOS, bạn sẽ thấy 2 file:
$ ls
main main.rs
Trên Windows bạn sẽ thấy 3 files:
> dir
main.exe
main.pdb
main.rs
Nó bao gồm file source với đuôi .rs, file thực thi(main.exe trên Windows, main trên Linux và MacOS). Và khi sử dụng Windows, có thêm một file bao gồm thông tin debug với đuôi .pdb. Bạn chạy file main hoặc main.exe:
$ ./main # hoặc .\main.exe trên Windows
Nếu main.rs là chương trình “Hello, world!”, terminal sẽ in ra Hello, world!
Rust là ngôn ngữ biên dịch trước, bạn có thể biên dịch 1 chương trình và đưa file thực thi cho người khác, và họ có thể chạy nó mà không cần cài đặt Rust. Nếu bạn đưa người khác một file .rb, .py, hoặc .js họ cần cài Ruby, Python, JavaScript để chạy nó. Đánh đổi lại, các ngôn ngữ đó biên dịch và chạy chỉ với 1 câu lệnh.
Biên dịch với rustc
chỉ dành cho chương trình đơn giản. Khi project phát triển, sẽ rất phức tạp khi quản lý các options.
Công cụ quản lý package - Cargo sẽ giúp ta việc đó.
Hello, Cargo!
Cargo là hệ thống build và quản lý thư viện của Rust. Hầu hết Rust coder - Rustaceans đều sử dụng Cargo để quản lý project của họ bởi vì Cargo xử lý nhiều tác vụ cho bạn ví dụ như: build code, tải thư viện, và build những thư viện đó. (Chúng ta gọi những thư viện mà code của bạn cần là những dependency)
Những chương trình Rust đơn giản nhất, như ví dụ bạn vừa viết chẳng hạn, không có dependency nào. Nên nếu chúng ta build chương trình “Hello, world!” với Cargo, Cargo sẽ chỉ giúp chúng ta build code. Khi bạn viết những chương trình phức tạp hơn, bạn sẽ cần thêm các dependency. Và nếu bạn bắt đầu chương trình với Cargo, việc thêm các dependency sẽ cực kì dễ dàng.
Bởi vì phần lớn các dự án Rust sử dụng Cargo, phần còn lại của cuốn sách này giả định rằng bạn cũng đang sử dụng Cargo. Cargo được cài đặt cùng với Rust nếu bạn sử dụng bộ cài chính thức đã được nêu ở phần “Cài đặt”. Nếu bạn đã cài Rust theo những cách khác, hãy kiểm tra xem Cargo đã được cài đặt hay chưa bằng cách nhập câu lệnh sau trong terminal:
$ cargo --version
Nếu bạn nhìn thấy số phiên bản, tức là bạn đã cài Cargo! Nếu bạn nhìn thấy lỗi như command not found
thì
phiên bản Rust bạn đã cài đặt không bao gồm Cargo.
Tạo một project với Cargo
Chúng ta hãy tạo một project mới bằng Cargo và xem nó khác như thế nào so với project “Hello, world!” trước. Vào thư mục projects của bạn (bất cứ thư mục nào mà bạn muốn lưu trữ code). Sau đó chạy những lệnh sau:
$ cargo new hello_cargo
$ cd hello_cargo
Câu lệnh đầu tiên tạo một thư mục mới là hello_cargo. Chúng ta đã đặt tên project của chúng ta là hello_cargo, và Cargo sẽ tạo những file mặc định trong thư mục trên.
Vào thư mục hello_cargo và xem các file được tạo. Bạn sẽ thấy Cargo tạo ra hai file và một thư mục: file Cargo.toml và thư mục src có file main.rs bên trong.
Cargo cũng tạo một Git repository cùng với file .gitignore. Nếu bạn chạy cargo new
trong một thư mục đã có Git repository
nó sẽ không tạo Git repository mới. Nếu bạn vẫn muốn tạo Git repository mới hãy dùng cargo new --vcs=git
.
Note: Git là hệ thống quản lý phiên bản phổ biến. Bạn có thể dùng hệ thống quản lý phiên bản khác với cờ
--vcs
. Sử dụngcargo new --help
để xem những options có thể chọn.
Mở file Cargo.toml. Nó sẽ giống với code ở Listing 1-2.
Filename: Cargo.toml
[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"
[dependencies]
Listing 1-2: Nội dung file Cargo.toml được tạo bởi cargo new
File này được viết theo chuẩn TOML (Tom’s Obvious, Minimal Language), theo định dạng cấu hình của Cargo
Dòng đầu tiên, [package]
, là tiêu đề của một đoạn thể hiện rằng những khai báo sau đó đang cấu hình một package.
Chúng ta sẽ thêm nhiều thông tin khác cũng như các đoạn khác vào file này.
Ba dòng tiếp theo đặt thông tin cấu hình Cargo cần để biên dịch chương trình: tên, phiên bản, và phiên bản(edition
) Rust cần dùng
Chúng ta sẽ nói về edition
trong phần Appendix E.
Dòng cuối, [dependencies]
, là bắt đầu của một đoạn liệt kê các dependency của project.
Trong Rust, các package được coi như các crate. Chúng ta không cần bất kỳ crate nào cho project này,
nhưng chúng ta sẽ cần trong project đầu tiên ở Chương 2, nên chúng ta sẽ sử dùng đoạn khai báo dependencies này sau.
Giờ mở file src/main.rs và xem thử:
Filename: src/main.rs
fn main() { println!("Hello, world!"); }
Cargo đã tạo ra một chương trình “Hello, world!” cho bạn, giống như cái chúng ta đã viết trong Listing 1-1! Cho đến giờ, điểm khác biệt giữa project trước và project Cargo tạo ra là Cargo đặt code bên trong thư mục src, và chúng ta có một file cấu hình Cargo.toml ở thư mục ngoài cùng.
Cargo yêu cầu những file mã nguồn của bạn nằm trong thư mục src. Thư mục ngoài cùng của project chỉ để file README, thông tin bản quyền, các file cấu hình, và những thứ không liên quan tới code. Việc sử dụng Cargo giúp bạn tổ chức project khoa học hơn.
Nếu bạn đã tạo một project mà không sử dụng Cargo, như project “Hello, world!”, bạn có thể chuyển nó thành một project sử dụng Cargo. Chuyển code vào trong thư mục src và tạo một file Cargo.toml phù hợp.
Build và chạy một Cargo Project
Giờ hãy nhìn vào sự khác biệt khi bạn build và chạy chương trình “Hello, world!” với Cargo! Từ thư mục hello_cargo của bạn, build project bằng lệnh sau:
$ cargo build
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs
Câu lệnh trên tạo một file thực thi trong target/debug/hello_cargo (hoặc target\debug\hello_cargo.exe trên Windows) thay vì thư mục hiện tại của bạn. Bạn có thể chạy file thực thi với lệnh sau:
$ ./target/debug/hello_cargo # hoặc .\target\debug\hello_cargo.exe trên Windows
Hello, world!
Nếu mọi việc thực hiện đúng, Hello, world!
sẽ được in ra terminal.
Việc chạy cargo build
lần đầu tiên cũng làm Cargo tạo ra một file mới ở thư mục ngoài: Cargo.lock.
File này chứa thông tin phiên bản của các dependency trong project của bạn.
Project này không có dependency nên file này hầu như không có thông tin gì cả.
Bạn không cần phải sửa đổi gì ở file này; Cargo sẽ quản lý nội dung của nó cho bạn.
Chúng ta vừa mới build một project với cargo build
và chạy nó với ./target/debug/hello_cargo
,
nhưng chúng ta cũng có thể sử dụng cargo run
để biên dịch và chạy trong một lệnh.
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/hello_cargo`
Hello, world!
Lưu ý rằng lần này chúng ta không nhìn thấy output chỉ ra rằng Cargo đang biên dịch hello_cargo
.
Cargo thấy rằng các file không thay đổi nên nó chỉ thực thi file nhị phân.
Nếu bạn đã sửa source code, Cargo sẽ build lại project trước khi chạy nó và bạn sẽ nhìn thấy output này:
$ cargo run
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
Running `target/debug/hello_cargo`
Hello, world!
Cargo cung cấp một câu lệnh gọi là cargo check
. Câu lệnh này nhanh chóng kiểm tra code của bạn để chắc chắn rằng nó biên dịch được nhưng không tạo ra file thực thi:
$ cargo check
Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs
Sao bạn lại không muốn file thực thi? Thông thường, cargo check
nhanh hơn rất nhiều so với cargo build
,
bởi vì nó bỏ qua bước tạo file thực thi. Nếu bạn liên tục kiểm tra code của bạn trong khi viết, sử dụng cargo check
sẽ tăng tốc quá trình làm việc!
Như vậy, nhiều Rustacean chạy cargo check
thường xuyên khi họ viết chương trình để đảm bảo nó biên dịch được.
Sau đó họ chạy cargo build khi họ sẵn sàng sử dụng file thực thi.
Hãy cùng điểm những gì chúng ta đã học được về Cargo cho đến lúc này:
- Chúng ta có thể tạo project với
cargo new
. - Chúng ta có thể build một project với
cargo build
. - Chúng ta có thể build và chạy một project trong một bước bằng
cargo run
. - Chúng ta có thể build project mà không sinh ra file thực thi để kiểm tra lỗi compile bằng
cargo check
. - Thay vì lưu kết quả build trong cùng thư mục với code, Cargo lưu nó trong thư mục target/debug.
Một ưu điểm nữa của Cargo là các câu lệnh của nó giống nhau trên các hệ điều hành. Nên từ bây giờ chúng ta sẽ không đưa ra những chỉ dẫn riêng cho Linux và macOS với Windows nữa.
Build bản phát hành
Khi project của bạn sẵn sàng để phát hành, bạn có thể sử dụng cargo build --release
để biên dịch nó một các tối ưu.
Câu lệnh này sẽ tạo một file thực thi trong target/release thay vì target/debug.
Cách này làm code của bạn chạy nhanh hơn, nhưng sẽ biên dịch lâu hơn.
Đây là lý do vì sao có hai cấu hình khác nhau: một cho việc phát triển, khi mà bạn muốn build lại nhanh chóng và thường xuyên,
và một cái khác cho việc build ra chương trình cuối cùng, thứ mà bạn sẽ đưa cho người dùng,
nó sẽ không cần build lại nhiều lần và sẽ chạy nhanh nhất có thể. Nếu bạn đang benchmark thời gian chạy của code,
hãy chắc chắn rằng chạy cargo build --release
và benchmark với file thực thi trong target/release.
Cargo as Convention
Với những project đơn giản, Cargo không có giá trị nhiều so với sử dụng rustc
, nhưng nó sẽ chứng minh giá
trị của nó khi chương trình của bạn phức tạp hơn. Với những project phức tạp bao gồm nhiều crate, dùng cargo sẽ
thuận tiện hơn rất nhiều.
Mặc dù project hello_cargo
rất đơn giản, nhưng nó đã sử dụng những công cụ mà bạn sẽ sử dụng sau
này trong công việc của bạn. Thực tế, để tham gia vào project Rust, bạn có thể sử dụng những lệnh sau để clone
code từ git và build nó
$ git clone example.org/someproject
$ cd someproject
$ cargo build
Xem thêm tài liệu Cargo để biết nhiều thông tin hơn.
Tổng kết
Bạn đã có một khởi đầu rất tuyệt trong hành trình đến với Rust! Trong chương này, bạn đã học được cách:
- Cài đặt phiên bản ổn định mới nhất của Rust bằng cách sử dụng
rustup
- Viết và chạy một chương trình “Hello, world!” với
rustc
- Tạo và chạy một project mới bằng Cargo
Đây là thời điểm rất tốt để build một chương trình lớn hơn để làm quen với việc đọc và viết code Rust. Vì thế, trong chương 2, chúng ta sẽ build một chương trình trò chơi đoán số. Nếu bạn muốn bắt đầu học về các khái niệm lập trình phổ biến trong Rust, bạn có thể đọc Chương 3 và quay lại Chương 2 sau.
Lập trình Trò chơi đoán số
Bây giờ, hãy nhảy vào Rust bằng cách bắt tay vào làm một dự án cùng nhau! Chương này sẽ giới thiệu một vài ý tưởng Rust thông thường, Bạn sẽ học về let
, match
, các phương thức, các hàm liên quan, sử dụng các external crates, và còn nhiều hơn nữa! Trong chương tiếp theo, chúng ta sẽ khám phá những ý tưởng này chi tiết hơn. Trong chương này, bạn sẽ luyện tập được những nguyên tắc cơ bản.
Chúng ta sẽ triển khai một vài vấn đề lập trình cơ bản dành cho người mới: một trò chơi đoán số. Đây là cách nó thực hiện: Chương trình này sẽ khởi tạo một số nguyên ngẫu nhiên trong khoảng 1 đến 100. Nó sẽ yêu cầu người chơi phải đoán. Sau khi người chơi nhập số, chương trình sẽ hiển thị rằng: dự đoán của người chơi quá thấp hoặc quá cao. Nếu dự đoán chính xác, chương trình sẽ in ra thông báo chúc mừng và thoát ra.
Cấu hình một dự án mới
Để cấu hình một dự án mới, đến thư mục project, nơi mà được bạn tạo ra trong chương 1 và tạo mới một dự án mới sử dụng Cargo, ví dụ như sau:
$ cargo new guessing_game
$ cd guessing_game
Câu lệnh đầu tiên, cargo new
, đặt tên cho dự án này, (guessing_game
) là thông số đầu tiên. Câu lệnh tiếp theo để thay đổi thư mục, đưa bạn tới thư mục của dự án.
Nhìn vào file Cargo.toml đã được khởi tạo trước đó.
Filename: Cargo.toml
[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
Như bạn đã thấy trong Chương 1, cargo new
khởi tạo chương trình "Hello, world!" cho bạn. Kiểm tra file src/main.rs:
Filename: src/main.rs
fn main() { println!("Hello, world!"); }
Bây giờ, hãy cùng biên dịch chương trình "Hello, world!" và chạy nó, sử dụng câu lệnh cargo run
:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
Running `target/debug/guessing_game`
Hello, world!
Câu lệnh run
sẽ có ích khi bạn cần lặp lại nhanh chóng trong một dự án, cũng như cách mà chúng ra thực hiện trong trò chơi này, nhanh chóng kiểm tra từng lần lặp lại trước khi chuyển tới bước tiếp theo.
Mở lại file src/main.rs. Bạn sẽ phải viết lại tất cả code trong file này.
Tiến hành dự đoán
Phần đầu tiên của trò chơi dự đoán này là sẽ hỏi người chơi nhập đầu vào, xử lý đầu vào đó, và kiểm tra đầu vào đó có trong định dạng được kì vọng hay không. Để bắt đầu, chúng ta sẽ cho người chơi nhập vào một đầu vào dự đoán. Nhập đoạn code trong Listing 2-1 vào trong file src/main.rs.
Filename: src/main.rs
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Listing 2-1: Đoạn mã nhận dự đoán của người dùng và in nó ra
Đoạn code này hàm chứa rất nhiều thông tin, vì vậy hãy cùng nhau giải thích nó từng dòng một. Để lựa chọn đầu vào của người dùng và in kết quả đầu ra, ta cần mang thư viện io
input/output vào trong phạm vi này. Thư viện io
từ thư viện tiêu chuẩn, được viết tới là std
:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Trong mặc định, Rust có một tập các items định nghĩa các thư viện tiêu chuẩn được mang vào trong phạm vi của mỗi dự án. Tập này được gọi là prelude, và bạn có thể nhìn thấy tất cả chúng trong tài liệu về thư viện tiêu chuẩn.
Nếu kiểu thư viện bạn muốn không ở trong phần dạo đầu, bạn cần mang nó vào trong một phạm vi rõ ràng với statement use
. Sử dụng thư viện std::id
cung cấp cho bạn một vài tính năng hữu dụng, bao gồm khả năng chấp nhận đầu vào của người dùng.
Như bạn từng thấy trong Chương 1, hàm main
sẽ là điểm vào trong chương trình.
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Cú pháp fn
khai báo hàm mới, dấu ngoặc đơn, ()
, biểu thị rằng nó không có tham số, và dấu ngoặc nhọn, {
bắt đầu phần thân của một hàm.
Như bạn đã từng học trong Chương 1, println!
cũng là một macro in ra chuỗi ngoài màn hình.
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Đoạn code này in ra một lời nhắc đây là trò chơi gì và yêu cầu nhập đầu vào từ người dùng.
Lưu giữ giá trị với biến.
Tiếp theo, chúng ta sẽ tạo một biến để lưu trữ giá trị từ đầu vào của người dùng, như sau:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Bây giờ chương trình đang dần thú vị hơn! Có rất nhiều điều xảy ra trong dòng này. Chúng ta sẽ sử dụng câu lệnh let
để tạo giá trị. Sau đây là một ví dụ:
let apples = 5;
Dòng code này tạo mới một biến được đặt tên là apples
và gắn nó với giá trị là 5. Trong Rust, các biến đều mắc định là bất biến, nghĩa là một khi chúng được đưa một giá trị nhất định, giá trị này sẽ không thay đổi. Chúng ta sẽ bàn đến ý tưởng này chi tiết hơn trong phần "Các biến và tính bất biến" ở chương 3. Để làm cho một biến có thể biến đổi được, ta thêm mut
trước tên biến:
let apples = 5; // immutable
let mut bananas = 5; // mutable
Ghi chú: Cú pháp
\\
bắt đầu một bình luận kéo dài đến cuối dòng. Rust sẽ bỏ qua tất cả ở trong phần bình luận này. Chúng ta sẽ bàn đến phần bình luận này chi tiết hơn ở trong Chương 3.
Trở về chương trình trò chơi đoán số, bạn biết rằng let mut guess
sẽ giới thiệu biến khả biến được đặt tên là guess
. Dấu bằng (=
) nói với Rust rằng chúng ta muốn gắn gì đó vào biến. Bên phải của dấu bằng là giá trị mà guess
được gắn vào, thứ là kết quả của việc gọi String::new
, một hàm trả về một instance của String
. String
là kiểu dữ liệu được cung cấp bởi thư viện tiêu chuẩn, nó có thể phát triển được, UTF-8 encoded bit hoặc text.
Cú pháp ::
trong dòng ::new
chỉ ra rằng new
có liên quá đến hàm của kiểu dữ liệu String
. Một hàm liên quan là một hàm được triển khai thực hiện trên một kiểu, trong trường hợp này là String
. Hàm new
này tạo ra một chuỗi mới và trống. Bạn sẽ tìm được hàm new
trong nhiều kiểu dữ liệu, bởi vì nó là cái tên phổ biến cho hàm tạo ra giá trị mới, hoặc đại loại vậy.
Về cụ thể, dòng let mut guess = String::new()
đã tạo ra một biến khả biến, nó được gắn liền với một chuỗi mới, trống và là instance của String
. Phù!
Nhận dữ liệu đầu vào từ người dùng.
Quay lại với việc chúng ta đã bao gồm chức năng đầu vào/đầu ra từ một thư viện tiêu chuẩn với use std::io;
trong dòng đầu tiên của chương trình. Bây giờ chúng ta sẽ gọi hàm stdin
từ module io
, thứ mà cho phép chúng ta xử lý đầu vào được nhập từ người dùng:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Nếu chúng ta chưa bổ sung thư viện io
với use std::io
ở phần đầu của chương trình, chúng ta vẫn có thể sử dụng hàm bằng cách viết hàm gọi, ví dụ std::io::stdin
. Hàm stdin
trả về instance của std::io::Stdin
, thứ mà đại diện xử lý đầu vào tiêu chuẩn cho terminal của bạn.
Tiếp theo, dòng .read_line(&mut guess)
gọi đến phương thức read_line
trên chuẩn xử lý đầu vào để lấy đầu vào được nhập từ người dùng. Chúng ta cũng đi qua &mut gues
như là một tham số để read_line
để chỉ ra rằng chuỗi nào lưu trữ đầu vào của người dùng. Công việc đầy đủ của read_line
là nhận lấy bất kỳ kiểu dữ liệu tiêu chuẩn nào của người dùng và nối chúng thành một chuỗi (mà không hề ghi đè nội dung), vì vậy trước khi bỏ qua chuỗi đó như là một tham số. Chuỗi tham số này cần để trở nên khả biến vì vậy phương thức có thể thay đổi nội dung chuỗi.
Ký hiệu &
chỉ ra rằng tham số này là một tham chiếu, thứ mà chỉ ra cho bạn cách để nhiều đoạn code của bạn cùng truy cập vào một dùng dữ liệu mà không cần sao chiếu dữ liệu đó vào bộ nhớ nhiều lần. Tham chiếu là một tính năng phức tạo, nhưng và nó là một trong những điểm điểm mạnh của Rust, vô cùng an toàn và dễ dàng để sử dụng tham chiếu trong Rust. Bạn không cần phải biết quá nhiều chi tiết để hoàn thiện chương trình. Bây giờ, tất cả những gì bạn cần phải biết là nó giống với biến, tham chiếu là bất biến trong mặc định. Vì vậy, bạn cần phải ghi &mut guess
thay vì &guess
để làm nó khả biến. (Chương 4 sẽ giải thích tham chiếu rõ ràng hơn)
Chúng ta vẫn sẽ làm việc trong dòng code này. Giờ đây, ta bàn tiếp về dòng code thứ 3 trong đoạn đó, nhưng ghi chú rằng nó vẫn là một phần của dòng code logic. Phần tiếp theo là phương thức này:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Chúng ta có thể ghi dòng code như sau:
io::stdin().read_line(&mut guess).expect("Failed to read line");
Mặc dù vậy, một dòng quá dài thì vô cùng khó để đọc, vì vậy cách tốt nhất là chia nó ra. Thông thường, sẽ khôn ngoan hơn nếu khai báo một dòng code và một khoảng trắng để giúp chia một dòng dài khi bạn gọi một phương thức với cú pháp .method_name()
. Bây giờ chúng ta sẽ thảo luận dòng code này làm gì.
Như đã đề cập trước đó, read_line
đưa vào bất kỳ dữ liệu đầu vào nào được người dùng nhập vào, nhưng cũng đồng thời trả về giá trị Result
. Result
là một enumeration, thường xuyên gọi là enum thứ mà kiểu dữ liệu có thể ở một trong nhiều trạng thái có thể. Chúng ta gọi từng trạng thái đó là các biến thể.
Chương 6 sẽ bao hàm enums chi tiết hơn. Mục đích của những kiểu dữ liệu Result
là để mã hóa thông tin xử lý lỗi.
Các biến thể của Result
là Ok
và Err
. Biến thể Ok
chỉ ra rằng toán tử đã thành công và bên trong Ok
là một giá trị được khởi tạo thành công. Biến thể Err
có nghĩa rằng toán tử đã thất bại, và Err
bao gồm những thông tin về việc tại sao hay bằng cách nào mà toán tử lại thất bại.
Giá trị của kiểu dữ liệu Result
giống như nhiều giá trị và kiểu khác, là đều có những phương thức định nghĩa trên chúng. Một instance của Result
có expect
method mà bạn có thể gọi. Nếu instance này của Result
là một giá trị Err
, expect
sẽ là nguyên nhân tại sao chương trình crash và hiển thị tin nhắn đó, được bạn bỏ qua như là một tham số của expect
. Nếu phương thức read_line
được trả về như Err
, nó sẽ giống như kết quả của một lỗi đến từ hệ điều hành của bạn. Nếu như instance của Result
này là một giá trị Ok
, expect
sẽ nhận giá trị trả về khi Ok
đang nắm giữ giá trị và trả về đúng giá trị đó cho bạn để sử dụng. Trong trường hợp này giá trị đó là số của những byte trong đầu vào người dùng.
Nếu bạn không gọi expect
, chương trình vẫn sẽ biên dịch nhưng bạn sẽ nhận được cảnh báo:
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
warning: unused `Result` that must be used
--> src/main.rs:10:5
|
10 | io::stdin().read_line(&mut guess);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: this `Result` may be an `Err` variant, which should be handled
warning: `guessing_game` (bin "guessing_game") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 0.59s
Rust sẽ cảnh báo bạn vì bạn chưa sử dụng giá trị trả về Result
từ read_line
, nó chỉ ra tằng chương trình chưa được xử lý những lỗi có thể xảy ra.
Cách phù hợp để giảm cảnh báo thực ra là viết phần xử lý lỗi, nhưng trong trường hợp này chúng ta chỉ muốn crash chương trình khi vấn đề xuất hiện, vì vậy chúng ta sử dùng expect
. Bạn sẽ học được cách xử lý lỗi trong Chương 9.
In ra giá trị với trình giữ chỗ println!
Bên cạnh dấu ngoặc nhọn, chỉ còn duy nhất một dòng để bàn về đoạn code đến bây giờ:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Dòng này in ra một chuỗi chứa đầu vào được nhập bởi người dùng. Dấu {}
là một tập các dấu ngoặc nhọn là một trình giữ chỗ: Hãy liên tưởng {}
giống như một chiếc càng cua nhỏ giữ một giá trị đúng chỗ. Bạn có thể in nhiều hơn một giá trị nếu dử dụng dấu ngoặc nhọn: dấu ngoặc nhọn đầu tiên của các dấu ngoặc nhọn giữ giá trị đầu tiên được liệt kê dưới định dạng chuỗi, và cứ thế tiếp tục. In ra nhiều giá trị trong một lần gọi println!
sẽ trông như sau:
#![allow(unused)] fn main() { let x = 5; let y = 10; println!("x = {} and y = {}", x, y); }
Dòng code này sẽ in ra: x = 5 and y = 10
.
Kiểm thử phần đầu tiên
Hãy cùng nhau kiểm thử phần đầu tiên của trò chơi đoán số. Khởi chạy chương trình sử dụng cargo run
:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 6.44s
Running `target/debug/guessing_game`
Guess the number!
Please input your guess.
6
You guessed: 6
Tính đến thời điểm này, phần đầu tiên của trò chơi đã hoàn tất: chúng ta đã nhận đầu vào được nhập bởi bàn phím người dùng và in ra nó.
Khởi tạo ra một số bí mật
Tiếp theo, chúng ta cần tạo ra một số bí mật để người dùng đoán. Số bí mật sẽ thay đổi sau mỗi lần để trò chơi thêm phần thú vị. Chúng ta sẽ sử dụng một số bí mật nằm giữa 1 và 100 để trò chơi không trở nên quá khó. Rust chưa bao gồm một hàm khởi tạo ngẫu nhiên số bí mật. Nhưng đội ngũ Rust đã cung cấp một thư viện rand
crate như chúng ta đã nói.
Sử dụng Crate để lấy thêm chức năng
Hãy nhớ rằng crate là một tập các file source code Rust. Một dự án mà chúng tôi đã từng xây dựng là một binary crate, thứ mà có thể thực thi. Crate rand
là một thư viện crate, thứ mà bao gồm đoạn mã được dự định sẽ sử dụng trong chương trình khác và không thể tử thực thi bởi chính nó.
Sự phối hợp của Cargo trong những crate ngoại cảnh là điểm sáng của Cargo. Trước khi chúng ta có thể viết những đoạn code sử dụng rand
, chúng ta cần chỉnh sửa file Cargo.toml để bao gồm rand
như một dependency. Mở file đó và thêm vào những dòng sau ở bên dưới cùng chỗ [dependencies]
trong mục header mà Cargo đã tạo cho bạn.
Filename: Cargo.toml
rand = "0.8.3"
Trong file Cargo.toml, tất cả đều theo phần đầu, đó là mục tiếp theo cho đến khi mục khác bắt đầu. Trong [dependencíe]
bạn chỉ ra với Cargo rằng những crates ngoại vi nào phụ thuộc trong dự án của bạn và phiên bản nào của những crate này mà bạn yêu cầu. Trong trường hợp này, chúng ta xác định rằng crate rand
về mặt ngữ nghĩa được xác định là phiên bản 0.8.3
. Cargo hiểu Semantic Versioning (thi thoảng được gọi là SemVer), là tiêu chuẩn cho viết phiên bản số bao nhiêu. Số 0.8.3
thực ra là tốc ký cho ^0.8.3
. Điều này có ý nghĩa rằng phiên bản tối thiểu là 0.8.3
nhưng dưới 0.9.0
.
Cargo cho rằng những phiên bản này phải có những APIs công khai, tương thích với phiên bản 0.8.3
và sự chỉ rõ này đảm bảo rằng bạn sẽ nhận bản vá mới nhất được công bố, thứ mà vẫn có thể biên dịch với đoạn code ở trong chương này. Mọi phiên bản 0.9.0
trở lên không được cho phép có cùng API theo như những gì mà ví dụ sau sử dụng.
Bây giờ, thay vì thay đổi bất kỳ phần code nào, hãy xây dựng dự án này, như đã thể hiện trong mục Listing 2-2.
$ cargo build
Updating crates.io index
Downloaded rand v0.8.3
Downloaded libc v0.2.86
Downloaded getrandom v0.2.2
Downloaded cfg-if v1.0.0
Downloaded ppv-lite86 v0.2.10
Downloaded rand_chacha v0.3.0
Downloaded rand_core v0.6.2
Compiling rand_core v0.6.2
Compiling libc v0.2.86
Compiling getrandom v0.2.2
Compiling cfg-if v1.0.0
Compiling ppv-lite86 v0.2.10
Compiling rand_chacha v0.3.0
Compiling rand v0.8.3
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2.53s
Listing 2-2: Đầu ra sau khi chạy cargo build
sau khi thêm crate ngẫu nhiên như một dependency
Bạn có thể thấy sự khác biệt trong số của phiên bản (nhưng chúng sẽ đều tương thích với đoạn code, cảm ơn SemVer!), Những dòng khác nhau (phụ thuộc vào hệ điều hành) và những dòng này code thể ở những trật tự khác nhau.
Khi chúng ta bao hàm những dependency ngoại vi, Cargo sẽ tìm về phiên bản cũ nhất của tất cả những gì mà dependency cần từ registry, đó là một bản sao của dữ liệu từ Crates.io. Crate.io là nơi mà mọi người trong hệ sinh thái Rust có thể đăng những đoạn code Rust mã nguồn mở để mọi người khác có thể sử dụng.
Sau khi cập nhật phần đăng ký, Cargo sẽ kiểm tra mục [dependencies]
và tải về bất kỳ crates nào được liệt kệ nhưng chưa được tải xuống. Trong trường hợp này, mặc dù chúng ta mới liệt kê rand
như là một dependency, Cargo đồng thời mang những crates khác mà rand
cần để hoạt động. Sau khi tải xuống các crate, Rust sẽ biên dịch chúng và sau đó biên dịch dự án với những dependency khả dụng.
Nếu bạn ngay lập tức khởi chạy cargo build
lần nữa mà không thay đổi bất kỳ điều gì, bạn sẽ không nhận được bất kỳ đầu ra ngoài nào từ dòng Finished
. Cargo biết đó đã sẵn sàng được tải xuống và biên dịch các dependency, và bạn sẽ không cần thay đổi bất kỳ thứ gì trong file Cargo.toml của bạn. Cargo đồng thời biết rằng bạn chưa hề thay đổi bất cứ điều gì trong đoạn code của bạn, vì vậy nó không hề biên dịch lại luôn. Với việc không có gì để làm, nó chỉ đơn giản là thoát ra.
Nếu bạn mở file src/main.rs, thay đổi không đáng kể và sau đó lưu chúng và build lại từ đầu, bạn sẽ nhìn thấy hai dòng đầu ra như sau:
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs
Những dòng sau cho thấy rằng Cargo chỉ cập những bản build với sự thay đổi nhỏ nhất trong file src/main/rs. Những dependency của bạn không hề thay đổi, vì vậy Cargo biết rằng chúng có thể tái sử dụng những thứ gì đã được tải xuống và biên dịch những thứ đó.
Đảm bảo rằng có thể tái sử dụng những bản Build trong file Cargo.lock
Cargo có một cơ chế để đảm bảo rằng bạn có thể build lại cùng một sản phẩm từng lần, dù bạn hay người khác build code đó: Cargo sẽ chỉ sử dụng những phiên bản của những dependency mà bạn chỉ định đến khi bạn biểu thị cái khác. Lấy ví dụ, phiên bản tiếp theo của 0.8.4 của rand
crate được công bố, và phiên bản đó đã bao gồm những lỗi đã được sửa, những nó đồng thời bao gồm sự cấp lại, mà có thể phá hỏng code của bạn. Để xử lý điều này, rust tạo ra file Cargo.lock, lần đầu tiên bạn chạy cargo.build
, giờ đây chúng ta có điều này trong thư mục guesing_game
Khi bạn build một project lần đầu, Cargo tìm ra tất cả những phiên bản của các dependency phù hợp với những tiêu chí và rồi ghi chúng vào trong file Cargo.lock tồn tại và sử dụng những phiên bản được chỉ định hơn là làm hết những công việc được tìm ra trong những phiên bản trước đó. Điều này cho bạn khả năng tái sử dụng các bản build một cách tự động. Mặt khác, dự án của bạn sẽ được duy trì ở 0.8.3
đến khi bạn chỉ định cập nhật, cảm ơn file Cargo.lock. Bởi vì file Cargo.lock vô cùng quan trọng cho những bản build có thể tái sử dụng, nó thường xuyên kiếm tra trong trình kiểm soát mã với phần còn lại của đoạn code trong dự án của bạn.
Cập nhật Crate để nhận phiên bản mới hơn
Khi bạn muốn cập nhật một crate, Cargo cung cấp câu lệnh update
, thứ mà bỏ qua file Cargo.lock và tìm ra tất cả những phiên bản mới nhất mà phù hợp với chỉ định của bạn trong file Cargo.toml. Cargo khi đó sẽ viết những phiên bản này vào trong file Cargo.lock. Mặt khác, mặc định, Cargo sẽ chỉ khóa những phiên bản lớn hơn 0.8.3
và nhỏ hơn 0.9.0
. Nếu crate rand
đã được công bố hai phiên bản 0.8.4
và 0.9.0
thì bạn sẽ thấy những dòng sau đây nếu bạn chạy cargo update
:
$ cargo update
Updating crates.io index
Updating rand v0.8.3 -> v0.8.4
Cargo sẽ bỏ qua phiên bản 0.9.0
. Ở thời điểm này, bạn để ý rằng không có thay đổi trong file Cargo.lock của bạn mà những phiên của crate rand
của bạn giờ đây sử dụng 0.8.4
. Để sử dụng phiên bản 0.9.0
của rand
hoặc bất kỳ phiên bản nào khác trong tập 0.9.x
, bạn cần cập nhật trong file Cargo.toml để khóa thay vì làm như sau:
[dependencies]
rand = "0.9.0"
Lần tiếp theo bạn chạy cargo build
, Cargo sẽ cập nhật bản đăng ký của những crate khả dụng và đánh giá lại yêu cầu rand
thay vì phiên bản mới mà bạn chỉ định.
Có nhiều điều để nói về Cargo và its ecosystem thứ mà chúng ta sẽ bàn kỹ hơn trong Chương 14, nhưng không phải bây giờ, đó là tất cả những gì mà bạn cần phải biết. Cargo sẽ làm nó trở nên vô cùng đơn giản để tái sử dụng thư viện, vì vậy những lập trình viên Rust có khả năng viết những dự án nhỏ hơn, những dự án được tập hợp bởi một số lượng các package.
Khởi tạo một số ngẫu nhiên
Hãy bắt đầu sử dụng rand
để khởi tạo một số để đoán. Bước tiếp theo là cập nhật src/main.rs được hiển thị trong Listing 2-3.
Filename: src/main.rs
use std::io;
use rand::Rng;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Listing 2-3: Thêm phần code để khởi tạo ngẫu nhiên
Đầu tiên, chúng ta thêm dòng use rand::Rng
. Rnd
định nghĩa phương thức mà trình khởi tạo số triển khai, và đặc điểm này cần phải trong phạm vi cho chúng ta có thể sử dụng những phương thức này. Chương 10 sẽ bao gồm những đặc điểm này về chi tiết.
Tiếp theo, chúng ta sẽ thêm hai dòng ở giữa. Trong dòng đầu tiên, chúng ta gọi hàm rand::thread_rng
để cho chúng ta một trình khởi tạo số ngẫu nhiên mà sẽ được chúng ta sử dụng: một là từ local đến thread hiện tại của trình thực thi và được seed bởi hệ điều hành. Sau đó chúng. Sau đó chúng ta gọi phương thức gen_rand
trên trình khởi tạo số ngẫu nhiên. Phương thức này được định nghĩa bởi Rng
mà chúng đã đã mang vào trong phạm vi này trước đó với câu lệnh use rand::Rng
. Phương thức gen_rand
lấy hai khoảng của biểu thức như là tham số và khởi tạo ra một số trong phạm vi đó. Kiểu của phạm vi biểu thức này chúng ta sử dụng ở đây để nhận mẫu start..=end
và nó bao gồm giới hạn thấp và cao, vì vậy chúng ta cần chỉ ra 1..=100
để yêu cầu một số giữa 1 và 100.
Ghi chú: bạn sẽ không thể biết đặc điểm nào được sử dụng và phương thức hay hàm nào được gọi trong crate, vì vậy mỗi crate có một tài liệu cho cách sử dụng. Với tính năng neat khác của Cargo được chạy bởi câu lệnh
cargo doc--open
sẽ build một tài liệu được cung cấp bởi tất cả các dependency locally và mở nó trong trình duyệt cua bạn. Nếu bạn cảm thấy thú vị với những tính năng này trong craterand
này, ví dụ, chạycargo doc --open
và bấm vàorand
bên trái trên thành sidebar.
Dòng thứ hai in ra số bí mật. Nó sẽ vô cùng hữu ích khi mà chúng ta phát triển chương trình để có khả năng kiểm thử nó, nhưng chúng ta sẽ xóa nó ra khỏi phiên bản cuối cùng. Sẽ không có nhiều trò chơi nếu chương trình in ra kết quả ngay khi trò chơi bắt đầu.
Thử chạy chương trình vài lần:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2.53s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5
Bạn cần nhận được các số ngẫu nhiên khác nhau, và chúng sẽ đều nằm trong khoảng 1 và 100. Làm tốt lắm!
So sánh dự đoán với số bí mật
Bây giờ chúng ta đã có đầu vào của người dùng và một số bí mật, chúng ta có thể so sánh chúng. Đó là bước được hiển thị trong Listing 2-4. Ghi chú rằng đoạn code này chưa được biên dịch, như chúng ta sẽ giải thích.
Filename: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
// --snip--
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
Listing 2-4: Xử lý các khả năng của giá trị trả về khi so sánh hai số
Đầu tiên chúng ta thêm câu lệnh use
, mang kiểu gọi std::cmp::Ordering
vào trong phạm vi từ thư viện tiêu chuẩn. Kiểu Odering
là một kiểu enum khác và có giá trị Less
, Greater
, và Equal
. Đây là ba đầu ra khả dụng khi bạn so sánh hai giá trị.
Sau đó thêm năm dòng vào phần cuối sử dụng kiểu Ordering
. Phương thức cmp
so sánh hai giá trị và có thể được gọi trên bất kỳ thứ gì có thể so sánh được. Có cần tham chiếu tới bất kỳ thứ giá ban muốn để so sánh với: đây là cách so sánh guess
với secret_number
. Sau đó trả về giá trị của Ordering
enum mà chúng ta mang vào trong phạm vi này với câu lệnh use
. Chúng ta sử dụng biểu thức match
để khai báo những gì cần làm tiếp theo dựa trên những biến nào của Ordering
được trả lại từ lời gọi đến hàm cmp
với những giá trị trong guess
và secret_number
.
Biểu thức match
được tạo ra bởi arms. Một cánh tay bao gồm những pattern để khớp với, và đoạn code nên được chạy nếu giá trị được cho đến match
phù hợp với mô hình cánh tay. Rust nhận những giá trị được cho đến match
và nhìn qua từng mô hình cánh tay trong một lượt. Các mô hình và cấu trúc match
là những tính năng Rust vô cùng mạnh mẽ cho phép bạn thể hiện một vài những tình huống trong code của bạn có thể gặp và đảm bảo rằng bạn có thể xử lý được hết chúng. Những tính năng này sẽ được bao hàm về chi tiết trong Chương 6 và Chương 18 tương ứng.
Cùng nhau dạo qua một ví dụ với biểu thức match
mà chúng ta sử dụng ở đây. Nói rằng người dùng đã đoán 50 lần và số được khởi tạo ngẫu nhiên lần này là 38. Khi mà code so sánh 50 và 38, phương thức cmp
sẽ trả về giá trị Orderring::Greater
và bắt đầu kiểm tra từng mô hình cánh tay. Nó nhìn đến mô hình cánh tay đầu tiên, Ordering::Less
và nhìn thấy giá trị Ordering::Greater
không khớp với Ordering::Less
, vì vậy nó quả qua đoạn code trong cánh tay đó và chuyển tiếp đến canh tay tiếp theo. Mô hình cánh tay tiếp theo là Ordering::Greater
, thứ mà khớp với Ordering::Greater
! Sự liên quan trong đoạn code từ cánh tay đó sẽ thực thi và in ra Too big!
lên màn hình. Biểu thức khớp sau khi lần khớp thành công đầu tiên, vì vậy nó sẽ không nhìn đến cánh tay cuối trong kịch bản.
Mặc dù, đoạn code trong Listing 2-4 sẽ chưa được biên dịch. Hãy thử điều này
$ cargo build
Compiling libc v0.2.86
Compiling getrandom v0.2.2
Compiling cfg-if v1.0.0
Compiling ppv-lite86 v0.2.10
Compiling rand_core v0.6.2
Compiling rand_chacha v0.3.0
Compiling rand v0.8.3
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
--> src/main.rs:22:21
|
22 | match guess.cmp(&secret_number) {
| ^^^^^^^^^^^^^^ expected struct `String`, found integer
|
= note: expected reference `&String`
found reference `&{integer}`
error[E0283]: type annotations needed for `{integer}`
--> src/main.rs:8:44
|
8 | let secret_number = rand::thread_rng().gen_range(1..=100);
| ------------- ^^^^^^^^^ cannot infer type for type `{integer}`
| |
| consider giving `secret_number` a type
|
= note: multiple `impl`s satisfying `{integer}: SampleUniform` found in the `rand` crate:
- impl SampleUniform for i128;
- impl SampleUniform for i16;
- impl SampleUniform for i32;
- impl SampleUniform for i64;
and 8 more
note: required by a bound in `gen_range`
--> /Users/carolnichols/.cargo/registry/src/github.com-1ecc6299db9ec823/rand-0.8.3/src/rng.rs:129:12
|
129 | T: SampleUniform,
| ^^^^^^^^^^^^^ required by this bound in `gen_range`
help: consider specifying the type arguments in the function call
|
8 | let secret_number = rand::thread_rng().gen_range::<T, R>(1..=100);
| ++++++++
Some errors have detailed explanations: E0283, E0308.
For more information about an error, try `rustc --explain E0283`.
error: could not compile `guessing_game` due to 2 previous errors
Cốt lõi của trạng thái lỗi là nó có kiểu không khớp. Rust có hệ thống mạnh, tĩnh. Mặc dù thế, nó cũng có sự suy luận. Khi chúng ta viết let mut guess = String::new()
, Rust có khả năng suy luận ra guess
có thể là kiểu String
và không làm chúng ta viết kiểu. Mặt khác, secret_number
là kiểu số. Và một vài kiểu số của Rust có thể có giá trị từ 1 đến 100: i32
, một số 32 bit; u32
, một số không dấu 32 bit; i64
, một số 64 bit, giống với các số khác. Trừ khi được chỉ định khác, Rust sẽ mặc định sử dụng i32
, đó là kiểu dành cho số secret_number
trừ khi bạn thêm thông tin về kiểu khác, điều đó khiển Rust suy luận một kiểu số khác. Lý do cho lỗi này là Rust không thể so sánh một chuỗi với một kiểu số.
Cuối cùng, chúng ta muốn chuyển đổi kiểu chuỗi để chương trình đọc đầu vào thành một số thực, chúng ta có thể so sánh về mặt số học với số bí mật. Chúng ta làm điều đó bằng cách thêm dòng này vào phần thân của hàm main
.
Filename: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
// --snip--
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
Dòng đó là:
let guess: u32 = guess.trim().parse().expect("Please type a number!");
Chúng ta tạo ra một biến được đặt tên là guess
. Nhưng đợi đã, không chương trình đã có biến tên là guess
rồi hay sao? Đúng vậy, nhưng may thay, Rust cho phép chúng ta shadow giá trị trước đó của guess
với một biến mới. Shadowing cho phép chúng ta tái sử dụng biến guess
thay vì phải tạo ra biến mới, như là guess_str
và guess
. Chúng ta sẽ bao hàm chi tiết vấn đề này trong Chương 3, nhưng bây giờ chỉ cần biết rằng tính năng này thường xuyên được sử dụng khi bạn muốn chuyển đổi một giá trị sang giá trị khác.
Chúng ta gắn biến này vào biểu thức guess.trim().parse()
. guess
trong biểu thúc này cho thấy rằng biến guess
nguyên bản chứa đầu vào như là một chuỗi. Phương thức trim
lên String
instance sẽ xóa bỏ bất kỳ khoảng trắng nào ở đầu và cuối chuỗi, chúng ta cần làm vậy để có khả năng so sánh chuỗi với u32
, thứ mà chỉ bao gồm dữ liệu số. Người dùng sẽ nhập enter để thõa mãn read_line
và nhập dự đoán của họ, thứ mà được thêm một dòng những ký tự mới thành chuỗi. Ví dụ, nếu người dùng nhập 5 và nhấn enter, guess
sẽ giống như này 5\n
. \n
biểu thị dòng mới (Trên windows, nhấn enter kết quả trong toa xe sẽ trả về và một dòng mới \r\n
). Phương thức trim
sẽ xóa bỏ \n
và \r\n
, kết quả sẽ chỉ là 5
.
parse
method on strings sẽ chuyển đổi một chuỗi thành kiểu dữ liệu khác. Ở đây, chúng ta sẽ sử dụng nó để chuyển đối nó từ một chuỗi thành số. Chúng ta cần nói với Rust chính xác kiểu dữ liệu mà chúng ta cần, sử dụng let guess: u32
. Dấu hai chấm (:
) sau guess
nói với Rust rằng chúng ta sẽ chú thích biến ở đây. Rust có một vài kiểu số xây dựng trong; u32
ở đây là một số không dấu, số nguyên 32 bit. Đây là một lựa chọn mặc định tốt dành cho số dương nhỏ. Bạn sẽ học được về kiểu số khác trong Chương 3. Trong điều kiện đó, chú thích u32
trong chương trình ví dụng này và sự so sánh với secret_number
có ý nghĩa là Rust sẽ suy luận rằng secret_number
sẽ là u32
. Giờ đây sự so sánh sẽ là giữa hai giá trị có cùng kiểu.
Phương thức parse
sẽ chỉ làm việc trên những ký tự có thể chuyển đổi hợp lý thành số và nó cũng dễ gây ra lỗi. Nếu, ví dụ là, chuỗi chứa A👍%
, sẽ không thể nào chuyển đôi nó thành một số được. Vì nó sẽ thất bại, phương thức parse
sẽ trả về kiểu Result
, giống như phương thức read_line
làm (đã được thảo luận trước đó trong “Handling Potential Failure with theResult
Type”). Chúng ta sẽ đối xử với Result
cùng với cách mà chúng ta sử dụng phương thức expect
lần nữa. Nếu parse
trả về biến thể Err
của Result
vì không thể tạo một số từ một chuỗi, lời gọi expect
sẽ phá hỏng trò chơi và in tin nhắn mà chúng ta đã đưa cho nó. Nếu parse
có thể thành công chuyển đổi chuỗi thành số, nó sẽ trả về biến thể Ok
của Result
, và expect
sẽ trả về số mà chúng ta muốn ở giá trị Ok
.
Bây giờ hãy khởi chạy chương trình!
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
76
You guessed: 76
Too big!
Tốt! Kể cả khi khoảng trắng được thêm vào trước dự đoán, chương trình vẫn tìm ra được dự đoán của người dùng là 76. Chạy chương trình vài lần để kiểu tra hành vi khác nhau với những kiểu đầu vào khác nhau: dự đoán số chính xác, dự đoán số quá cao, dự đoán số quá thấp.
Chúng ta đã có gần hết trò chơi bây giờ, nhưng người chơi chỉ có thể đoán một lần. Hãy thay đổi điều đó bằng cách thêm vào môt vòng lặp!
Từ khóa loop
tạo ra một vòng lặp vô hạn. Chúng ta sẽ thêm một vòng lặp để cho người dùng có nhiều cơ hội hơn để đoán số:
Filename: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
// --snip--
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
// --snip--
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
}
Như bạn đã thấy, chúng ta đã chuyển tất cả từ đầu vào người dùng trở đi vào trong vòng lặp. Hãy chắc chắn rằng dòng mới được thụt vào trong với 4 khoảng trắng và chạy lại chương trình lần nữa. Chương trình sẽ hỏi dự đoán mãi mãi, đây là một vấn đề mới. Dường như là người chơi không thể thoát.
Người dùng có thể gián đoạn chương trình bất cứ lúc nào, sử dụng tổ hợp phím: ctrl-c. Nhưng có cách khác để thoát ra, như đã đề cập trước đó ở phần thảo luận parse
trong “Comparing the Guess to the Secret Number”: Nếu người chơi nhấn một phím không phải số, chương trình sẽ hỏng. Chúng ta cần tận dụng lợi thế đó để cho phép người chơi thoát, như dưới đây:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/main.rs:28:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Gõ quit
sẽ thoát trò chơi, nhưng bạn cần chú ý rằng người dùng có thể nhập một ký tự không phải số. Đây là cách không hề tối ưu, ít nhất, chúng ta muốn trò chơi dừng lại khi người chơi dự đoán đúng số.
Thoát sau khi dự đoán đúng
Hãy lập trình một trò chơi khi người chơi thắng bằng cách thêm câu lệnh break
:
Filename: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
Thêm dòng break
sau You win!
làm cho chương trình thoát ra khỏi vòng lặp khi mà người chơi dự đoán đúng. Thoát khỏi vòng lặp đồng nghĩa với việc thoát khỏi chương trình, bởi vì vòng lặp là phần cuối cùng của main
.
Xử lý đầu vào không hợp lệ
Để lọc nhiều hơn những hành vi của trò chơi, hơn là chỉ dừng chương trình khi người chơi nhập một ký tự không phải số, hãy làm cho trò chơi bỏ qua ký tự đó để người chơi có thể tiếp tục dự đoán. Chúng là có thể làm được điều đó bằng cách thay đổi dòng sau, nơi mà guess
được chuyển đổi từ String
thành u32
. Được thể hiện trong Listing 2-5;
Filename: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
let mut guess = String::new();
// --snip--
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
Listing 2-5: Bỏ qua một ký tự không phải số và yêu cầu một dự đoán khác thay vì dừng chương trình
Chúng ta chuyển từ lời gọi expect
thành biểu thức match
để từ dừng chương trình thành một lỗi có thể xử lý được. Nhớ rằng parse
sẽ trả về một kiểu Result
là một enum có biến thể Ok
và Err
. Chúng ta đang sử dụng biểu thức match
ở đây, như cách chúng ta đã làm với kết quả Ordering
của phương thức cmp
.
Nếu parse
cho phép chuyển thành công từ chuỗi thành số, nó sẽ trả về giá Ok
chứa kết quả số. Giá trị Ok
đó sẽ khớp với mô hình cánh tay đầu tiên, và biểu thức match
sẽ chỉ trả về giá trị num
mà thủ tục parse
và trả về bên trong giá trị Ok
. Số này sẽ kết thúc ở nơi ta muốn nó ở trong giá trị guess
mà chúng ta tạo ra.
Nếu parse
không có khả năng để chuyển một chuỗi thành số, nó sẽ trả về giá trị Err
hàm chứa nhiều thông tin hơn về lỗi. Giá trị Err
không khợp với mẫu Err(_)
trong cánh tay match
đầu tiên. Dấu gạch dưới _
là một giá trị catchall; Trong ví dụ này, chúng ta nói rằng chúng ta muốn khớp tất cả giá trị Err
, không quan trọng thông tin nào mà họ có. Vì thế chương trình sẽ thực thi đoạn mã trong cánh tay thứ hai, continue
nói với chương trình đi tới lần lặp tiếp theo của loop
và tiếp tục hỏi dự đoán khác. Vì thế, vô cùng hiệu quả, chương trình sẽ bỏ qua tất cả lỗi mà parse
có thể gặp!
Giờ đây mọi tính năng trong chương trình cần hoạt động như kì vọng. Hãy chạy thử:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 4.45s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!
Tuyệt vời! Với một chút chỉnh sửa, chúng ta sẽ kết thúc trò chơi đoán số. Gọi lại chương trình vẫn sẽ in ra số bí mật. Nó hoạt động tốt trong lúc kiểm thử, nhưng nó sẽ phá hỏng trò chơi, Hãy cùng xóa println!
mà in ra số bí mật. Listing 2-6 sẽ hiển thị đoạn code chính thức.
Filename: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
loop {
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
Listing 2-6: Hoàn thiện đoạn mã của trò chơi đoán số
Tổng kết
Ở thời điểm này, bạn đã thành công xây dựng trò chơi đoán số. Chúc mừng!
Dự án này là cách bắt tay vào để giới thiệu cho bạn những ý tưởng mới trong Rust: các hàm let
, match
, cách dùng các crate ngoại vi, và nhiều hơn nữa. Trong vài chương tiếp theo, bạn sẽ học được về những ý tưởng này chi tiết hơn. Chương 3 sẽ bao hàm các ý tưởng mà hầu hết các ngôn ngữ lập trình có, ví dụ như biến, kiểu dữ liệu và các hàm, và cho bạn thấy cách để dùng chúng trong Rust. Trong chương 4, chúng ta sẽ khám phá quyền sở hữu, một tính năng khiến Rust trở nên khác biệt so với các ngôn ngữ khác. Chương 5 chúng ta sẽ thảo luận sẽ các cấu trúc và các cú pháp phương thức. Và chương 6 sẽ giải thích enum hoạt động như nào.
Các khái niệm lập trình chung
Chương này bao gồm các khái niệm xuất hiện hầu hết trong mọi ngôn ngữ lập trình và cách chúng hoạt động trong Rust. Nhiều ngôn ngữ lập trình có nhiều điểm chung trong cố lõi của chúng. Không có khái niệm nào trong chương trình là duy nhất đối với Rust nhưng chúng ta sẽ thảo luận về chúng trong ngữ cảnh Rust và giải thích các quy ước xung quanh việc sử dụng các khái niệm này.
Cụ thể, bạn sẽ tìm hiểu về các biến, các kiểu dữ liệu cơ bản, hàm, comment và control flow. Những nền tảng này sẽ có mặt trong mọi chương trình Rust và học chúng sớm sẽ cung cấp cho bạn một nền tảng cốt lõi vững chắc.
Từ khóa
Ngôn ngữ Rust có một tập hợp các từ khóa (keywords) chỉ dành riêng cho ngôn ngữ đó, giống như nhiều ngôn ngữ khác. Hãy nhớ rằng bạn không thể sử dụng các từ khóa này để đặt tên biến hay tên hàm. Hầu hết từ khóa có ý nghĩa đặc biệt và bạn sẽ sử dụng chúng để thực hiện nhiều tác vụ khác nhau trong chương trình Rust; một vài tự khóa hiện tại chưa có chức năng đi kèm với chúng nhưng đã được dành riêng cho các chức năng có thể được thêm vào Rust trong tương lai. Bạn có thể tìm thấy danh sách các từ khóa trong Phụ lục A.
Biến (Variable) và Tính biến đổi (Mutability)
Như đã đề cập trong phần “Sử dụng biến để chứa các giá trị”, các biến mặc định là không thể thay đổi được (bất biến - immutable). Đây là một trong số nhiều khuyến khích mà Rust cung cấp để bạn viết code theo cách tận dụng sự an toàn và đồng thời dễ dàng mà Rust đưa ra. Tuy nhiên, bạn vẫn có tùy chọn để khiến cho biến có thể thay đổi (mutable). Hãy cùng tìm hiểu cách thức và lý do tại sao Rust khuyến khích bạn ưu tiên tính bất biến (immutability) và tại sao đôi khi bạn có thể không muốn thế.
Khi một biến là immutable, bạn không thể thay đổi giá trị đã được gán vào biến đó.
Để mô tả điều này, hãy tạo một dự án có tên variables trong thư mục projects
bằng cách sử dụng cargo new variables
.
Sau đó, trong thư mục variables, mở file src/main.rs và thay code của nó bằng đoạn code bên dưới. Code này sẽ chưa được biên dịch, chúng sẽ kiểm tra lỗi về tính bất biến trước.
Filename: src/main.rs
fn main() {
let x = 5;
println!("The value of x is: {}", x);
x = 6;
println!("The value of x is: {}", x);
}
Lưu lại và chạy chương trình bằng cargo run
. Bạn sẽ nhận một thông báo lỗi
như được hiển thị trong phần kết quả này:
$ cargo run
Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
--> src/main.rs:4:5
|
2 | let x = 5;
| -
| |
| first assignment to `x`
| help: consider making this binding mutable: `mut x`
3 | println!("The value of x is: {}", x);
4 | x = 6;
| ^^^^^ cannot assign twice to immutable variable
For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error
Ví dụ này chỉ ra cách mà trình biên dịch giúp bạn tìm ra lỗi trong chương trình. Lỗi trình biên dịch có thể gây khó chịu, nhưng thực sự chúng chỉ có nghĩa rằng chương trình của bạn chưa thực hiện một cách an toàn những gì bạn muốn; chúng không có nghĩa là bạn không phải là một lập trình viên giỏi! Nhiều Rustacean có kinh nghiệm vẫn gặp những lỗi này.
Thông báo lỗi chỉ ra nguyên nhân lỗi là cannot assign twice to immutable variable `x`
, bởi vì bạn đã cố gắng gán một giá trị
thứ hai vào biến immutable x
.
Điều quan trọng là chúng ta gặp lỗi compile-time khi chúng ta cố gắng thay đổi giá trị immutable bởi vì chính tình huống này có thể dẫn tới bugs. Nếu một phần code hoạt động trên giả định rằng một giá trị sẽ không bao giờ bị thay đổi và một phần khác có thể thay đổi giá trị đó thì phần code đầu tiền sẽ không thể thực hiện được như những gì nó được thiết kế. Nguyên nhân của loại bug này có thể khó lần ra trong thực tế, đặc biệt là khi đoạn code thứ hai chỉ đôi khi thay đổi giá trị. Trình biên dịch Rust đảm bảo rằng khi bạn chỉ đinh một giá trị sẽ không thay đổi, nó sẽ thực sự không đổi, vì vậy bạn không cần phải tự mình theo dõi nó. Do đó, code của bạn sẽ dễ dàng lập luận hơn.
Nhưng mutability có thể rất hữu ích và có thể khiến bạn viết code thuận tiện hơn.
Các biến chỉ immutable theo mặc định; như bạn đã làm trong Chương 2, bạn có thể
làm cho chúng mutable khi thêm mut
vào trước tên biến. Việc thêm mut
cũng
truyền tải ý định đến những người đọc code trong tương lai bằng cách chỉ ra rằng
các phần khác của code sẽ thay đổi giá trị của biến này.
Ví dụ, hãy thay đổi file src/main.rs thành như sau:
Filename: src/main.rs
fn main() { let mut x = 5; println!("The value of x is: {}", x); x = 6; println!("The value of x is: {}", x); }
Khi chúng ta chạy chương trình, chúng ta sẽ nhận được như vầy:
$ cargo run
Compiling variables v0.1.0 (file:///projects/variables)
Finished dev [unoptimized + debuginfo] target(s) in 0.30s
Running `target/debug/variables`
The value of x is: 5
The value of x is: 6
Chúng ta được phép thay đổi giá trị gán vào x
từ 5
thành 6
khi chúng ta dùng mut
.
Có nhiều sự đánh đổi cần cân nhắc ngoài việc ngăn ngừa bugs. Ví dụ, trong trường hợp bạn
đang sử dụng một cấu trúc dữ liệu lớn, việc thay đổi instance tại chỗ có thể sẽ nhanh hơn
so với việc sao chép và trả về các instance mới được phân bổ. Với cấu trúc dữ liệu nhỏ hơn,
việc tạo instace mới và viết theo phong cách lập trình nhiều chức năng hơn có thể dễ dàng hơn
để suy nghĩ, do đó hiệu suất thấp hơn có thể là một hình phạt đáng giá để tăng đạt được sự rõ
ràng đó.
Hằng số (Constants)
Giống như các biến immutable, constants là các giá trị được gắn với một cái tên và không được phép thay đổi, nhưng có một vài khác biệt giữa hằng số và biến.
Đầu tiên, bạn không được phép sử dụng mut
với hằng số. Hằng số không chỉ
immutable theo mặc định - chúng luôn luôn immutable. Bạn khai báo hằng số sử dụng từ khóa
const
thay vì từ khóa let
, và kiểu dữ liệu của giá trị buộc phải
được chú thích. Chúng ta sắp đề cập đến kiểu dữ liệu và chú thích kiểu dữ liệu trong
phần tiếp theo, “Các kiểu dữ liệu” vì vậy đừng lo lắng
về chi tiết lúc này. Chỉ biết rằng bạn phải luôn luôn chú thích kiểu dữ liệu.
Hằng số có thể được khai báo trong bất kì phạm vi nào, bao gồm cả phạm vi toàn cục (global scope), điều này làm hằng số trở nên hữu ích cho các phần của code cần sử dụng giá trị của chúng.
Sự khác biệt cuối cùng là các hằng số chỉ có thể khai báo ở dạng biểu thức hằng, chứ không phải kết quả của một giá trị được tính toán lúc runtime.
Dưới đây là một ví dụ về khai báo hằng:
#![allow(unused)] fn main() { const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3; }
Tên của hằng số là THREE_HOURS_IN_SECONDS
và giá trị của nó được thiết lập là
kết quả của 60 (số giây trong một phút) nhân 60 (số phút trong một giờ)
nhân 3 (số giờ chúng ta muốn đếm trong chương trình). Quy ước đặt tên hằng số
của Rust là đặt tên với chữ in hoa và phân cách giữa các từ bằng dấu gạch dưới.
Trình biên dịch có thể tính toán hạn chế một số phép toán ở thời điểm biên dịch,
điều này cho phép chúng ta chọn viết ra giá trị này theo một cách dễ hiểu và dễ
xác minh hơn, hơn là để giá trị 10,800 cho hằng số này.
Hãy xem Rust Reference’s section on constant evaluation để biết thêm
thông tin về những phép toán có thể được dùng khi khai báo hằng số.
Hằng số hợp lệ trong toàn bộ thời gian chương trình chạy, trong phạm vi mà chúng được khai báo. Thuộc tính này làm cho hằng số trở nên hữu ích trong cho các giá trị trong miền ứng dụng của bạn mà nhiều phần của chương trình có thể cần chúng, chẳng hạn như số điểm tối đa mà bất cứ người chơi nào trong game có thể kiếm được hoặc tốc độ ánh sáng.
Đặt tên cho các giá trị được mã hóa cứng được sử dụng trong suốt chương trình của bạn dưới dạng hằng số rất hữu ích trong việc truyền đạt ý nghĩa của giá trị đó đến với những người bảo trì code trong tương lai. Nó cũng hữu ích khi chỉ có một vị trí trong code của bạn mà bạn sẽ cần thay đổi nếu giá trị được mã hóa cứng đó cần được cập nhật trong tương lai.
Phủ bóng (Shadowing)
Như bạn đã thấy trong bài hướng dẫn game đoán số trong Chương
2, bạn có thể khai báo
một biến mới với cùng tên gọi như biến trước đó. Rustaceans nói rằng biến đầu
tiên bị phủ bóng (shadowed) bởi biến thứ hai, điều này có nghĩa là giá trị của
biến thứ hai là giá trị mà chương trình thấy khi biến đó được sử dụng. Chúng ta
có thể phủ bóng một biến bằng cách sử dụng tên của biến đó và sử dụng lại từ khóa
let
như sau:
Filename: src/main.rs
fn main() { let x = 5; let x = x + 1; { let x = x * 2; println!("The value of x in the inner scope is: {}", x); } println!("The value of x is: {}", x); }
Đầu tiên, chương trình gán x
với giá trị 5
. Sau đó phủ bóng x
bằng cách
lặp lại let x =
, lấy giá trị ban đầu và cộng 1
do đó, giá trị của
x
khi đó là 6
. Sau đó, trong phạm vi bên trong, câu lệnh let
thứ ba cũng
phủ bóng x
, nhân giá trị trước đó với 2
để x
được giá trị là 12
.
Khi phạm vi kết thúc, việc phủ bóng ở phạm vi bên trong kết thúc và x
trả về giá trị 6
.
Khi chúng ta chạy chương trình, đầu ra sẽ như sau:
$ cargo run
Compiling variables v0.1.0 (file:///projects/variables)
Finished dev [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6
Phủ bóng khác với đánh dấu một biến với mut
, bởi vì chúng ta sẽ gặp lỗi
compile-time nếu chúng ta vô tình cố gắng gán lại cho biến này mà không
sử dụng từ khóa let
. Bằng cách sử dụng let
, chúng ta có thể thực hiện
một số phép biến đổi trên một giá trị nhưng biến đó không thể thay đổi được
sau khi các phép biến đổi đó hoàn tất.
Sự khác biệt khác giữa mut
and shadowing là do chúng ta đang tạo ra một biến
mới một cách hiệu quả khi chúng ta sử dụng lại từ khóa let
, chúng ta có thể
thay đổi kiểu dữ liệu của giá trị nhưng sử dụng lại tên đó. Ví dụ, giả sử
chương trình của chúng ta yêu cầu người dùng hiển thị bao nhiêu khoảng cách mà
họ muốn giữa một số đoạn text bằng cách nhập các ký tự khoảng trắng và sau đó
chúng ta muốn lưu trữ đầu vào đó dưới dạng số:
fn main() { let spaces = " "; let spaces = spaces.len(); }
Biến spaces
đầu tiên có kiểu string và biến spaces
thứ hai có kiểu dữ liệu
số. Do đo shadowing giúp chúng ta không cần phải đặt các tên khác nhau như
spaces_str
và spaces_num
; thay vào đó, chúng ta có thể sử dụng lại cái
tên đơn giản hơn spaces
. Tuy nhiên, nếu chúng ta cố gắng sử dụng mut
cho
việc này, chúng ta sẽ gặp lỗi compile-time như bên dưới:
fn main() {
let mut spaces = " ";
spaces = spaces.len();
}
Lỗi cho biết chúng ta không được phép thay đổi kiểu dữ liệu của một biến:
$ cargo run
Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
--> src/main.rs:3:14
|
2 | let mut spaces = " ";
| ----- expected due to this value
3 | spaces = spaces.len();
| ^^^^^^^^^^^^ expected `&str`, found `usize`
For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` due to previous error
Bây giờ chúng ta đã khám phá cách các biến hoạt động, hãy cùng xem xét thêm các kiểu dữ liệu mà Rust có thể có.
Kiểu dữ liệu
Mọi giá trị trong Rust đều có một kiểu dữ liệu xác định, dựa vào kiểu dữ liệu Rust sẽ biết phải làm việc với dữ liệu đó như thế nào. Chúng ta sẽ xem xét hai tập con của kiểu dữ liệu: vô hướng và kết hợp.
Hãy nhớ rằng Rust là ngôn ngữ định kiểu tĩnh (statically typed), tức là Rust phải biết được kiểu
dữ liệu của tất cả các biến tại thời điểm biên dịch. Trình biên dịch thông thường
có thể suy luận kiểu dữ liệu mà chúng ta đang dùng dựa trên giá trị và cách chúng ta sử dụng
giá trị đó. Trong các trường hợp có nhiều kiểu, chẳng hạn như khi chúng ta chuyển
đổi String
sang kiểu số bằng cách sử dụng parse
trong phần “So sánh số dự đoán với
số bí mật” trong Chương 2,
chúng ta phải chú thích rõ kiểu dữ liệu như sau:
#![allow(unused)] fn main() { let guess: u32 = "42".parse().expect("Not a number!"); }
Nếu chúng ta không thêm chú thích kiểu dữ liệu vào, Rust sẽ hiển thị lỗi như bên dưới, trình biên dịch cần thêm thông tin để biết chúng ta đang sử dụng kiểu dữ liệu nào:
$ cargo build
Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0282]: type annotations needed
--> src/main.rs:2:9
|
2 | let guess = "42".parse().expect("Not a number!");
| ^^^^^ consider giving `guess` a type
For more information about this error, try `rustc --explain E0282`.
error: could not compile `no_type_annotations` due to previous error
Các loại dữ liệu khác nhau sẽ chú thích khác nhau.
Kiểu dữ liệu vô hướng
Một kiểu dữ liệu vô hướng (scalar) đại diện cho một giá trị duy nhất. Rust có 4 kiểu vô hướng chính: số nguyên (integers), số thực dấu phẩy động (floating-point numbers), Booleans và ký tự (characters). Bạn có thể thấy chúng quen thuộc ở các ngôn ngữ lập trình khác. Hãy cùng tìm hiểu cách chúng hoạt động trong Rust.
Kiểu số nguyên (interger)
Số nguyên là một số không có phần thập phân. Chúng ta đã sử dụng kiểu số nguyên
trong Chương 2, kiểu u32
. Việc khai báo kiểu dữ liệu này cho giá trị chỉ ra rằng giá trị
được khai báo phải là một số nguyên không dấu chiếm 32 bit (kiểu số nguyên có dấu bắt đầu bằng i
,
thay vì u
). Bảng 3-1 chỉ ra các kiểu số nguyên được xây dựng sẵn trong Rust. Chúng ta
có thể sử dụng bất kì variant nào trong này để khai báo kiểu số nguyên.
Bảng 3-1: Các kiểu số nguyên trong Rust
Độ dài | Signed | Unsigned |
---|---|---|
8-bit | i8 | u8 |
16-bit | i16 | u16 |
32-bit | i32 | u32 |
64-bit | i64 | u64 |
128-bit | i128 | u128 |
arch | isize | usize |
Mỗi variant có thể có dấu hoặc không dấu và có kích thước rõ ràng. Signed và unsigned chỉ ra rằng số đó liệu có thể có giá trị âm hay không, một số có dấu (signed) có thể chứa giá trị âm và dương, trong khi một số không có dấu (unsigned) sẽ chỉ chứa giá trị dương. Giống như việc viết số trên giấy: khi dấu là quan trọng, một số sẽ được ghi kèm với dấu cộng hoặc dấu trừ; tuy nhiên, thông thường khi viết số dương thường không có dấu. Các số có dấu được lưu trữ sử dụng two’s complement representation.
Mỗi signed variant có dấu có thể lưu trữ các số từ -(2n - 1) đến 2n -
1 - 1, trong đó n là số bits mà variant sử dụng. Do đó,
i8
có thể chứa các số từ -(27) đến 27 - 1, tương ứng từ
-128 đến 127. Unsigned variants có thể chứa các số từ 0 đến 2n - 1,
do đó u8
chứa các số từ 0 đến 28 - 1, tương ứng từ 0 đến 255.
Ngoài ra, kiểu isize
and usize
phụ thuộc vào cấu hình máy tính mà chương trình bạn
đang chạy, các kiểu này được ký hiệu trong bảng là “arch”:
64 bits nếu bạn đang dùng máy tính cấu hình 64-bit và 32 bits nếu bạn
đang dùng cấu hình 32-bit.
Bạn có thể viết số nguyên ở bất kỳ dạng nào như trong Bảng 3-2. Lưu ý rằng
các ký tự số (number literals) có thể là nhiều kiểu số cho phép một hậu tố để chỉ
định kiểu dữ liệu, chẳng hạn như 57u8
. Number literals cũng có thể sử dụng _
để phân
tách số cho dễ đọc hơn, ví dụ 1_000
sẽ có cùng giá trị như khi bạn khai
báo 1000
.
Bảng 3-2: Integer Literals trong Rust
Number literals | Example |
---|---|
Decimal | 98_222 |
Hex | 0xff |
Octal | 0o77 |
Binary | 0b1111_0000 |
Byte (u8 only) | b'A' |
Vì vậy làm cách nào bạn biết nên sử dụng loại số nguyên nào? Nếu bạn không chắc chắn
về điều đó, kiểu dữ liệu mặc định của Rust thường hữu ích: ví dụ, kiểu dữ liệu mặc định của
số nguyên trong Rust là i32
. Còn isize
và usize
bạn sẽ sử dụng khi cần lập chỉ mục một
số loại collection.
Tràn số nguyên (Integer Overflow)
Giả sử bạn có một biến có kiểu dữ liệu
u8
có thể lưu giá trị từ 0 đến 255. Nếu bạn cố gắng thay đổi giá trị của biến vượt ra khỏi phạm vi trên, chẳng hạn như 256, integer overflow sẽ xảy ra có thể dẫn đến một trong hai hành vi. Khi bạn biên dịch ở chế độ debug, Rust sẽ bao gồm các kiểm tra về integer overflow có phải là nguyên nhân khiến chương trình của bạn panic ở thời gian chạy nếu hành vi này xảy ra. Rust sử dụng thuật ngữ panicking khi thoát một chương trình bị lỗi, chúng ta sẽ thảo luận panics sâu hơn trong phần “Các lỗi không thể phục hồi vớipanic!
” trong Chương 9.Khi bạn biên dịch trong chế độ release với cờ
--release
, Rust sẽ không bao gồm các kiểm tra về integer overflow. Thay vào đó, nếu overflow xảy ra, Rust thực hiện two’s complement wrapping. Tóm lại, các giá trị lớn hơn giá trị mà kiểu dữ liệu có thể chứa sẽ “wrap around” vào giá trị nhỏ nhất mà kiểu dữ liệu có thể lưu giữ. Trong trường hợpu8
, giá trị 256 trở thành 0, giá trị 257 trở thành 1, v..v.. Chương trình sẽ không panic, nhưng biến sẽ có một giá trị mà bạn không mong đợi. Đây được coi là một lỗi.Để xử lý rõ ràng khả năng overflow, bạn có thể sử dụng các phương thức do thư viện chuẩn cung cấp cho các kiểu số nguyên thủy:
- Wrap trong tất cả các chế độ bằng các phương thức
wrapping_*
, nhưwrapping_add
- Trả về giá trị
None
nếu overflow xảy ra bằng phương thứcchecked_*
- Trả về giá trị và một boolean cho biết liệu overflow có xảy ra hay không bằng phương thức
overflowing_*
- Saturate ở các giá trị tối thiểu hoặc tối đa bằng phương thức
saturating_*
Kiểu dấu phẩy động
Rust cũng có hai kiểu dữ liệu nguyên thủy cho số thực dấu phẩy động, các số
có dấu phần thập phân. Kiểu dấu phẩy động của Rust là f32
và f64
,
tương ứng với kích thước 32 bits và 64 bits. Kiểu mặc định trong Rust là f64
bởi vì các CPU hiện đại bây giờ tốc độ giống như f32
nhưng chính xác hơn.
Tất cả kiểu dấu phẩy động đều có dấu.
Dưới đây là một ví dụ về sử dụng số thực dấu phẩy động:
Filename: src/main.rs
fn main() { let x = 2.0; // f64 let y: f32 = 3.0; // f32 }
Số thực dấu phẩy động được biểu diễn theo tiêu chuẩn IEEE-754 standard. Kiểu float
f32
có độ chính xác đơn và f64
có độ chính xác gấp đôi.
Các phép toán số học
Rust hỗ trợ tất cả các phép toán cơ bản cho tất cả kiểu số:
cộng, trừ, nhân, chia và phần dư. Phép chia số nguyên được làm
tròn đến số nguyên gần nhất. Code bên dưới chỉ bạn cách sử dụng
mỗi phép toán trong câu lệnh let
:
Filename: src/main.rs
fn main() { // addition let sum = 5 + 10; // subtraction let difference = 95.5 - 4.3; // multiplication let product = 4 * 30; // division let quotient = 56.7 / 32.2; let floored = 2 / 3; // Results in 0 // remainder let remainder = 43 % 5; }
Mỗi biểu thức trong các câu lệnh sử dụng một toán tử toán học và cho ra kết quả là một giá trị đơn được gán vào một biến. Phụ lục B chứa danh sách bao gồm tất cả các toán tử mà Rust cung cấp.
Kiểu Boolean
Như trong hầu hết các ngôn ngữ lập trình khác, kiểu Boolean trong Rust chứa hai giá trị:
true
và false
. Booleans có kích thước 1 byte. Sử dụng bool
để chỉ ra kiểu Boolean
trong Rust. Ví dụ:
Filename: src/main.rs
fn main() { let t = true; let f: bool = false; // with explicit type annotation }
Giá trị Boolean được sử dụng chủ yếu trong các câu điều kiện, chẳng hạn như biểu thức if
.
Chúng ta sẽ đề cập về biểu thức if
được sử dụng như thế nào trong Rust trong phần “Control
Flow”.
Kiểu ký tự
Kiểu char
trong Rust là kiểu chữ cái nguyên thủy nhất của ngôn ngữ. Sau đây là
một vài ví dụ về khai báo giá trị char
:
Filename: src/main.rs
fn main() { let c = 'z'; let z = 'ℤ'; let heart_eyed_cat = '😻'; }
Lưu ý rằng chúng ta chỉ định ký tự char
bằng dấu nháy đơn, trong khi ký tự chuỗi
sử dụng dấu nháy kép. Kiểu char
trong Rust có kích thước 4 bytes và đại diện
cho một Giá trị Vô hướng Unicode (Unicode Scalar Value), tức là nó có thể đại diện
cho nhiều thứ hơn ASCII. Tấy cả các chữ cái có dấu; chữ Trung Quốc, Nhật Bản và Hàn Quốc; emoji
và zero-width spaces đều là giá trị char
hợp lệ trong Rust. Unicode Scalar
Values nằm trong khoảng từ U+0000
đến U+D7FF
và U+E000
đến U+10FFFF
.
Tuy nhiên, một “ký tự” không thực sự là một khái niệm trong Unicode, vì vậy trực giác của
con người về “ký tự” là gì có thể không trùng khớp với char
trong
Rust. Chúng ta sẽ thảo luận chi tiết về chủ đề này trong “Storing UTF-8 Encoded Text with
Strings” ở Chương 8.
Kiểu kết hợp (Compound Types)
Compound types có thể nhóm nhiều giá trị vào một kiểu. Rust có hai kiểu kết hợp nguyên thủy là: tuples và arrays.
Kiểu Tuple
Tuple là cách thông thường nhóm một số giá trị tương ứng với những kiểu dữ liệu khác nhau lại. Tuples có độ dài cố định: một khi được khai báo, chúng ta không thể tăng hoặc giảm kích thước của chúng.
Chúng ta tạo ra tuple bằng cách viết một danh sách các giá trị được phân cách nhau bằng dấu phẩy bên trong dấu ngoặc tròn. Mỗi vị trí trong tuple mang một kiểu dữ liệu và không nhất thiết tất cả các giá trị trong tuple phải có kiểu dữ liệu giống nhau. Chúng tôi đã thêm chú thích kiểu dữ liệu như trong ví dụ sau:
Filename: src/main.rs
fn main() { let tup: (i32, f64, u8) = (500, 6.4, 1); }
Toàn bộ tuple được gán cho biến tup
, vì một tuple được coi là một phần tử
kết hợp đơn lẻ. Để lấy các giá trị riêng lẻ ra khỏi tuple, chúng ta có thể
sử dụng pattern matching để destructure giá trị như sau:
Filename: src/main.rs
fn main() { let tup = (500, 6.4, 1); let (x, y, z) = tup; println!("The value of y is: {}", y); }
Chương trình ban đầu tạo ra một a tuple và gán nó vào biến tup
. Sau đó
sử dụng pattern với let
để biến tup
trở thành ba biến riêng biệt,
x
, y
và z
. Cách làm này được gọi là destructuring, bởi vì nó chia một
tuple đơn lẻ thành ba phần riêng biệt. Cuối cùng, chương trình in ra giá trị của
y
là 6.4
.
Chúng ta cũng có thể truy cập trực tiếp vào một tuple bằng cách sử dụng dấu chấm (.
)
theo sau đó là vị trí của giá trị mà chúng ta muốn truy cập. Ví dụ:
Filename: src/main.rs
fn main() { let x: (i32, f64, u8) = (500, 6.4, 1); let five_hundred = x.0; let six_point_four = x.1; let one = x.2; }
Chương trình tạo ra một tuple x
, sau đó tạo các biến mới cho từng phần tử
bằng cách sử dụng chỉ số ứng với chúng. Như với hầu hết các ngôn ngữ lập trình,
vị trí đầu tiên trong tuple là 0.
Tuple không chứa bất kì giá trị nào là một kiểu đặc biệt chỉ chứa một giá trị,
()
. Kiểu này được gọi là unit type và giá trị đó được gọi là
unit value. Các biểu thức sẽ trả về unit value nếu chúng không trả về bất kì
giá trị nào khác.
Kiểu Mảng (Array)
Một cách khác để có một collection với nhiều giá trị là sử dụng array. Không giống như tuple, mọi phần tử của array phải có kiểu dữ liệu giống nhau. Không giống như array trong các ngôn ngữ khác, các array trong Rust có độ dài cố định.
Chúng ta tạo array bằng cách viết một danh sách các giá trị được phân cách nhau bằng dấu phẩy đặt bên trong dấu ngoặc vuông:
Filename: src/main.rs
fn main() { let a = [1, 2, 3, 4, 5]; }
Arrays rất hữu ích khi bạn muốn dữ liệu của mình được phân bổ trên stack hơn là trên heap (chúng ta sẽ thảo luận nhiều hơn về stack và heap trong Chương 4) hoặc khi bạn muốn đảm bảo rằng bạn luôn luôn có số lượng phần tử cố định. Tuy nhiên array không linh hoạt như kiểu vector. Vector là một kiểu collection tương tự như array do thư viện chuẩn cung cấp, vector cho phép bạn tăng hoặc giảm kích thước. Nếu bạn không chắc liệu nên sử dụng array hay vector thì bạn nên sử dụng vector. Chúng ta sẽ thảo luận chi tiết hơn về vector trong Chương 8.
Tuy nhiên, array sẽ hữu ích hơn khi bạn đã biết được số lượng phần tử mà bạn cần. Ví dụ, nếu bạn sử dụng tên của các tháng trong chương trình, bạn nên sử dụng array hơn là vector bởi vì bạn biết chắc chắn rằng nó sẽ luôn luôn chứa 12 phần tử:
#![allow(unused)] fn main() { let months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]; }
Bạn viết kiểu array bằng cách sử dụng dấu ngoặc vuông với bên trong là kiểu của phần tử, dấu chấm phẩy và sau đó là số lượng phần tử trong array, như sau:
#![allow(unused)] fn main() { let a: [i32; 5] = [1, 2, 3, 4, 5]; }
Ở đây i32
là kiểu dữ liệu của tất cả phần tử. Số 5
nằm sau dấu chấm phẩy
cho biết rằng array chứ 5 phần tử.
Bạn cũng có thể tạo ra một array chứa các phần tử có cùng giá trị bằng cách chỉ định giá trị ban đầu, theo sau là dấu chấm phẩy và kế đó là độ dài của array, tất cả được đặt bên trong dấu ngoặc vuông như bên dưới:
#![allow(unused)] fn main() { let a = [3; 5]; }
Array a
sẽ chứa 5
phần tử có cùng giá trị ban đầu là
3
. Tương tự như khi chúng ta viết let a = [3, 3, 3, 3, 3];
nhưng
ngắn gọn hơn.
Truy cập các phần tử của array
Array là một đoạn bộ nhớ đơn đã biết có kích thước cố định có thể được phân bổ trên stack. Bạn có thể truy cập các phần tử của array bằng cách sử dụng chỉ mục như sau:
Filename: src/main.rs
fn main() { let a = [1, 2, 3, 4, 5]; let first = a[0]; let second = a[1]; }
Trong ví dụ này, biến first
sẽ nhận giá trị 1
, bởi vì đó
là giá trị tại chỉ mục [0]
trong array. Biến second
sẽ
nhận giá trị 2
từ chỉ mục [1]
trong array.
Truy cập phần tử array không hợp lệ
Hãy xem điều gì xảy ra nếu bạn cố gắng truy cập vào một phần tử nằm vượt quá phần cuối của array. Giả sử bạn chạy code này, tương tự như game đoán số trong Chương 2, để nhận chỉ mục array từ người dùng:
Filename: src/main.rs
use std::io;
fn main() {
let a = [1, 2, 3, 4, 5];
println!("Please enter an array index.");
let mut index = String::new();
io::stdin()
.read_line(&mut index)
.expect("Failed to read line");
let index: usize = index
.trim()
.parse()
.expect("Index entered was not a number");
let element = a[index];
println!(
"The value of the element at index {} is: {}",
index, element
);
}
Code này sẽ biên dịch thành công. Nếu bạn chạy cargo run
và nhập
0, 1, 2, 3, hoặc 4, chương trình sẽ in ra giá trị tương ứng tại chỉ
mục trong array đó. Thay vào đó nếu bạn nhập một số vượt quá phần cuối
của array, ví dụ như 10, bạn sẽ thấy đầu ra như sau:
thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Chương trình sẽ dẫn đến lỗi runtime tại điểm mà bạn sử dụng giá trị không hợp lệ
trong thao tác lập chỉ mục. Chương trình thoát ra với thông báo lỗi và không
thực thi câu lệnh println!
cuối cùng. Khi bạn cố gắng truy cập một phần tử sử dụng
lập chỉ mục, Rust sẽ kiểm tra xem chỉ mục mà bạn chỉ định có nhỏ đơn độ dài của array
hay không. Nếu chỉ mục lớn hơn hoặc bằng chiều dài của array, Rust sẽ panic.
Kiểm tra này diễn ra tại thời điểm runtime, nhất là trong trường hợp này, bởi vì
trình biên dịch không thể biết người dùng sau đó sẽ nhập giá trị nào khi họ chạy code.
Đây là một ví dụ về nguyên tắc an toàn bộ nhớ của Rust đang hoạt động. Trong nhiều ngôn ngữ cấp thấp, loại kiểm tra này không được thực hiện và khi bạn cung cấp một chỉ mục không chính xác, bộ nhớ không hợp lệ có thể được truy cập. Rust bảo vệ bạn tránh khỏi lỗi này bằng cách thoát chương trình ngay lập tức, thay vì cho phép truy cập bộ nhớ và tiếp tục chạy. Chương 9 sẽ thảo luận nhiều hơn về cách xử lý lỗi của Rust.
Hàm
Hàm phổ biến trong Rust. Bạn đã thấy một trong những hàm quan trọng nhất trong ngôn
ngữ này: đó là hàm main
. Bạn cũng thấy từ khóa fn
giúp cho phép bạn khai báo
hàm mới.
Rust sử dụng quy tắc con rắn (snake case) làm quy ước cách đặt tên hàm và biến, trong đó tất cả các chữ cái phải viết thường và phân cách các từ bằng dấu gạch dưới. Bên dưới là một chương trình ví dụ về cách định nghĩa hàm:
Filename: src/main.rs
fn main() { println!("Hello, world!"); another_function(); } fn another_function() { println!("Another function."); }
Chúng ta định nghĩa hàm trong Rust bằng cách gõ từ khóa fn
theo sau là
tên của hàm và một cặp dấu ngoặc đơn. Cặp dấu ngoặc nhọn cho trình biên dịch
biết vị trí bắt đầu và kết thúc của thân hàm.
Chúng ta có thể gọi bất kỳ hàm nào đã được định nghĩa bằng cách gõ tên hàm theo sau
là cặp dấu ngoặc tròn. Do hàm another_function
đã được định nghĩa trong chương trình,
bạn có thể gọi hàm này từ bên trong hàm main
. Lưu ý rằng chúng ta đã định nghĩa hàm another_function
sau hàm main
trong code; chúng ta cũng có thể định nghĩa nó trước hàm main
.
Rust không quan tâm bạn định nghĩa hàm ở đâu, Rust chỉ quan tâm hàm đã được định
hay chưa.
Hãy bắt đầu một dự án nhị phân có tên functions để khám phá thêm về
hàm. Lấy ví dụ hàm another_function
cho vào src/main.rs và khởi chạy chương trình.
Bạn sẽ thấy kết quả như bên dưới:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished dev [unoptimized + debuginfo] target(s) in 0.28s
Running `target/debug/functions`
Hello, world!
Another function.
Các dòng thực thi theo thứ tự xuất hiện trong hàm main
.
Đầu tiên, thông điệp “Hello, world!” được in ra, sau đó gọi hàm another_function
và in thông điệp của nó ra.
Tham số
Chúng ta có thể định nghĩa các hàm có các tham số - đây là những biến đặc biệt là một phần của chữ ký hàm. Khi một hàm có tham số đi kèm, bạn có thể cung cấp cho nó các giá trị tham số cụ thể. Về mặt kỹ thuật, các giá trị cụ thể này được gọi là đối số (arguments), nhưng trong giao tiếp thông thường, mọi người có xu hướng sử dụng từ tham số (parameter) và đối số (argument) thay thế cho nhau cho các biến trong định nghĩa hàm hoặc giá trị cụ thể được chuyển vào khi bạn gọi hàm.
Trong phiên bản này của hàm another_function
, chúng ta thêm một tham số vào:
Filename: src/main.rs
fn main() { another_function(5); } fn another_function(x: i32) { println!("The value of x is: {}", x); }
Thử khởi chạy chương trình; bạn sẽ nhận được kết quả sau:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished dev [unoptimized + debuginfo] target(s) in 1.21s
Running `target/debug/functions`
The value of x is: 5
Khi khai báo hàm another_function
, chúng ta có một tham số tên x
. Kiểu của
x
được chỉ định là i32
. Khi chúng ta chuyển giá trị 5
vào hàm another_function
,
println!
macro sẽ đặt 5
vào vị trí của cặp dấu ngoặc nhọn để định dạng thành
string.
Trong chữ ký hàm, bạn buộc phải khai báo kiểu của mọi tham số. Đây là một quyết định có chủ ý trong thiết kế của Rust: việc yêu cầu chú thích kiểu dữ liệu trong định nghĩa hàm có nghĩa là trình biên dịch sẽ không bao giờ yêu cầu bạn khai báo kiểu dữ liệu ở bất kỳ nơi khác trong code để tìm ra kiểu dữ liệu mà bạn muốn nói đến.
Khi bạn định nghĩa hàm với nhiều tham số, phân cách việc khai báo tham số bằng dấu phẩy như sau:
Filename: src/main.rs
fn main() { print_labeled_measurement(5, 'h'); } fn print_labeled_measurement(value: i32, unit_label: char) { println!("The measurement is: {}{}", value, unit_label); }
Ví dụ này tạo ra một hàm có tên print_labeled_measurement
với hai
tham số. Tham số thứ nhất có tên value
và có kiểu i32
. Tham số thứ hai có tên
unit_label
và có kiểu char
. Sau đó hàm in ra đoạn văn bản chứa cả
value
và unit_label
.
Hãy thử khởi chạy code. Thay thế ví dụ vừa rồi vào file
src/main.rs của dự án functions và khởi chạy nó với cargo run
:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished dev [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/functions`
The measurement is: 5h
Bởi vì chúng ta đã gọi hàm với giá trị của value
là 5
và unit_label
là 'h'
,
đầu ra của chương trình sẽ chứa các giá trị đó.
Câu lệnh và Biểu thức
Thân hàm được tạo thành từ một loạt các câu lệnh tùy ý kết thúc bằng một biểu thức. Cho đến bây giờ, các hàm mà chúng ta đã đề cập chưa có hàm nào kết bằng một biểu thức, nhưng bạn đã thấy biểu thức như một phần của câu lệnh. Bởi vì Rust là một ngôn ngữ dựa trên biểu thức, bạn cần hiểu về sự phân biệt quan trọng này. Những ngôn ngữ khác không có sự phân biệt giống như vậy, vì vậy hãy xem xét câu lệnh và biểu thức là gì và sự khác biệt của chúng ảnh hưởng như thế nào đến nội dung của hàm.
Câu lệnh (Statements) là các hướng dẫn thực hiện một số hành động và không trả về giá trị. Biểu thức (Expressions) tính toán để đưa ra một giá trị kết quả. Hãy xem xét một vài ví dụ.
Chúng ta đã thực sự sử dụng câu lệnh và biểu thức. Tạo một biến và gán một giá trị
cho nó với từ khóa let
là một câu lệnh. Trong Listing 3-1,
let y = 6;
là một câu lệnh.
Filename: src/main.rs
fn main() { let y = 6; }
Listing 3-1: A main
function declaration containing one statement
Việc định nghĩa một hàm cũng là một câu lệnh; toàn bộ ví dụ trước là một câu lệnh.
Câu lệnh không trả về giá trị. Do đó, bạn không thể gán một câu lệnh let
statement
vào một biến khác, bạn sẽ gặp lỗi nếu cố gắng làm như đoạn code bên dưới:
Filename: src/main.rs
fn main() {
let x = (let y = 6);
}
Khi bạn chạy chương trình, bạn sẽ bắt gặp lỗi như thế này:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found statement (`let`)
--> src/main.rs:2:14
|
2 | let x = (let y = 6);
| ^^^^^^^^^
|
= note: variable declaration using `let` is a statement
error[E0658]: `let` expressions in this position are experimental
--> src/main.rs:2:14
|
2 | let x = (let y = 6);
| ^^^^^^^^^
|
= note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
= help: you can write `matches!(<expr>, <pattern>)` instead of `let <pattern> = <expr>`
warning: unnecessary parentheses around assigned value
--> src/main.rs:2:13
|
2 | let x = (let y = 6);
| ^ ^
|
= note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
|
2 - let x = (let y = 6);
2 + let x = let y = 6;
|
For more information about this error, try `rustc --explain E0658`.
warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` due to 2 previous errors; 1 warning emitted
Câu lệnh let y = 6
không trả về một giá trị, do đó không có bất kỳ giá trị nào
được gán cho x
. Điều này khác biệt với những gì xảy ra trong các ngôn ngữ khác,
như C và Ruby, trong đó phép gán trả về giá trị của phép gán đó. Trong những
ngôn ngữ này, bạn có thể viết x = y = 6
, cả x
và y
đều sẽ có giá trị là
6
; nhưng Rust thì không hiểu như vậy.
Biểu thức tính toán đưa ra một giá trị và tạo nên gần như toàn bộ phần còn lại của code mà
bạn viết bằng Rust. Xét về một phép toán số học như 5 + 6
, đó là một
biểu thức sẽ đưa ra kết quả là 11
. Biểu thức có thể là một phần của câu
lệnh: trong Listing 3-1, giá trị 6
trong câu lệnh let y = 6;
là một
biểu thức đưa ra giá trị là 6
. Việc gọi một hàm cũng là một biểu
thức. Gọi một macro là một biểu thức. Một khối phạm vi mới được tạo ra bằng
dấu ngoặc nhọn là một biểu thức, ví dụ:
Filename: src/main.rs
fn main() { let y = { let x = 3; x + 1 }; println!("The value of y is: {}", y); }
Biểu thức này:
{
let x = 3;
x + 1
}
trong trường hợp này là một khối sẽ đưa ra giá trị là 4
. Giá trị đó được gán vào y
như một phần của câu lệnh let
. Lưu ý rằng dòng x + 1
không có dấu chấm phẩy ở
cuối câu, không giống như hầu hết các dòng code bạn đã thấy cho đến nay. Các biểu thức
không kết thúc bằng dấu chấm phẩy. Nếu bạn thêm dấu chấm phẩy vào cuối biểu thức, nó sẽ
trở thành một câu lệnh và câu lệnh thì không trả về giá trị.
Hãy nhớ điều này khi bạn tìm hiểu về các hàm trả về giá trị và biểu thức ở phần kế tiếp.
Hàm trả về giá trị
Hàm có thể trả về các giá trị cho code khi chúng được gọi. Chúng ta không đặt tên
giá trị trả về, nhưng chúng ta buộc phải khai báo kiểu dữ liệu của chúng sau dấu mũi
tên (->
). Trong Rust, giá trị trả về của hàm đồng nghĩa với giá trị của biểu
thức cuối cùng trong phần thân hàm. Bạn có thể trả về sớm giá trị của hàm bằng việc
sử dụng từ khóa return
và chỉ định giá trị trả về, nhưng trong hầu hết các hàm
sẽ ngầm định trả về biểu thức cuối cùng. Dưới đây là một ví dụ về một hàm
trả về giá trị:
Filename: src/main.rs
fn five() -> i32 { 5 } fn main() { let x = five(); println!("The value of x is: {}", x); }
Không có gọi hàm, macros, hay thậm chí câu lệnh let
trong hàm five
— chỉ có duy nhất số 5
. Đó là một hàm hợp lệ trong Rust.
Lưu ý rằng phải biết được kiểu dữ liệu trả về của hàm như -> i32
. Hãy
khởi chạy code này; đầu ra sẽ như thế này:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished dev [unoptimized + debuginfo] target(s) in 0.30s
Running `target/debug/functions`
The value of x is: 5
Số 5
trong hàm five
là giá trị trả về của hàm, đó là lý do tại sao kiểu
dữ liệu trả về là i32
. Hãy xem xét điều này chi tiết hơn. Có 2 bits quan trọng:
đầu tiên, dòng lệnh let x = five();
cho biết rằng bạn đang sử dụng giá trị trả về
của hàm để khởi tạo ra một biến. Bởi vì hàm five
trả về giá trị 5
,
dòng lệnh đó tương đương với dòng lệnh bên dưới:
#![allow(unused)] fn main() { let x = 5; }
Thứ hai, hàm five
không có tham số và hàm xác định kiểu dữ liệu của giá trị
trả về, nhưng trong phần thân hàm chỉ có số 5
không có dấu chấm phẩy
bởi vì nó là một biểu thức chứa giá trị mà chúng ta muốn trả về.
Hãy xem xét một ví dụ khác:
Filename: src/main.rs
fn main() { let x = plus_one(5); println!("The value of x is: {}", x); } fn plus_one(x: i32) -> i32 { x + 1 }
Code này sẽ in ra The value of x is: 6
. Nhưng nếu chúng ta đặt dấu chấm phẩy
vào cuối dòng chứa x + 1
, nó sẽ từ biểu thức chuyển thành câu lệnh,
chúng ta sẽ gặp lỗi ngay.
Filename: src/main.rs
fn main() {
let x = plus_one(5);
println!("The value of x is: {}", x);
}
fn plus_one(x: i32) -> i32 {
x + 1;
}
Biên dịch code này sẽ gây ra lỗi như sau:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
--> src/main.rs:7:24
|
7 | fn plus_one(x: i32) -> i32 {
| -------- ^^^ expected `i32`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
8 | x + 1;
| - help: consider removing this semicolon
For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` due to previous error
Thông báo lỗi chính, “mismatched types,” cho thấy vấn đề cốt lõi trong
code. Định nghĩa hàm plus_one
nói rằng nó sẽ trả về một giá trị
i32
, nhưng câu lệnh không trả về giá trị được biểu thị bằng ()
,
unit type. Do đó, không có gì để trả về, điều này mẫu thuẫn với định nghĩa
của hàm và dẫn đến lỗi. Trong đầu ra này, Rust đưa ra một thông báo để có thể
giúp khắc phục vấn đề này: Rust đề xuất loại bỏ dấu chấm phẩy để khắc phục
lỗi.
Chú thích (Comments)
Tất cả lập trình viên đều cố gắng làm cho code dễ hiểu, nhưng đôi khi cần những lời giải thích thêm. Trong các trường hợp này, lập trình viên sẽ để lại comments trong code, trình biên dịch sẽ bỏ qua các comment này nhưng chúng lại có thể có ích cho những ai đọc code.
Đây là một comment đơn giản:
#![allow(unused)] fn main() { // hello, world }
Trong Rust, comment bắt đầu với hai dấu gạch chéo và kéo dài cho đến cuối
dòng. Đối với các comment vượt quá một dòng, bạn sẽ cần viết thêm //
ở
mỗi dòng như thế này:
#![allow(unused)] fn main() { // So we’re doing something complicated here, long enough that we need // multiple lines of comments to do it! Whew! Hopefully, this comment will // explain what’s going on. }
Comments cũng có thể được đặt ở cuối dòng chứa mã code:
Filename: src/main.rs
fn main() { let lucky_number = 7; // I’m feeling lucky today }
Nhưng bạn sẽ thường xuyên thấy chúng ở định dạng comment ở trên một dòng riêng biệt với code cần chú thích:
Filename: src/main.rs
fn main() { // I’m feeling lucky today let lucky_number = 7; }
Rust cũng có một loại comment khác, documentation comments, chúng ta sẽ thảo luận về nó trong phần “Publishing a Crate to Crates.io” ở Chương 14.
Luồng điều khiển (Control Flow)
Luồng điều khiển sẽ quyết định cách code của chúng ta được hoạt động như thế nào.
Các cấu trúc phổ biến nhất cho phép bạn kiểm soát luồng thực thi code
của Rust là biểu thức if
và vòng lặp (loops).
Biểu thức if
Biểu thức if
cho phép bạn phân nhánh code phụ thuộc vào các điều kiện. Bạn
đưa ra một điều kiện, sau đó yêu cầu: “Nếu thỏa mãn điều kiện này, hãy chạy code
này. Nếu điều kiện này không thỏa mãn, không chạy code này.”
Khởi tạo một dự án mới có tên branches trong thư mực projects của bạn để
tìm hiểu về biểu thức if
. Trong file src/main.rs, hãy nhập code như bên dưới:
Filename: src/main.rs
fn main() { let number = 3; if number < 5 { println!("condition was true"); } else { println!("condition was false"); } }
Tất cả biểu thức if
bắt đầu với từ khóa if
, theo sau là một điều kiện. Trong
trường hợp này, điều kiện sẽ kiểm tra xem liệu biến number
có giá trị nhỏ hơn
5 hay không. Ngay sau điều kiện, bên trong cặp dấu ngoặc nhọn, chúng ta viết code
cần thực thi nếu điều kiện đúng. Đoạn code liên kết với điều kiện trong biểu thức
if
thường được gọi là nhánh (arms), giống như arms trong biểu thức
match
mà chúng ta đã đề cập trong phần “So sánh số dự đoán với số bí
mật” ở Chương 2.
Chúng ta cũng có thể tùy ý bao gồm thêm biểu thức else
, như chúng ta đã làm
ở đây, để cung cấp cho chương trình một đoạn code thay thế khác để thực thi nếu điều
kiện sai. Nếu bạn không cung cấp biểu thức else
và điều kiện không thỏa mãn,
chương trình sẽ bỏ qua đoạn code chứa if
và chuyển sang đoạn code tiếp theo.
Hãy thử chạy code này; bạn sẽ nhận được kết quả như sau:
$ cargo run
Compiling branches v0.1.0 (file:///projects/branches)
Finished dev [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/branches`
condition was true
Hãy thử thay đổi giá trị của biến number
thành một giá trị làm cho điều kiện
sai
để xem điều gì xảy ra:
fn main() {
let number = 7;
if number < 5 {
println!("condition was true");
} else {
println!("condition was false");
}
}
Chạy chương trình một lần nữa và xem kết quả:
$ cargo run
Compiling branches v0.1.0 (file:///projects/branches)
Finished dev [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/branches`
condition was false
Cũng cần lưu ý rằng điều kiện trong code phải là bool
. Nếu điều kiện
không phải là bool
, chúng ta sẽ gặp lỗi. Ví dụ, bạn hãy thử chạy đoạn code
sau đây:
Filename: src/main.rs
fn main() {
let number = 3;
if number {
println!("number was three");
}
}
Lần này điều kiện if
có giá trị là 3
và Rust đưa ra
lỗi:
$ cargo run
Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
--> src/main.rs:4:8
|
4 | if number {
| ^^^^^^ expected `bool`, found integer
For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error
Lỗi chỉ ra rằng Rust mong đợi bool
nhưng lại nhận được số nguyên. Không giống
như các ngôn ngữ khác như Ruby và JavaScript, Rust sẽ không tự động chuyển đổi
các kiểu dữ liệu không phải Boolean sang Boolean. Bạn phải rõ ràng và luôn luôn
cung cấp Boolean cho câu điều kiện if
. Ví dụ, nếu bạn muốn đoạn code if
chỉ
chạy khi một số khác 0
, chúng ta có thể thay đổi biểu thức if
như sau:
Filename: src/main.rs
fn main() { let number = 3; if number != 0 { println!("number was something other than zero"); } }
Khởi chạy đoạn code này sẽ in ra number was something other than zero
.
Xử lý nhiều điều kiện với else if
Bạn có thể so sánh nhiều điều kiện bằng cách kết hợp if
và else
trong biểu thức else if
Ví dụ như:
Filename: src/main.rs
fn main() { let number = 6; if number % 4 == 0 { println!("number is divisible by 4"); } else if number % 3 == 0 { println!("number is divisible by 3"); } else if number % 2 == 0 { println!("number is divisible by 2"); } else { println!("number is not divisible by 4, 3, or 2"); } }
Chương trình này có 4 điều kiện có thể thực hiện. Sau khi chạy code, bạn sẽ thấy kết quả như bên dưới:
$ cargo run
Compiling branches v0.1.0 (file:///projects/branches)
Finished dev [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/branches`
number is divisible by 3
Khi thực thi chương trình, Rust sẽ kiểm tra lần lượt mỗi biểu thức if
và
thực thi đoạn code đầu tiên mà điều kiện thỏa mãn. Lưu ý rằng 6 chia hết cho
2, chúng ta không thấy kết quả đầu ra là đoạn text number is divisible by 2
cũng như đoạn text number is not divisible by 4, 3, or 2
từ else
.
Bởi vì Rust chỉ thực thi đoạn code cho điều kiện đúng đầu tiên và nó sẽ
bỏ qua phần code còn lại.
Sử dụng quá nhiều biểu thức else if
có thể làm lộn xộn code của bạn, vì vậy nếu
bạn có nhiều hơn một biểu thức, bạn có thể cần tái cấu trúc lại code của mình.
Chương 6 giới thiệu một cấu trúc phân nhánh mạnh mẽ, match
, cho các trường hợp này.
Sử dụng if
trong câu lệnh let
Bởi vì if
là một biểu thức, chúng ta có thể sử dụng nó bên phải câu lệnh let
để giá kết quả cho biến, như trong Listing 3-2.
Filename: src/main.rs
fn main() { let condition = true; let number = if condition { 5 } else { 6 }; println!("The value of number is: {}", number); }
Listing 3-2: Gán kết quả của biểu thức if
cho một biến
Biến number
sẽ được gán với giá trị dựa vào kết quả của biểu thức if
.
Hãy chạy đoạn code này để xem điều gì xảy ra:
$ cargo run
Compiling branches v0.1.0 (file:///projects/branches)
Finished dev [unoptimized + debuginfo] target(s) in 0.30s
Running `target/debug/branches`
The value of number is: 5
Hãy nhớ rằng đoạn code đánh giá đến biểu thức cuối cùng và các số cũng bản thân nó
cũng là biểu thức. Trong trường hợp này, giá trị của toàn bộ biểu thức
if
phụ thuộc vào đoạn code mà nó thực thi. Điều này có nghĩa là các giá trị
của mỗi nhánh if
phải có kiểu dữ liệu giống nhau; trong Listing 3-2, kết quả
từ cả nhánh if
và nhánh else
đều là số nguyên i32
. Nếu kiểu dữ liệu không khớp,
bạn sẽ gặp lỗi như trong ví dụ dưới đây:
Filename: src/main.rs
fn main() {
let condition = true;
let number = if condition { 5 } else { "six" };
println!("The value of number is: {}", number);
}
Khi bạn biên dịch code này, bạn sẽ gặp lỗi. Nhánh if
và else
có kiểu giá trị
không tương thích và Rust chỉ ra chính xác vị trí vấn đề trong chương trình:
$ cargo run
Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
--> src/main.rs:4:44
|
4 | let number = if condition { 5 } else { "six" };
| - ^^^^^ expected integer, found `&str`
| |
| expected because of this
For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error
Biểu thức trong khối if
đưa ra một số nguyên và biểu thức trong khối
else
đưa ra một string. Điều này sẽ không thực hiện được bởi vì các biến
phải có một kiểu duy nhất và Rust cần biết tại thời điểm biên dịch biến
number
có kiểu gì. Biết được kiểu của number
cho phép trình biên dịch
xác minh kiểu đó hợp lệ ở mọi chỗ khi chúng ta sử dụng number
. Rust không thể
làm điều đó nếu kiểu của number
chỉ được xác định tại thời điểm runtime; trình
biên dịch sẽ phức tạp hơn và sẽ ít đảm bảo hơn về code nếu nó phải theo dõi
nhiều kiểu giả định cho bất kỳ biến nào.
Lặp lại với các vòng lặp (Loops)
Việc thực thi một đoạn code nhiều lần sẽ rất hữu ích. Để làm điều này, Rust cung cấp một số vòng lặp (loop), vòng lặp này sẽ chạy code bên trong thân của vòng lặp từ đầu đến cuối và sau đó ngay lập tức bắt đầu lại từ đầu. Để trải nghiệm với vòng lặp, hãy khởi tạo một dự án mới có tên loops.
Rust có 3 loại vòng lặp: loop
, while
, và for
. Hãy thử từng loại.
Lặp lại code với loop
Từ khóa loop
yêu cầu Rust thực thi một đoạn code lặp đi lặp lại mãi mãi
hoặc cho đến khi bạn yêu cầu nó dừng lại.
Ví dụ, thay đổi file src/main.rs trong thư mục loops như bên dưới:
Filename: src/main.rs
fn main() {
loop {
println!("again!");
}
}
Khi bạn chạy chương trình này, bạn sẽ thấy kết quả again!
được in liên tục
cho đến khi chúng ta dừng chương trình một cách thủ công. Hầu hết terminal
hỗ trợ phím tắt ctrl-c để ngắt một chương trình
bị mắc kẹt trong một vòng lặp liên tục. Hãy thử một lần:
$ cargo run
Compiling loops v0.1.0 (file:///projects/loops)
Finished dev [unoptimized + debuginfo] target(s) in 0.29s
Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!
Ký hiệu ^C
thể hiện vị trí bạn nhấn ctrl-c
. Bạn có thể gặp lại từ again!
này hoặc không được in ra sau ^C
,
phụ thuộc vào vị trí của code trong vòng lặp khi nó nhận được tín hiệu
ngắt.
May mắn thay, Rust cũng cung cấp một cách để thoát khỏi vòng lặp bằng cách sử dụng code.
Bạn có thể đặt từ khóa break
trong vòng lặp để cho chương trình biết khi nào nên dừng
thực hiện vòng lặp. Chúng ta đã làm điều này trong trò chơi đoán số trong phần
“Thoát ra sau khi đoán đúng” ở Chương 2 để thoát khỏi chương trình khi người dùng đoán đúng con số bí mật.
Chúng ta cũng đã dùng continue
trong trò chơi đoán số, trong vòng lặp continue
sẽ yêu cầu
chương trình bỏ qua đoạn code còn lại trong lần lặp này của vòng lặp và đi
đến vòng lặp tiếp theo.
Nếu bạn có vòng lặp lồng bên trong vòng lặp, break
và continue
áp dụng cho vòng
lặp trong cùng tại điểm đó. Bạn có thể tùy chọn chỉ định gắn nhãn cho vòng lặp, chúng ta có thể
sử dụng break
hoặc continue
để chỉ định rằng các từ khóa đó sẽ áp dụng cho vòng
lặp nào được gắn nhãn thay vì vòng lặp trong cùng. Dưới đây là một ví dụ về hai
vòng lặp lồng nhau:
fn main() { let mut count = 0; 'counting_up: loop { println!("count = {}", count); let mut remaining = 10; loop { println!("remaining = {}", remaining); if remaining == 9 { break; } if count == 2 { break 'counting_up; } remaining -= 1; } count += 1; } println!("End count = {}", count); }
Vòng lặp bên ngoài có nhãn 'counting_up
và nó sẽ đếm từ 0 đến 2.
Vòng lặp bên trong không có nhãn đếm ngược từ 10 đến 9. Câu lệnhbreak
đầu tiên
không chỉ định nhãn của vòng lặp nên sẽ chỉ thoát khỏi vòng lặp bên trong. Câu lệnh break 'counting_up;
sẽ thoát khỏi vòng lặp ngoài. Code này sẽ in ra:
$ cargo run
Compiling loops v0.1.0 (file:///projects/loops)
Finished dev [unoptimized + debuginfo] target(s) in 0.58s
Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2
Trả về giá trị từ vòng lặp
Một trong các cách sử dụng vòng lặp
là thử một phép toán mà bạn biết có thể nó
sẽ thất bại, chẳng hạn như kiểm tra xem một luồng có hoàn thành công việc hay không.
Bạn cũng có thể cần chuyển kết quả của phép toán đó ra khỏi vòng lặp đến phần còn lại
của code. Để làm điều này, bạn có thể thêm giá trị bạn muốn trả về sau biểu thức break
mà bạn sử dụng để dừng vòng lặp; giá trị đó sẽ được trả về khỏi vòng lặp và do đó bạn
có thể sử dụng giá trị đó như được hiển thị ở đây:
fn main() { let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } }; println!("The result is {}", result); }
Trước vòng lặp, chúng ta khai báo một biến có tên counter
và gán cho nó giá trị
0
. Sau đó chúng ta khai báo một biến có tên result
để chứa giá trị mà vòng lặp
trả về. Trên mỗi lần lặp của vòng lặp, chúng ta cộng 1
vào biến counter
và sau
đó kiểm tra xem liệu counter bằng 10
hay không. Khi nó thỏa mãn điều kiện, chúng ta
sử dụng từ khóa break
với counter * 2
. Sau vòng lặp, chúng ta sử dụng dấu chấm phẩy
để kết thúc câu lệnh gán giá trị vào biến result
. Cuối cùng, chúng ta in ra giá trị
của result
, trong trường hợp này là 20.
Vòng lặp có điều kiện với while
Một chương trình sẽ thường cần đánh giá một điều kiện bên trong vòng lặp. Trong
khi điều kiện là đúng, vòng lặp sẽ chạy. Khi điều kiện không còn đúng nữa, chương
trình sẽ gọi break
để dừng vòng lặp. Có thể triển khai hành vi như vậy bằng cách
sử dụng kết hợp loop
, if
, else
và break
; bạn có thể thử điều đó trong một
chương trình ngay nếu bạn muốn. Tùy nhiên, mẫu này phổ biến đến mức Rust đã xây dựng
một cấu trúc cho nó gọi là vòng lặp while
. Trong Listing 3-3, chúng ta sử dụng while
để lặp lại chương trình ba lần, mỗi lần lặp đếm ngược, in ra một thông báo và thoát
Filename: src/main.rs
fn main() { let mut number = 3; while number != 0 { println!("{}!", number); number -= 1; } println!("LIFTOFF!!!"); }
Listing 3-3: Sử dụng vòng lặp while
để chạy code
trong khi điều kiện đúng
Cấu trúc này loại bỏ nhiều lồng ghép cần thiết nếu bạn sử dụng
loop
, if
, else
và break
và nó rõ ràng hơn nhiều. Trong khi
một điều kiện đúng, code sẽ hoạt động; nếu không nó sẽ thoát vòng lặp.
Vòng lặp cho Collection với for
Bạn có thể sử dụng cấu trúc while
để lặp qua các phần tử của một
collection, chẳng hạn như array. Ví dụ, vòng lặp trong Listing 3-4 in ra
từng phần tử trong array a
.
Filename: src/main.rs
fn main() { let a = [10, 20, 30, 40, 50]; let mut index = 0; while index < 5 { println!("the value is: {}", a[index]); index += 1; } }
Listing 3-4: Lặp qua từng phần tử của một collection
sử dụng vòng lặp while
Ở đây, code sẽ đếm lên thông qua các phần tử trong array. Nó bắt đầu ở chỉ mục
0
và sau đó lặp lại cho đến chỉ mục cuối cùng trong array (đó là khi
index < 5
không còn đúng nữa). Khởi chạy code này, nó sẽ in ra mọi phần tử
trong array:
$ cargo run
Compiling loops v0.1.0 (file:///projects/loops)
Finished dev [unoptimized + debuginfo] target(s) in 0.32s
Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50
Tất cả năm giá trị của array đều xuất hiện trong terminal như mong đợi. Mặc dù index
sẽ đạt giá trị 5
tại một số thời điểm , vòng lặp dừng thực thi trước khi cố gắng
tìm nạp giá trị thứ sáu từ array.
Tuy nhiên, các tiếp cận này dễ xảy ra lỗi; chúng ta có thể làm chương trình panic nếu
giá trị chỉ mục hoặc điều kiện kiểm tra không đúng. Ví dụ nếu bạn thay đổi định nghĩa
của array a
chỉ có bốn phần tử nhưng quên cập nhật điều kiện thành
while index < 4
, code khi đó sẽ panic. Nó cũng chậm bởi vì trình biên dịch thêm
runtime code để thực hiện kiểm tra có điều kiện liệu chỉ mục có nằm trong giới hạn
của array trên mỗi lần lặp qua vòng lặp hay không.
Để thay thế ngắn gọn hơn, bạn có thể sử dụng vòng lặp for
và thực thi code cho mỗi
item trong collection. Vòng lặp for
trong giống như code trong Listing 3-5.
Filename: src/main.rs
fn main() { let a = [10, 20, 30, 40, 50]; for element in a { println!("the value is: {}", element); } }
Listing 3-5: Lặp qua từng phần tử của collection
sử dụng vòng lặp for
Khi chúng ta sử dụng đoạn code này, chúng ta sẽ nhận được kết quả giống hệt như trong Listing 3-4. Quan trọng hơn, chúng ta có thể tăng tính an toàn của code và loại bỏ khả năng lỗi từ việc vượt qua phần tử cuối của array hoặc lặp không hết và thiếu sót một vài item.
Sử dụng vòng lặp for
, bạn sẽ không cần phải thay đổi code nếu bạn thay đổi số lượng phần
tử của array như với phương pháp mà bạn sử dụng trong Listing 3-4.
Tính an toàn và độ ngắn gọn của vòng lặp for
khiến chúng trở thành cấu trúc vòng lặp
được sử dụng phổ biến trong Rust. Ngay cả trong các tình huống bạn muốn chạy code một
số lần nhất định, như ví dụ đếm ngược đã sử dụng vòng lặp while
trong
Listing 3-3, phần lớn Rustaceans sẽ sử dụng vòng lặp for
. Các để làm điều đó là sử
dụng phạm vi (Range)
, được cung cấp bởi thư viện chuẩn, tạo ra tất cả các số theo
thứ tự bắt đầu từ một số và kết thúc trước một số khác.
Dưới đây là cách đếm ngược sử dụng vòng lặp for
và một phương thức khác mà
chúng ta chưa đề cập đến, rev
, để đảo ngược phạm vi:
Filename: src/main.rs
fn main() { for number in (1..4).rev() { println!("{}!", number); } println!("LIFTOFF!!!"); }
Code này đẹp hơn một chút rồi phải không?
Tóm tắt
Bạn đã làm được! Đây là một chương khá lớn: bạn đã học về biến, kiểu dữ liệu vô
hướng và kết hợp, hàm, comments, biểu thức if
và vòng lặp!
Để thực hành các khái niệm này, hãy thử xây dựng chương trình để thực hiện những
điều sau:
- Chuyển đổi nhiệt độ giữa Fahrenheit và Celsius.
- Tạo ra số Fibonacci thứ n.
- In lời bài hát mừng Giáng sinh “The Twelve Days of Christmas,” tận dụng sự lặp lại trong bài hát.
Khi bạn đã sẵn sàng để tiếp tục, chúng ta sẽ nói về một khái niệm trong Rust không thường tồn tại trong các ngôn ngữ lập trình khác: quyền sở hữu (ownership).
Understanding Ownership
Ownership (Quyền sở hữu) là tính năng độc đáo nhất của Rust và có ý nghĩa sâu sắc đối với phần còn lại của ngôn ngữ. Nó cho phép Rust đảm bảo an toàn cho bộ nhớ mà không cần bộ thu gom rác (garbage collector), vì vậy điều quan trọng là phải hiểu cách thức hoạt động của Ownership. Chúng ta sẽ nói về ownership cũng như một số tính năng liên quan: borrowing (nguyên lý mư mượn), slices (chuỗi các thành phần liên tiếp trong bộ nhớ), và cách Rust đưa dữ liệu ra ngoài trong bộ nhớ.
What Is Ownership?
Một số thuật ngữ:
- ownership:
- scope: phạm vi, tầm vực
- stack và heap: vùng bộ nhớ trong máy tính lưu trữ biến
Ownership là một tập hợp các quy tắc chi phối cách một chương trình Rust quản lý bộ nhớ. Tất cả các chương trình phải quản lý cách chúng sử dụng bộ nhớ của máy tính khi chạy. Một số ngôn ngữ có garbage collection (bộ thu thập rác) liên tục tìm kiếm bộ nhớ không còn được sử dụng khi chương trình chạy; trong các ngôn ngữ khác, lập trình viên phải cấp phát và giải phóng bộ nhớ một cách rõ ràng. Rust sử dụng cách tiếp cận thứ ba: bộ nhớ được quản lý thông qua một hệ thống sở hữu (system of ownership) với một tập hợp các quy tắc mà trình biên dịch kiểm tra khi biên dịch. Nếu bất kỳ quy tắc nào bị vi phạm, chương trình sẽ không biên dịch. Không có tính năng nào của ownership sẽ làm chậm chương trình của bạn khi nó đang chạy.
Vì ownership là một khái niệm mới đối với nhiều lập trình viên, nên nó cần một chút thời gian để làm quen. Tin tốt là bạn càng có nhiều kinh nghiệm hơn với Rust và các quy tắc của hệ thống sở hữu (ownership system) hơn, bạn càng thấy dễ dàng hơn khi phát triển code an toàn và hiệu quả một cách tự nhiên. Hãy kiên trì!
Khi bạn hiểu ownership, bạn sẽ có một nền tảng vững chắc để hiểu các tính năng làm cho Rust trở nên độc đáo. Trong chương này, bạn sẽ học ownership bằng cách làm việc thông qua một số ví dụ tập trung vào cấu trúc dữ liệu rất phổ biến: chuỗi (strings).
Stack và Heap
Nhiều ngôn ngữ lập trình không yêu cầu bạn phải nghĩ về stack và heap thường xuyên. Nhưng trong một ngôn ngữ lập trình hệ thống như Rust, việc một giá trị nằm trên stack hoặc sẽ ảnh hưởng đến cách ngôn ngữ hoạt động và tại sao bạn phải đưa ra những quyết định nhất định. Các phần của ownership sẽ được mô tả liên quan đến stack và heap ở phần sau của chương này, vì vậy đây là một lời giải thích ngắn gọn trong quá trình chuẩn bị.
Cả stack và heap đều là những phần bộ nhớ có sẵn cho code của bạn để sử dụng trong runtime, nhưng chúng được cấu trúc theo những cách khác nhau. Stack lưu trữ lưu trữ các giá trị theo thứ tự mà nó nhận được và xóa các giá trị theo thứ tự ngược lại. Điều này được gọi là last in, first out (Vào sau, ra trước). Hãy nghĩ về một chồng đĩa: Khi bạn thêm nhiều đĩa, bạn đặt chúng lên trên đầu và khi bạn cần một chiếc đĩa, bạn lấy một cái trên đầu ra. Thêm hoặc xóa các đĩa ở giữa hoặc dưới cùng cũng sẽ không hoạt động! Thêm dữ liệu được gọi là pushing onto the stack, và xóa dữ liệu được gọi là popping off the stack. Tất cả dữ liệu được lưu trữ trên stack phải có kích thước cố định (fixed size), đã biết. Thay vào đó dữ liệu có kích thước không xác định (unknown size) tại thời điểm biên dịch hoặc kích thước có thể thay đổi phải được lưu trữ trên heap.
Heap ít được tổ chức hơn: khi bạn đặt dữ liệu trên heap, bạn gửi yêu cầu một khoảng trống nhất định trong bộ nhớ. Bộ cấp phát bộ nhớ tìm thấy một chỗ trống trên heap đủ lớn, đánh dấu nó là đang được sử dụng, và trả về một con trỏ, đó là địa chỉ cuả vị trí đó. Quá trình này được gọi là allocating on the heap (cấp phát trên heap) và đôi khi được viết tắt là allocating (việc đẩy các giá trị vào stack không được coi là cấp phát). Vì con trỏ tới heap có kích thước cố định (fixed size) và đã biết, bạn có thể lưu trữ con trỏ trên stack, nhưng khi bạn muốn dữ liệu thực sự, bạn phải đi theo con trỏ. Hãy nghĩ đến việc tìm chỗ ngồi tại một nhà hàng. Khi bạn tới đó, bạn sẽ cần nói số người trong nhóm của bạn, và nhần viên sẽ tìm một bàn trống đủ chỗ cho mọi người và dẫn bạn tới đó. Nếu ai đó trong nhóm của bạn đến muộn, họ có thể hỏi chỗ ngồi của bạn ở đâu để tìm.
Đẩy dữ liệu vào stack nhanh hơn là cấp phát trên heap vì bộ cấp phát không bao giờ phải tìm kiếm một nơi để lưu dữ liệu mới; vị trí đó luôn ở trên cùng của stack. Tương tự, việc phân bổ không gian trên heap đòi hỏi nhiều công việc hơn, bởi vì bộ cấp phát trước tiên phải tìm một không gian đủ lớn để chứa dữ liệu sau đó thực hiện ghi sổ (bookkeeping) để chuẩn bị cho đợt cấp phát tiếp theo.
Truy cập dữ liệu trong heap chậm hơn so với truy cập dữ liệu trên stack vì bạn phải đi theo một con trỏ để đến đó. Các bộ xử lý hiện đại nhanh hơn nếu chúng ít nhảy qua lại bộ nhớ hơn. Tiếp tục tương tự, hãy xem xét một máy chủ tại một nhà hàng nhận các orders từ nhiều bàn. Cách hiệu quả nhất là nhận tất cả các orders tại một bàn trước khi chuyển sang bàn tiếp theo. Nhận một order từ bàn A, sau đó một order từ bàn B, sau đó lại một từ bàn A lần nữa, và sau đó lại một từ B sẽ là một quá trình chậm hơn nhiều. Cũng vì lẽ ấy, một bộ xử lý có thể thực hiện công việc của nó tốt hơn nếu nó làm việc với các dữ liệu gần nhau (như trên stack) thay vì các dữ liệu xa nhau (như trên heap). Việc phân bổ một lượng lớn không gian trên heap cũng có thể mất thời gian.
Khi code của bạn gọi một hàm, các giá trị đã được truyền vào hàm (có thể bao gồm cả con trỏ đến dữ liệu trên heap) và các biến cục bộ của hàm được đẩy lên stack. Khi hàm kết thúc, những giá trị đó bị lấy ra khỏi stack.
Theo dõi những phần code nào đang sử dụng dữ liệu nào trên heap, giảm thiểu số lượng dữ liệu trùng lặp trên heap, và dọn dẹp dữ liệu không sử dụng trên heap do đó bạn không cạn kiệt khoảng trống là tất cả những vấn đề mà ownership giải quyết. Khi bạn hiểu về ownership, bạn không cần phải suy nghĩ về stack và heap thường xuyên, nhưng biết được mục đích chính của ownership là để quản lý dữ liệu heap có thể giúp giải thích được tại sao nó hoạt động như vậy.
Các quy tắc của Ownership
Trước tiên, hãy xem các quy tắc ownership. Hãy ghi nhớ những quy tắc này khi chúng ta xem thông qua các ví dụ minh họa chúng:
- Mỗi giá trị trong Rust có một biến gọi là owner của nó.
- Chỉ có thể có một owner tại một thời điểm.
- Khi owner ra khỏi phạm vi (scope) của nó, giá trị sẽ bị bỏ đi.
Phạm vi biến
Bây giờ chúng ta đã qua cú pháp Rust cơ bản, chúng ta sẽ không viết tất cả các dòng
fn main() {
trong ví dụ nữa, vì vậy khi bạn theo dõi các ví dụ hãy chắc chắn
đã tự đặt các ví dụ bên trong hàm main
một cách thủ công. Vì vậy, các ví dụ của
chúng ta trông sẽ ngắn gọn hơn một chút, cho phép chúng ta tập trung vào những chi
tiết hơn là các đoạn mã soạn sẵn.
Trong ví dụ đầu tiên, chúng ta sẽ nói về phạm vi (scope) của một số biến. Scope là phạm vi trong một chương trình mà một item có giá trị. Giả sử ta có biến sau:
#![allow(unused)] fn main() { let s = "hello"; }
Biến s
đề cập tới một chuỗi kí tự (string literal), nơi mà giá trị của chuỗi được
gán cứng (hardcoded) vào một văn bản trong chương trình. Biến có giá trị tại thời điểm mà nó
được khai báo cho đến khi kết thúc scope hiện tại. Trong Listing 4-1 bên dưới có
các comment chỉ ra nơi biến s
hợp lệ
fn main() { { // s không hợp lệ ở đây, nó chưa được khai báo let s = "hello"; // s có giá trị từ thời điểm này trở đi // nơi làm những thứ với s } // scope này hiện đã kết thúc và s không còn hợp lệ }
Listing 4-1: Một biến và phạm vi mà nó hợp lệ
Nói cách khác, có hai điểm quan trọng về thời gian ở đây:
- Khi
s
đi vào scope, nó có giá trị. - Nó vẫn có giá trị cho tới khi nó đi ra khỏi scope.
Tại thời điểm này, mối quan hệ giữa phạm vi và thời điểm các biến có giá trị tương tự như trong các ngôn ngữ lập trình khác. Bây giờ dựa trên hiểu biết này bây giờ chúng tôi sẽ giới thiệu về kiểu String
.
Kiểu String
Để minh họa các quy tắc về ownership, chúng ta cần một kiểu dữ liệu phức tạp hơn những kiểu mà chúng ta đã đề cập trong phần “Data Types” ở chương 3. Các loại được đề cập trước đây đều có kích thước đã biết, có thể được lưu trữ trên stack và bị đẩy ra khỏi stack khi phạm vi của chúng kết thúc, và có thể được sao chép nhanh chóng và đơn để tạo ra một cái mới trong trường hợp độc lập nếu một phần khác của code cần sử dụng cùng một giá trị trong một phạm vi khác. Nhưng chúng ta muốn xem xét dữ liệu được lưu trữ trên heap và khám phá cách Rust biết khi nào cần dọn dẹp dữ liệu đó, và kiểu String
là một ví dụ tuyệt vời.
Chúng ta sẽ tập trung vào các phần của String
liên quan đến ownership. Các khía cạnh này cũng áp dụng cho các kiểu dữ liệu phức tạp khác, cho dù chúng được cung cấp bởi thư viện chuẩn hay do bạn tạo. Chúng ta sẽ thảo luận về String
sâu hơn ở Chapter 8.
Chúng ta đã nhìn thấy những chuỗi kí tự (string literals) có giá trị được gán cứng (hardcoded) trong chương trình. Các ký tự kiểu chuỗi rất tiện lợi, nhưng chúng không phù hợp với mọi tình huống mà chúng ta có thể muốn sử dụng văn bản. Một lý do là chúng không thay đổi. Một điều khác là không phải mọi giá trị chuỗi đều có thể được biết khi chúng ta viết mã của mình, ví dụ: nếu chúng ta muốn lấy dữ liệu đầu vào của người dùng và lưu trữ nó thì sao? Trong tình huống này, Rust có một kiểu chuỗi thứ hai, String
. Kiểu dữ liệu này được phân bổ trên heap, như thế nó có thể lưu trữ một khối lượng văn bản không biết trước ở thời điểm biên dịch. Bạn có thể tạo một String
từ một string literal bằng cách sử dụng hàm from
, như sau:
#![allow(unused)] fn main() { let s = String::from("hello"); }
Dấu hai chấm ::
là một toán tử cho phép chúng ta gọi hàm (namespace) from
với kiểu String
thay vì sử dụng một số loại tên như string_from
. Chúng ta sẽ thảo luận về cú pháp này nhiều hơn trong phần “Method Syntax” chương 5 và khi chúng ta nói về namespacing với module ở phần “Paths for Referring to an Item in the Module Tree” trong chương 7.
Kiểu chuỗi này cũng có thể biến đổi giá trị (mutated):
fn main() { let mut s = String::from("hello"); s.push_str(", world!"); // push_str() nối một ký tự vào một chuỗi println!("{}", s); // Điều này sẽ in ra `hello, world! ' }
Vậy, sự khác biệt ở đây là gì? Tại sao String
có thể biến đổi trong khi chuỗi kí tự (string literals)
thì không? Sự khác biệt là cách hai loại này tương tác với bộ nhớ.
Memory and Allocation (Bộ nhớ và cấp phát)
Trong trường hợp một chuỗi kí tự (string literal), chúng ta biết nội dung tại thời điểm biên dịch, vì vậy văn bản được gán cứng (hardcoded) trực tiếp vào tệp thực thi cuối cùng. Đây là lý do tại sao các ký tự chuỗi (string literals) nhanh và hiệu quả. Nhưng những thuộc tính này chỉ đến từ tính bất biến của chuỗi ký tự. Thật không may, chúng ta không thể đặt một blob memory vào hệ nhị phân cho mỗi đoạn văn bản có kích thước không xác định tại thời điểm biên dịch và kích thước của chúng có thể thay đổi trong khi chạy chương trình.
Với kiểu String
, để hỗ trợ một đoạn văn bản có thể thay đổi, có thể phát triển, chúng ta cần phân bổ một lượng bộ nhớ trên heap, không xác định tại thời điểm biên dịch, để giữ nội dung. Điều này có nghĩa là:
- Bộ nhớ phải được yêu cầu từ bộ cấp phát bộ nhớ trong thời gian chạy (runtime).
- Chúng ta cần một cách để trả lại bộ nhớ này cho bộ cấp phát khi chúng ta hoàn thành
String
.
Phần đầu tiên do chúng ta thực hiện: khi chúng ta gọi String::from
, việc triển khai của nó yêu cầu bộ nhớ mà nó cần. Điều này khá phổ biến trong các ngôn ngữ lập trình.
Tuy nhiên, phần thứ hai thì khác. Trong các ngôn ngữ có garbage collector(GC), theo dõi và dọn dẹp bộ nhớ không còn được sử dụng nữa và chúng ta không cần phải suy nghĩ về điều đó. Trong hầu hết các ngôn ngữ không có GC, chúng ta có trách nhiệm xác định khi nào bộ nhớ không còn được sử dụng và dùng code để trả lại bộ nhớ một cách rõ ràng, giống như chúng ta đã làm để yêu cầu nó. Trong lịch sử để thực hiện điều này một cách chính xác là một vấn đề khó khăn của lập trình. Nếu chúng ta quên, chúng ta sẽ lãng phí bộ nhớ. Nếu chúng ta làm điều đó quá sớm, chúng ta sẽ có một biến không hợp lệ. Nếu chúng tôi làm điều đó hai lần, đó cũng là một lỗi. Chúng ta cần ghép chính xác một allocate
với một free
.
Rust đi theo một con đường khác: bộ nhớ sẽ tự động được trả về khi biến sở hữu nó vượt ra khỏi phạm vi (scope). Dưới đây là một phiên bản của ví dụ về scope từ Listing 4-1 sử dụng một String
thay vì một chuỗi kí tự (string literal):
fn main() { { let s = String::from("hello"); // s có giá trị từ thời điểm này trở đi // do stuff with s } // phạm vi này hiện đã kết thúc và không // còn giá trị }
Có một điểm tự nhiên mà chúng ta có thể trả lại vùng nhớ String
của chúng ta cho bộ cấp phát: khi s
đi ra khỏi scope. Khi một biến vượt ra ngoài scope, Rust gọi một hàm đặc biệt cho chúng ta. Hàm này được gọi là drop
, và nó là nơi mà tác giả của String
có thể đặt code để trả lại bộ nhớ. Rust gọi drop
tự động tại nơi dấu đóng ngoặc nhọn.
Note: Lưu ý: Trong C ++, kiểu phân bổ tài nguyên này ở cuối vòng đời của một item đôi khi được gọi là Resource Acquisition Is Initialization (RAII). Hàm
drop
trong Rust sẽ quen thuộc hơn với bạn nếu bạn từng dùng mô hình RAII.
Mô hình này có tác động sâu sắc đến cách viết code của Rust. Nó có vẻ đơn giản ngay bây giờ, nhưng hành vi của code có thể không mong muốn trong các tình huống phức tạp hơn khi chúng ta muốn có nhiều biến sử dụng dữ liệu chúng ta đã phân bổ trên heap. Bây giờ chúng ta hãy khám phá một số tình huống đó.
Cách các biến và dữ liệu tương tác: Move
Nhiều biến có thể tương tác với cùng một dữ liệu theo những cách khác nhau trong Rust. Hãy xem một ví dụ sử dụng một số nguyên trong Listing 4-2.
fn main() { let x = 5; let y = x; }
Listing 4-2: Gán giá trị nguyên của biến x
vào y
Chúng ta có thể đoán được đoạn code này đang thể hiện gì: “gán giá trị 5
vào x
; sau đó tạo một bản sao của giá trị của x
và gán nó bằng y
.” Bây giờ chúng ta có hai biến, x
và y
, cả 2 đều bằng 5
. Đây thực sự là những gì đang xảy ra, bởi vì số nguyên là các giá trị đơn giản có giá trị cố định, đã biết, và hai giá trị 5
này được đẩy vào stack.
Giờ hãy cùng nhìn vào phiên bản String
:
fn main() { let s1 = String::from("hello"); let s2 = s1; }
Điều này trông rất giống nhau, vì vậy chúng tôi có thể giả định rằng cách nó hoạt động sẽ giống nhau: nghĩa là, dòng thứ hai sẽ tạo một bản sao của giá trị trong s1
và gán nó cho s2
. Nhưng đây không phải là điều sẽ diễn ra.
Hãy xem Hình 4-1 để xem điều gì đang xảy ra với String
trong thực tế. String
được tạo thành từ ba phần, hiển thị ở bên trái: một con trỏ tới bộ nhớ chứa nội dung của string, một độ dài, và một dung lượng (capacity). Nhóm dữ liệu này được lưu trữ trên stack. Ở bên phải là bộ nhớ trên heap chứa nội dung.
Hình 4-1: Biểu diễn trong bộ nhớ của một String
giữ giá trị "hello"
gán cho s1
Độ dài là lượng bộ nhớ, tính bằng byte, mà nội dung của String
đang sử dụng. Dung lượng (capacity) là tổng dung lượng bộ nhớ, tính bằng byte mà String
đã nhận được từ bộ cấp phát. Có sự khác biệt giữa độ dài và dung lượng (capacity), nhưng không phải trong bối cảnh này, vì vậy hiện tại, bạn có thể bỏ qua dung lượng (capacity).
Khi chúng ta gán s1
cho s2
, dữ liệu String
được sao chép, có nghĩa là chúng ta sao chép con trỏ, độ dài và dung lượng trên stack. Chúng ta không sao chép dữ liệu trên heap mà con trỏ chỉ tới. Nói cách khác, dữ liệu được biểu diễn trong bộ nhớ như Hình 4-2.
Hình 4-2: Biểu diễn trong bộ nhớ của biến s2
chứa bản sao của con trỏ, độ dài và dung lượng của s1
Biểu diễn trên Hình 4-2 không giống như Hình 4-3, đó là bộ nhớ sẽ trông như thế nào nếu thay vào đó Rust cũng sao chép dữ liệu heap. Nếu Rust đã làm điều này, s2 = s1
có thể rất tốn kém về hiệu suất thời gian chạy nếu dữ liệu trên heap lớn.
Hình 4-3: Một khả năng khác cho những gì s2 = s1
có thể làm nếu Rust cũng sao chép dữ liệu heap
Trước đó, chúng tôi đã nói rằng khi một biến vượt ra ngoài scope, Rust tự động gọi hàm drop
và dọn dẹp bộ nhớ heap cho biến đó. Nhưng Hình 4-2 hiển thị cả hai con trỏ dữ liệu trỏ đến cùng một vị trí. Đây là một vấn đề: khi s2
và s1
vượt ra ngoài scope, cả hai sẽ cố gắng giải phóng cùng một bộ nhớ. Điều này được gọi là lỗi double free và là một trong những lỗi an toàn bộ nhớ mà chúng tôi đã đề cập trước đây. Giải phóng bộ nhớ hai lần có thể dẫn đến hỏng bộ nhớ, có thể dẫn đến lỗ hổng bảo mật.
Để đảm bảo an toàn cho bộ nhớ, sau dòng let s2 = s1
, Rust coi s1
không còn giá trị nữa. Do đó, Rust không cần giải phóng bất cứ thứ gì khi khi s1
đi ra khỏi scope. Kiểm tra những gì sẽ xảy ra khi bạn cố gắng sử dụng s1
sau khi s2
được tạo ra; nó sẽ không hoạt động:
fn main() {
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1);
}
Bạn sẽ gặp lỗi như thế này vì Rust ngăn bạn sử dụng tham chiếu không hợp lệ:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0382]: borrow of moved value: `s1`
--> src/main.rs:5:28
|
2 | let s1 = String::from("hello");
| -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 | let s2 = s1;
| -- value moved here
4 |
5 | println!("{}, world!", s1);
| ^^ value borrowed here after move
|
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` due to previous error
Nếu bạn đã nghe về thuật ngữ sao chép cạn (shallow copy) và sao chép sâu (deep copy) trong khi làm việc với các ngôn ngữ khác, khái niệm sao chép con trỏ, độ dài và dung lượng mà không sao chép dữ liệu có thể nghe giống như tạo một sao chép cạn. Nhưng vì Rust cũng làm mất hiệu lực của biến đầu tiên, thay vì gọi nó là một sao chép cạn, nó được gọi là một move (di chuyển). Trong ví dụ này, chúng ta sẽ nói rằng s1
đã được moved vào s2
. Những gì thực sự xảy ra được thể hiện trong Hình 4-4.
Hình 4-4: Biểu diễn trong bộ nhớ sau khi s1
đã bị vô hiệu
Điều đó giải quyết vấn đề của chúng tôi! Chỉ với s2
còn giá trị và khi nó vượt ra ngoài scope, chỉ nó sẽ giải phóng bộ nhớ và chúng ta đã hoàn tất.
Ngoài ra, có một lựa chọn thiết kế được ngụ ý bởi điều này: Rust sẽ không bao giờ tự động tạo các bản sao "sâu" (deep copy) dữ liệu của bạn. Do đó, bất kỳ tự động sao chép nào cũng có thể được coi là không tốn kém về hiệu suất runtime.
Cách tương tác giữa các biến và dữ liệu: Clone
Nếu chúng tôi muốn sao chép sâu dữ liệu heap của String
, không chỉ là dữ liệu stack, chúng ta có thể sử dụng một phương thức (method) phổ biến được gọi là clone
. Chúng ta sẽ thảo luận về cú pháp của method trong Chương 5, nhưng vì các method là một tính năng phổ biến trong nhiều ngôn ngữ lập trình, nên có thể bạn đã từng thấy chúng trước đây.
Đây là một ví dụ của method clone
:
fn main() { let s1 = String::from("hello"); let s2 = s1.clone(); println!("s1 = {}, s2 = {}", s1, s2); }
Đoạn code hoạt động tốt và rõ ràng tạo ra hành vi được hiển thị trong Hình 4-3, nơi dữ liệu heap được sao chép.
Khi bạn thấy một lệnh gọi clone
, bạn biết rằng đoạn code nào đó đang được thực thi và code đó có thể khá tốn tài nguyên. Đó là một chỉ báo trực quan cho thấy điều gì đó khác thường đang diễn ra.
Dữ liệu chỉ trên Stack (Stack-Only Data): Copy
Có một vấn đề khác mà chúng ta chưa nói đến. Đoạn code này sử dụng số nguyên – một phần trong số đó đã được hiển thị trong Listing 4-2 – hoạt động và hợp lệ:
fn main() { let x = 5; let y = x; println!("x = {}, y = {}", x, y); }
Nhưng mã này có vẻ mâu thuẫn với những gì chúng ta vừa học được: chúng ta không gọi lệnh clone
, nhưng x
vẫn còn hiệu lực và chưa được move vào y
.
Lý do là các loại như số nguyên có kích thước đã biết tại thời điểm biên dịch được lưu trữ hoàn toàn trên stack, vì vậy các bản sao của các giá trị thực tế được tạo ra nhanh chóng. Điều đó có nghĩa là không có lý do gì chúng tôi muốn ngăn chặn x
không còn hợp lệ sau khi chúng tôi tạo biến y
. Nói cách khác, không có sự khác biệt giữa sao chép sâu và sao chép cạn ở đây, vì vậy việc gọi clone
sẽ không làm gì khác so với cách sao chép cạn thông thường và chúng ta có thể bỏ nó đi.
Rust có một chú thích (annotation) đặc biệt gọi là Copy
trait chúng ta có thể đặt nó trên những kiểu được lưu trữ trên stack như integer (chúng ta sẽ nói thêm về trait trong Chương 10). Nếu một kiểu thực hiện Copy
trait, một biến vẫn hợp lệ sau khi gán cho một biến khác. Rust không cho phép chúng ta chú thích một kiểu với Copy
nếu kiểu của nó, hoặc bất kì phần nào của nó, đã thực thi Drop
trait. Nếu kiểu cần một cái gì đó đặc biệt để xảy ra khi giá trị vượt ra ngoài scope và chúng ta thêm Copy
annotation vào kiểu đó, chúng ta sẽ gặp lỗi biên dịch. Để tìm hiểu về cách thêm Copy
annotation vào kiểu của bạn để triển khai trait, hãy xem “Derivable Traits”
trong Phụ lục C.
Vậy, những loại nào triển khai Copy
trait? Bạn có thể kiểm tra tài liệu về loại đã cho để chắc chắn, nhưng theo quy tắc chung, bất kỳ nhóm giá trị vô hướng đơn giản nào cũng có thể triển khai Copy
, và không có kiểu nào yêu cầu allocation hoặc là một dạng của resource có thể triển khai Copy
. Dưới đây là một số kiểu có thể triển khai Copy
:
- Tất cả các kiểu số nguyên, chẳng hạn như
u32
. - Kiểu Boolean,
bool
, với giá trịtrue
vàfalse
. - Tất cả các kiểu dấu phẩy động, chẳng hạn như
f64
. - Kiểu ký tự,
char
. - Tuples, nếu chúng chỉ chứa những kiểu có thể triển khai
Copy
. Ví dụ,(i32, i32)
có thể triển khaiCopy
, nhưng(i32, String)
thì không.
Ownership và Hàm
Ý nghĩa cho việc truyền một giá trị tới một hàm tương tự việc gán một giá trị vào một biến. Truyền một biến cho một hàm sẽ di chuyển hoặc sao chép, giống như phép gán. Listing 4-3 có một ví dụ với một số chú thích hiển thị nơi các biến đi vào và ra khỏi scope.
Filename: src/main.rs
fn main() { let s = String::from("hello"); // s đi vào scope takes_ownership(s); // giá trị của s di chuyển vào hàm... // ... và như vậy không còn giá trị ở đây let x = 5; // x đi vào scope makes_copy(x); // x sẽ di chuyển vào hàm, // nhưng i32 là Copy, vì vậy vẫn hoàn toàn có thể // sử dụng x sau đó } // Tại đây, x đi ra khỏi scope, sau đó là s. Nhưng vì giá trị của s đã được move, nên không có gì // đặc biệt xảy ra. fn takes_ownership(some_string: String) { // some_string đi vào scope println!("{}", some_string); } // Tại đây, some_string đi ra khỏi scope và `drop` được gọi. Bộ nhớ được giải phóng. fn makes_copy(some_integer: i32) { // some_integer đi vào scope println!("{}", some_integer); } // Tại đây, some_integer đi ra khỏi scope. Không có gì đặc biệt xảy ra.
Listing 4-3: Hàm với ownership và scope được chú thích
Nếu chúng ta cố gắng sử dụng s
sau khi gọi takes_ownership
, Rust sẽ báo lỗi biên dịch. Những kiểm tra tĩnh này bảo vệ chúng ta khỏi những sai lầm. Thử thêm code vào main
sử dụng s
và x
để xem bạn có thể sử dụng chúng ở đâu và các quy tắc ownership ngăn bạn làm điều đó ở đâu.
Trả về giá trị và (Tầm vực - Phạm vi) Scope
Giá trị trả về cũng có thể chuyển giao ownership. Listing 4-4 hiển thị một ví dụ về một hàm trả về một số giá trị, với các chú thích tương tự như trong Listing 4-3.
Filename: src/main.rs
fn main() { let s1 = gives_ownership(); // gives_ownership di chuyển giá trị trả về của nó // vào s1 let s2 = String::from("hello"); // s2 đi vào scope let s3 = takes_and_gives_back(s2); // s2 is được di chuyển vào // takes_and_gives_back, và // giá trị trả về của nó được di chuyển vào s3 } // Tại đây, s3 đi ra khỏi scope và bị drop. s2 đã bị di chuyển, vậy nên không có gì // xảy ra. s1 đi ra khỏi scope và bị drop. fn gives_ownership() -> String { // gives_ownership sẽ di chuyển // giá trị trả về của nó nó vào hàm gọi nó let some_string = String::from("yours"); // some_string đi vào scope some_string // some_string được trả về và // chuyển sang hàm gọi } // Hàm này nhận một a String trả về một string fn takes_and_gives_back(a_string: String) -> String { // a_string đi vào // scope a_string // a_string được trả về và chuyển sang hàm gọi }
Listing 4-4: Chuyển ownership của giá trị trả về
Ownership của một biến luôn tuân theo cùng một mẫu: việc gán một giá trị cho một biến khác sẽ di chuyển nó. Khi một biến bao gồm dữ liệu trên heap vượt ra khỏi scope, giá trị sẽ được xóa bởi drop
trừ khi ownership của dữ liệu đã được chuyển sang một biến khác.
Việc lấy ownership và sau đó trả về ownership với mọi hàm có một chút tẻ nhạt. Điều gì sẽ xảy ra nếu chúng ta muốn cho một hàm sử dụng một giá trị nhưng không có ownership? Điều khá khó chịu là bất kỳ thứ gì chúng ta truyền đi cũng cần phải được truyền lại nếu chúng ta muốn sử dụng lại nó, thêm cả bất kỳ dữ liệu nào đến từ phần thân của hàm mà chúng ta có thể muốn trả về.
Rust cho phép chúng ta trả về nhiều giá trị bằng cách sử dụng một bộ tuple, như được hiển thị trong Listing 4-5.
Filename: src/main.rs
fn main() { let s1 = String::from("hello"); let (s2, len) = calculate_length(s1); println!("The length of '{}' is {}.", s2, len); } fn calculate_length(s: String) -> (String, usize) { let length = s.len(); // len() trả về độ dài của một String (s, length) }
Listing 4-5: Returning ownership of parameters
Nhưng đây là quá nhiều thao tác và rất nhiều công việc đối với một khái niệm nên phổ biến. May mắn cho chúng ta, Rust có một tính năng để sử dụng một giá trị mà không cần chuyển ownership, được gọi là references.
Tham chiếu và nguyên lý mượn - borrowing (References và Borrowing)
Data races: Chạy đua dữ liệu, chỉ hiện tượng các đoạn code khác nhau cùng đòi quyền sử dụng một biến hay một vùng bộ nhớ
Vấn đề với tuple trong Listing 4-5 là chúng ta phải trả lại String
cho hàm gọi vì vậy chúng ta vẫn có thể sử dụng String
sau khi gọi calculate_length
, vì String
đã được chuyển đến calculate_length
. Thay vào đó, chúng ta có thể cung cấp một tham chiếu (reference) đến giá trị của String
.
Một tham chiếu (reference) giống như một con trỏ ở chỗ đó là một địa chỉ mà chúng ta có thể đi theo để truy cập vào dữ liệu được lưu trữ tại địa chỉ thuộc sở hữu của một số biến khác. Không giống như một con trỏ, một tham chiếu được đảm bảo trỏ đến một giá trị hợp lệ của một kiểu cụ thể. Đây là cách bạn sẽ xác định và sử dụng một hàm calculate_length
có tham chiếu đến một đối tượng dưới dạng tham số thay vì dùng ownership để có quyền sở hữu giá trị:
Filename: src/main.rs
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{}' is {}.", s1, len); } fn calculate_length(s: &String) -> usize { s.len() }
Đầu tiên, hãy lưu ý rằng tất cả tuple trong khai báo biến và giá trị trả về của hàm đã biến mất. Thứ hai, lưu ý rằng chúng tôi chuyển &s1
vào calculate_length
và, theo định nghĩa của nó, chúng tôi lấy &String
thay vì String
. Các ký hiệu & này đại diện cho các tham chiếu (references), và chúng cho phép bạn tham chiếu đến một số giá trị mà không cần lấy ownership của nó. Hình 4-5 mô tả khái niệm này.
Figure 4-5: Một sơ đồ của &String s
trỏ vào String s1
Lưu ý: Ngược lại với tham chiếu bằng cách sử dụng
&
is dereferencing, được thực hiện với toán tử dereference,*
. Chúng ta sẽ thấy một số cách sử dụng của toán tử dereference trong Chương 8 và thảo luận chi tiết về dereferencing trong Chương 15.
Chúng ta hãy xem xét kỹ hơn lệnh gọi hàm tại đây:
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{}' is {}.", s1, len); } fn calculate_length(s: &String) -> usize { s.len() }
&s1
cú pháp cho phép chúng ta tạo một tham chiếu đề cập đến giá trị của s1
nhưng không sở hữu nó. Bởi vì nó không sở hữu nó, giá trị nó trỏ đến sẽ không bị drop khi tham chiếu ngừng được sử dụng.
Tương tự như vậy, chữ ký hàm (signature of the function) sử dụng uses &
để chỉ ra rằng kiểu tham số
s
là một tham chiếu. Hãy xem một số chú thích để giải thích cho việc này:
fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{}' is {}.", s1, len); } fn calculate_length(s: &String) -> usize { //s là một tham chiếu đến một String s.len() } // Tại đây, s đi ra khỏi scope. Nhưng vì nó không có quyền sở hữu của String nó đề cập đến, // nên không có gì xảy ra.
Phạm vi mà biến s
có giá trị giống như phạm vi của bất kỳ thông số hàm nào, nhưng giá trị được trỏ đến bởi tham chiếu không bị drop khi s
được dừng sử dụng vì s
không có ownership. Khi các hàm có tham chiếu dưới dạng tham số thay vì giá trị thực, chúng ta sẽ không cần trả lại giá trị để trả lại ownership vì chúng ta chưa bao giờ có ownership.
Chúng tôi gọi hành động tạo tham chiếu là borrowing. Như trong cuộc sống thực, nếu một người sở hữu một thứ gì đó, bạn có thể mượn nó từ họ. Khi bạn làm xong, bạn phải trả lại nó. Bạn không sở hữu nó.
Vậy điều gì sẽ xảy ra nếu chúng ta cố gắng sửa đổi thứ mà chúng ta đang vay mượn (borrowing)? Hãy thử code trong Listing 4-6. Spoiler cảnh báo: nó không hoạt động!
Filename: src/main.rs
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}
Listing 4-6: Attempting to modify a borrowed value
Here’s the error:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
7 | fn change(some_string: &String) {
| ------- help: consider changing this to be a mutable reference: `&mut String`
8 | some_string.push_str(", world");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` due to previous error
Cũng giống như các biến là bất biến theo mặc định, các tham chiếu cũng vậy. Chúng tôi không được phép sửa đổi điều gì đó mà chúng tôi có tham chiếu đến.
Tham chiếu (References) có thể thay đổi
Chúng ta có thể sửa code từ Listing 4-6 để cho phép chúng ta sửa đổi một giá trị đã mượn chỉ với một vài chỉnh sửa nhỏ, bằng cách sử dụng tham chiếu có thể thay đổi (mutable reference):
Filename: src/main.rs
fn main() { let mut s = String::from("hello"); change(&mut s); } fn change(some_string: &mut String) { some_string.push_str(", world"); }
Đầu tiên, chúng ta thay đổi s s
thành mut
để có thể thay đổi. Sau đó, chúng tôi tạo một tham chiếu có thể thay đổi với &muts
nơi chúng ta gọi hàm change
, và cập nhật chữ ký hàm (function signature) để chấp nhận một tham chiếu có thể thay đổi với some_string: &mut String
. Điều này làm cho nó rất rõ ràng rằng hàm change
sẽ thay đổi giá trị mà nó vay.
Tham chiếu có thể thay đổi có một hạn chế lớn: bạn chỉ có thể có một tham chiếu có thể thay đổi cho một phần dữ liệu cụ thể tại một thời điểm. Code này cố gắng tạo hai tham chiếu có thể thay đổi cho s
sẽ không thành công:
Filename: src/main.rs
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
}
Đây là lỗi:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{}, {}", r1, r2);
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error
Lỗi này cho biết rằng code không hợp lệ vì chúng ta không thể mượn (borrow) s
có thể thay đổi nhiều lần tại một thời điểm. Đầu tiên là tại s1 r1
và nó kéo dài cho tới khi sử dụng println!
, nhưng giữa chừng, chúng ta đã cố gắng tạo một tham chiếu có thể thay đổi khác tại r2
mượn cùng một dữ liệu như r1
.
Hạn chế ngăn nhiều tham chiếu có thể thay đổi đến cùng một dữ liệu cùng một lúc cho phép tạo ra đột biến nhưng theo cách rất được kiểm soát. Đó là điều mà những Rustaceans mới gặp khó khăn vì hầu hết các ngôn ngữ đều cho phép bạn thay đổi bất cứ khi nào bạn muốn. Lợi ích của việc hạn chế này là Rust có thể ngăn chặn hiện tượng data race tại thời điểm biên dịch. Một data race tương tự như một race condition và xảy ra khi ba hành vi này xảy ra:
- Hai hoặc nhiều con trỏ truy cập cùng một dữ liệu cùng một lúc.
- Ít nhất một trong các con trỏ đang được sử dụng để ghi vào dữ liệu.
- Không có cơ chế nào được sử dụng để đồng bộ hóa quyền truy cập vào dữ liệu.
Chạy đua dữ liệu (Data races) gây ra hành vi không xác định (undefined behavior) và có thể khó chẩn đoán và khắc phục khi bạn đang cố gắng theo dõi chúng trong runtime; Rust ngăn chặn vấn đề này bằng cách từ chối biên dịch code với data races!
Như mọi khi, chúng ta có thể sử dụng dấu ngoặc nhọn để tạo một phạm vi mới, cho phép nhiều tham chiếu có thể thay đổi, chỉ là những tham chiếu không được xảy ra đồng thời:
fn main() { let mut s = String::from("hello"); { let r1 = &mut s; } // r1 đi ra khỏi scope tại đây, vì vậy chúng ta có thể tạo một //tham chiếu mới mà không gặp vấn đề gì. let r2 = &mut s; }
Rust thực thi một quy tắc tương tự để kết hợp các tham chiếu có thể thay đổi và bất biến. Code này dẫn đến lỗi:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM
println!("{}, {}, and {}", r1, r2, r3);
}
Here’s the error:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:6:14
|
4 | let r1 = &s; // no problem
| -- immutable borrow occurs here
5 | let r2 = &s; // no problem
6 | let r3 = &mut s; // BIG PROBLEM
| ^^^^^^ mutable borrow occurs here
7 |
8 | println!("{}, {}, and {}", r1, r2, r3);
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error
Chà! Chúng ta cũng không thể có một tham chiếu có thể thay đổi (mutable reference) trong khi chúng ta có một tham chiếu bất biến (immutable reference) với cùng một giá trị. Người dùng tham chiếu bất biến không mong đợi giá trị đột ngột thay đổi! Tuy nhiên, việc sử dụng nhiều tham chiếu bất biến thì được cho phép vì không ảnh hưởng đến việc đọc dữ liệu của bất kỳ ai khác.
Lưu ý rằng phạm vi của tham chiếu bắt đầu từ nơi nó tạo ra và tiếp tục cho đến lần cuối cùng tham chiếu đó được sử dụng. Ví dụ: code này vẫn sẽ biên dịch vì nơi sử dụng cuối cùng của các tham chiếu bất biến tại println!
, xảy ra trước khi tham chiếu có thể thay đổi được tạo ra:
fn main() { let mut s = String::from("hello"); let r1 = &s; // no problem let r2 = &s; // no problem println!("{} and {}", r1, r2); // biến r1 và r2 sẽ không được sử dụng sau thời điểm này let r3 = &mut s; // no problem println!("{}", r3); }
Phạm vi của các tham chiếu bất biến r1
và r2
kết thúc sau println!
nơi chúng được sử dụng lần cuối, trước tham chiếu có thể thay đổi r3
được tạo ra. Các phạm vi này không trùng lặp, vì vậy code này được phép sử dụng. Khả năng của trình biên dịch để thông báo rằng một tham chiếu không còn được sử dụng tại một điểm trước khi kết thúc phạm vi được gọi là Non-Lexical Lifetimes (viết tắt là NLL), và bạn có thể đọc thêm về nó trong The Edition Guide.
Mặc dù đôi khi lỗi borrowing có thể khiến bạn bực bội, hãy nhớ rằng đó là trình biên dịch Rust chỉ ra một lỗi tiềm ẩn sớm (tại tại thời điểm biên dịch thay vì tại runtime) và cho bạn thấy chính xác vấn đề nằm ở đâu. Sau đó, bạn không phải theo dõi lý do tại sao dữ liệu của bạn không giống như bạn nghĩ nữa.
Tham chiếu treo (Hoặc Tham chiếu lạc) (Dangling References)
Trong các ngôn ngữ có con trỏ, rất dễ tạo sai một con trỏ treo (dangling pointer)--một con trỏ tham chiếu đến một vị trí trong bộ nhớ có thể đã được cấp cho người khác--bằng cách giải phóng một số bộ nhớ trong khi vẫn bảo toàn con trỏ tới bộ nhớ đó. Ngược lại, trong Rust, trình biên dịch đảm bảo rằng các tham chiếu sẽ không bao giờ là tham chiếu treo (dangling references): nếu bạn có tham chiếu đến một số dữ liệu, trình biên dịch sẽ đảm bảo rằng dữ liệu sẽ không vượt ra khỏi phạm vi trước khi tham chiếu đến dữ liệu đó.
Hãy thử tạo một tham chiếu treo (dangling references) để xem cách Rust ngăn chặn chúng với lỗi biên dịch:
Filename: src/main.rs
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
Here’s the error:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
5 | fn dangle() -> &String {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
|
5 | fn dangle() -> &'static String {
| ~~~~~~~~
For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error
Thông báo lỗi này đề cập đến một tính năng mà chúng tôi chưa đề cập đến: lifetimes. Chúng ta sẽ thảo luận về lifetimes chi tiết trong Chương 10. Tuy nhiên, nếu bạn chưa nắm rõ về lifetimes thì thông báo vẫn có chỉ ra tại sao code này lại đang có vấn đề:
this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
(kiểu trả về của hàm này chứa giá trị được borrow, nhưng không có giá trị nào cho nó được borrow)
Chúng ta hãy xem xét kỹ hơn chính xác những gì đang xảy ra ở mỗi giai đoạn trong code:
Filename: src/main.rs
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // trả về một tham chiếu đến một String
let s = String::from("hello"); // s là một String mới
&s // chúng ta trả về một tham chiếu đến String, s
} // Tại đây, s đi ra khỏi scope, và bị dropped. Bộ nhớ của nó đã bị mất đi.
// Nguy hiểm!
Bởi vì s
được tạo ra bên trong dangle
, khi code của dangle
đã hoàn thành, s
sẽ được phân bổ. Nhưng chúng ta đã cố gắng trả về một tham chiếu đến nó. Điều đó có nghĩa là tham chiếu này sẽ trỏ đến một String
không còn giá trị. Điều đó không tốt! Rust sẽ không để chúng ta làm điều này.
Giải pháp ở đây là trả về String
trực tiếp:
fn main() { let string = no_dangle(); } fn no_dangle() -> String { let s = String::from("hello"); s }
Điều này hoạt động mà không có bất kỳ vấn đề gì. Ownership đã được chuyển ra ngoài, và không có gì được phân bổ.
Các quy tắc của References
Hãy tóm tắt lại những gì chúng ta đã thảo luận về tham chiếu (references):
- Tại một thời điểm, bạn chỉ có thể có một tham chiếu có thể thay đổi (mutable reference) và có thể có nhiều tham chiếu bất biến (immutable references).
- Tham chiếu phải luôn có giá trị.
Tiếp theo, chúng ta sẽ xem xét một loại tham chiếu khác: slices.
Kiểu Slice
Slices cho phép bạn tham chiếu một chuỗi các phần tử liền nhau trong một tập hợp thay vì toàn bộ tập hợp. Một slice là một loại tham chiếu, vì vậy nó không có ownership.
Có một vấn đề nhỏ trong lập trình: viết một hàm nhận một chuỗi (String) và trả về từ đầu tiên mà nó tìm thấy trong chuỗi đó. Nếu hàm không tìm thấy khoảng trắng trong chuỗi, thì toàn bộ chuỗi phải là một từ, do đó, toàn bộ chuỗi phải được trả về.
Hãy cùng tìm hiểu về cách chúng ta viết chữ ký của hàm (signature of function) mà không cần sử dụng các slice, để hiểu vấn đề mà các slice sẽ giải quyết:
fn first_word(s: &String) -> ?
Hàm first_word
có một &String
là một tham số. Chúng ta không muốn sử dụng ownership, vì vậy điều này không sao cả. Nhưng chúng ta nên return lại cái gì? Chúng ta thực sự không có cách nào để nói về một phần của một string. Tuy nhiên, chúng ta có thể trả về index ở cuối từ, nếu nó là một khoảng trắng. Hẫy thử điều đó trong Listing 4-7.
Filename: src/main.rs
fn first_word(s: &String) -> usize { let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return i; } } s.len() } fn main() {}
Listing 4-7: Hàm first_word
trả về một giá trị index dạng byte vào tham số String
Bởi vì chúng ta cần đi qua phần tử của String
theo từng phần tử và kiểm tra xem một giá trị có phải là khoảng trắng hay không, chúng ta sẽ chuyển đổi String
thành một mảng byte bằng method as_bytes
:
fn first_word(s: &String) -> usize {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return i;
}
}
s.len()
}
fn main() {}
Tiếp theo, chúng ta tạo một trình lặp trên mảng byte bằng method iter
:
fn first_word(s: &String) -> usize {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return i;
}
}
s.len()
}
fn main() {}
Chúng ta sẽ thảo luận chi tiết hơn về trình lặp trong Chương 13. Bây giờ, hãy biết rằng iter
là một method that trả về từng phần tử trong một tập hợp và enumerate
sẽ bao bọc kết quả của iter
và trả về từng phần tử dưới dạng một phần của một tuple. Phần tử đầu tiên của tuple được
trả về từ enumerate
là index,và phần tử thứ hai là một tham chiếu đến phần tử. Điều này thuận tiện hơn một chút so với việc tự tính toán index.
Bởi vì method enumerate
một tuple,chúng ta có thể sử dụng các patterns để cấu trúc bộ tuple đó. Chúng ta sẽ thảo luận thêm về patterns trong Chương 6. Trong vòng lặp for
, chúng ta xác định một pattern có i
là index trong tuple và &item
cho single byte trong tuple. Bởi vì chúng ta nhận được một tham chiếu đến phần tử từ .iter().enumerate()
nên chúng ta sử dụng &
trong pattern.
Trong vòng lặp for
, chúng ta tìm kiếm byte đại diện cho khoảng trắng bằng cách sử dụng cú pháp ký tự byte. Nếu chúng ta tìm thấy một khoảng trắng, chúng ta sẽ trả về vị trí của nó. Nếu không, chúng ta trả về độ dài của chuỗi bằng cách sử dụng s.len()
:
fn first_word(s: &String) -> usize {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return i;
}
}
s.len()
}
fn main() {}
Bây giờ chúng ta có một cách để tìm ra index của cuối từ đầu tiên trong chuỗi, nhưng có một vấn đề. Chúng ta đang trả lại một usize
của riêng nó, nhưng nó chỉ là một con số có ý nghĩa trong ngữ cảnh của &String
. Nói cách khác, bởi vì nó là một giá trị riêng biệt với String
, không có gì đảm bảo rằng nó sẽ vẫn có giá trị trong tương lai. Xem xét chương trình trong Listing 4-8 sử dụng hàm first_word
từ Listing 4-7.
Filename: src/main.rs
fn first_word(s: &String) -> usize { let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return i; } } s.len() } fn main() { let mut s = String::from("hello world"); let word = first_word(&s); // word sẽ nhận được giá trị 5 s.clear(); // ở đây chúng ta làm trống String, làm cho nó bằng "" // word vẫn có giá trị 5 ở đây, nhưng không còn String nào mà chúng ta có thể sử dụng // một cách có ý nghĩa với giá trị 5 này nên word bây giờ hoàn toàn không có giá trị sử dụng! }
Listing 4-8: Lưu trữ kết quả trả về khi gọi hàm first_word
function và sau đó thay đổi nội dung của String
Chương trình này biên dịch mà không có bất kỳ lỗi nào và cũng như vậy nếu chúng ta sử dụng word
sau khi gọi s.clear()
. Vì word
hoàn toàn không kết nối với trạng thái của s
, word
vẫn chứa giá trị 5
. Nếu chúng ta sử dụng giá trị 5
với biến s
để trích xuất từ đầu tiên, nhưng đây sẽ là một lỗi vì nội dung của s
đã thay đổi kể từ khi chúng ta lưu 5
trong word
.
Việc phải lo lắng về việc index trong word
không đồng bộ với dữ liệu trong s
thật tẻ nhạt và dễ xảy ra lỗi! Việc quản lý các chỉ số này thậm chí còn khó khăn hơn nếu chúng ta viết một hàm second_word
. Chữ ký hàm của nó sẽ phải trông như thế này:
fn second_word(s: &String) -> (usize, usize) {
Bây giờ chúng ta đang theo dõi index nơi bắt đầu và nơi kết thúc, và chúng ta có nhiều giá trị hơn được tính toán từ dữ liệu ở một trạng thái cụ thể nhưng hoàn toàn không bị ràng buộc với trạng thái đó. Chúng tôi có tới ba biến không liên quan đang trôi nổi cần được đồng bộ hóa.
May mắn thay, Rust có một giải pháp cho vấn đề này: string slices.
String Slices
Một string slice là một tham chiếu đến một phần của một String
, và nó trông như thế này:
fn main() { let s = String::from("hello world"); let hello = &s[0..5]; let world = &s[6..11]; }
Thay vì tham chiếu đến toàn bộ String
, hello
là một tham chiếu đến một phần của String
, được xác định trong [0..5]
bit. Chúng ta tạo các lát cắt (slices) bằng cách sử dụng một phạm vi trong dấu ngoặc bằng cách chỉ định [starting_index..ending_index]
, starting_index
là vị trí đầu tiên trong slice và ending_index
nhiều hơn một so với vị trí cuối cùng trong slice. Bên trong, cấu trúc dữ liệu slice lưu trữ vị trí bắt đầu và độ dài của slice, tương ứng với ending_index
trừ đi starting_index
. Vì vậy, trong trường hợp của let world = &s[6..11];
, world
là một slice chứa một con trỏ đến byte tại index 6 của s
với giá trị độ dài là 5.
Figure 4-6 cho thấy điều này trong một sơ đồ.
Figure 4-6: String slice tham chiếu đến một phần của một String
Với ..
là cú pháp phạm vi của Rust, nếu bạn muốn bắt đầu từ index 0, bạn có thể viết theo 2 cách sau, chúng tương đương nhau:
#![allow(unused)] fn main() { let s = String::from("hello"); let slice = &s[0..2]; let slice = &s[..2]; }
Tương tự, nếu slice của bạn bao gồm byte cuối cùng của String
, bạn có thể bỏ len ở sau cùng. 2 cách viết dưới đây tương đương nhau:
#![allow(unused)] fn main() { let s = String::from("hello"); let len = s.len(); let slice = &s[3..len]; let slice = &s[3..]; }
Bạn cũng có thể bỏ cả hai giá trị để lấy một slice của toàn bộ chuỗi:
#![allow(unused)] fn main() { let s = String::from("hello"); let len = s.len(); let slice = &s[0..len]; let slice = &s[..]; }
Lưu ý: chỉ số phạm vi của String slice phải nằm trong ranh giới ký tự UTF-8 hợp lệ. Nếu bạn cố gắng tạo một string slice ở giữa một ký tự nhiều byte, chương trình của bạn sẽ thoát ra với một lỗi. Với mục đích giới thiệu string slices, chúng tôi chỉ giả định ASCII trong phần này; một cuộc thảo luận kỹ lưỡng hơn về việc xử lý UTF-8 có trong phần “Storing UTF-8 Encoded Text with Strings” ở chương 8.
Với tất cả thông tin này, chúng ta hãy viết lại first_word
để return một slice. Kiểu biểu thị“string slice” được viết là &str
:
Filename: src/main.rs
fn first_word(s: &String) -> &str { let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } } &s[..] } fn main() {}
Chúng ta nhận được index cho cuối từ theo cách giống như chúng tôi đã làm trong Listing 4-7, bằng cách tìm kiếm sự xuất hiện đầu tiên của một khoảng trắng. Khi chúng tôi tìm thấy một khoảng trắng, chúng ta trả về một string slice sử dụng nơi bắt đầu của string và index của khoảng trắng làm chỉ số bắt đầu và kết thúc.
Bây giờ khi chúng ta gọi first_word
, chúng ta nhận lại một giá trị duy nhất được liên kết với dữ liệu cơ bản. Giá trị được tạo thành từ tham chiếu đến điểm bắt đầu của slice và số phần tử trong slice.
Trả lại một slice cũng sẽ hoạt động cho một hàm second_word
:
fn second_word(s: &String) -> &str {
Giờ đây, chúng tôi có một API đơn giản và khó bị xáo trộn hơn nhiều, vì trình biên dịch sẽ đảm bảo các tham chiếu vào String
vẫn hợp lệ. Hãy nhớ lỗi trong chương trình trong Listing 4-8, khi chúng ta nhận được index của cuối từ đầu tiên nhưng sau đó xóa chuỗi nên index của chúng ta không hợp lệ? Code đó không chính xác về mặt logic nhưng không hiển thị bất kỳ lỗi nào ngay lập tức. Các vấn đề sẽ xuất hiện sau đó nếu chúng tôi tiếp tục cố gắng sử dụng index của từ đầu tiên với một chuỗi trống. Slices khiến lỗi này không thể xảy ra và cho chúng ta biết rằng chúng ta gặp sự cố với code của mình sớm hơn nhiều. Sử dụng phiên bản slice của first_word
wsẽ gây ra lỗi biên dịch:
Filename: src/main.rs
fn first_word(s: &String) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..]
}
fn main() {
let mut s = String::from("hello world");
let word = first_word(&s);
s.clear(); // error!
println!("the first word is: {}", word);
}
Here’s the compiler error:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:18:5
|
16 | let word = first_word(&s);
| -- immutable borrow occurs here
17 |
18 | s.clear(); // error!
| ^^^^^^^^^ mutable borrow occurs here
19 |
20 | println!("the first word is: {}", word);
| ---- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error
Hãy nhớ lại các quy tắc borrowing rằng nếu chúng ta có một tham chiếu bất biến đến một cái gì đó, chúng ta cũng không thể lấy một tham chiếu có thể thay đổi được. Vì clear
cần phải cắt bớt String
, nó cần nhận được một tham chiếu có thể thay đổi. println!
sau lệnh gọi clear
sử dụng tham chiếu trong word
, vì vậy tham chiếu bất biến phải vẫn hoạt động tại thời điểm đó. Rust không cho phép tham chiếu có thể thay đổi trong clear
và tham chiếu bất biến trong word
tồn tại cùng một lúc, và biên dịch không thành công. Rust không chỉ làm cho API của chúng ta dễ sử dụng hơn mà còn loại bỏ toàn bộ lớp lỗi tại thời điểm biên dịch!
String Literals là Slices
Nhớ lại rằng chúng ta đã nói về string literals .được lưu trữ bên trong tệp nhị phân. Bây giờ chúng ta biết về slices, chúng ta có thể hiểu đúng về string literals:
#![allow(unused)] fn main() { let s = "Hello, world!"; }
Kiểu của s
ở đây là &str
: nó là một slice chỉ đến điểm cụ thể của tệp nhị phân. Đây cũng là lý do tại sao string literals là bất biến; &str
là một tham chiếu bất biến.
String Slices như là các tham số (String Slices as Parameters)
Biết rằng bạn có thể lấy slices trong tập hợp các chữ và giá trị String
dẫn chúng ta đến một cải tiến nữa trên first_word
, và đó là signature của nó:
fn first_word(s: &String) -> &str {
Một Rustacean có kinh nghiệm hơn sẽ viết signature trong Listing 4-9 vì nó cho phép chúng ta sử dụng cùng một hàm trên cả giá trị &String
và giá trị &str
.
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 my_string = String::from("hello world");
// `first_word` works on slices of `String`s, whether partial or whole
let word = first_word(&my_string[0..6]);
let word = first_word(&my_string[..]);
// `first_word` also works on references to `String`s, which are equivalent
// to whole slices of `String`s
let word = first_word(&my_string);
let my_string_literal = "hello world";
// `first_word` works on slices of string literals, whether partial or whole
let word = first_word(&my_string_literal[0..6]);
let word = first_word(&my_string_literal[..]);
// Because string literals *are* string slices already,
// this works too, without the slice syntax!
let word = first_word(my_string_literal);
}
Listing 4-9: Cải tiến hàm first_word
bằng cách sử dụng một string slice cho kiểu của tham số s
Nếu chúng ta có một string slice, chúng ta có thể truyền vào trực tiếp. Nếu chúng ta có một String
, chúng ta có thể truyền một slice của String
hoặc một tham chiếu đến String
. Sự linh hoạt này tận dụng lợi thế của deref coercions, một tính năng chúng ta sẽ đề cập trong phần “Implicit Deref Coercions with Functions and Methods” của Chương 15. Việc xác định một hàm để lấy một string slice thay vì tham chiếu đến một String
làm cho API của chúng ta trở nên tổng quát và hữu ích hơn mà không làm mất bất kỳ chức năng nào:
Filename: src/main.rs
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 my_string = String::from("hello world"); // `first_word` works on slices of `String`s, whether partial or whole let word = first_word(&my_string[0..6]); let word = first_word(&my_string[..]); // `first_word` also works on references to `String`s, which are equivalent // to whole slices of `String`s let word = first_word(&my_string); let my_string_literal = "hello world"; // `first_word` works on slices of string literals, whether partial or whole let word = first_word(&my_string_literal[0..6]); let word = first_word(&my_string_literal[..]); // Because string literals *are* string slices already, // this works too, without the slice syntax! let word = first_word(my_string_literal); }
Kiểu Slices khác (Other Slices)
String slices, như bạn có thể tưởng tượng, dành riêng cho chuỗi. Nhưng cũng có một kiểu slice chung chung hơn. Hãy xem xét mảng này:
#![allow(unused)] fn main() { let a = [1, 2, 3, 4, 5]; }
Cũng giống như chúng ta có thể muốn tham chiếu đến một phần của chuỗi, chúng ta có thể muốn tham chiếu đến một phần của mảng. Chúng tôi sẽ làm như thế này:
#![allow(unused)] fn main() { let a = [1, 2, 3, 4, 5]; let slice = &a[1..3]; assert_eq!(slice, &[2, 3]); }
Slice này có kiểu &[i32]
. Nó hoạt động theo cách tương tự như string slices, bằng cách lưu trữ một tham chiếu đến phần tử đầu tiên và độ dài. Bạn sẽ sử dụng loại slice này cho tất cả các loại tập hợp khác. Chúng ta sẽ thảo luận chi tiết về các tập hợp này khi chúng ta nói về vectơ trong Chương 8.
Summary
Các khái niệm về ownership, borrowing, và slices đảm bảo an toàn cho bộ nhớ trong các chương trình Rust tại thời điểm biên dịch. Ngôn ngữ Rust cho phép bạn kiểm soát việc sử dụng bộ nhớ của mình giống như các ngôn ngữ lập trình hệ thống khác, nhưng có tự động xóa dữ liệu đó khi owner vượt ra khỏi scope có nghĩa là bạn không phải viết và gỡ lỗi thêm code để có được quyền kiểm soát này.
Ownership aảnh hưởng đến cách hoạt động của nhiều phần khác của Rust, vì vậy, chúng ta sẽ nói thêm về những khái niệm này trong suốt phần còn lại của cuốn sách. Hãy chuyển sang Chương 5 và xem xét việc nhóm các phần dữ liệu lại với nhau trong struct
.
Sử dụng Structs để "đóng gói" các trường dữ liệu có liên quan
Một struct, hay structure, có thể coi là một kiểu dữ liệu mà lập trình viên tự định nghĩa, được tạo ra để nhóm các giá trị có mối liên hệ với nhau và tạo thành một tập giá trị có ý nghĩa. Nếu bạn đã quen thuộc với lập trình hướng đối tượng (object-oriented language - OOP), struct giống như khái niệm object ở trong đó. Trong chương này, chúng ta sẽ so sánh struct trong Rust và kiểu struct mà bạn đã biết, khi nào nên sử dụng struct, làm cách nào để định nghĩa và khởi tạo một struct, hay làm sao để tạo ra một associated function (một trong những associated function phổ biến đó chính là method). Method trong Rust cũng tương tự như trong OOP, dùng để mô tả một hành vi (behavior) cụ thể của một struct. Structs và enums (trong chương 6) là một trong những cách tạo kiểu dữ liệu mới mà có thể tận dụng tối đa tính năng kiểm tra kiểu dữ liệu (type checking) tại thời điểm biên dịch (compile time).
Định nghĩa và khởi tạo Structs
Một số thuật ngữ:
- instance: thực thể
- mutable: có thể thay đổi được
Structs tương tự như tuples (trình bày tại phần "The Tuple Type"), đó là chúng đều giữ các giá trị có mối liên hệ với nhau. Một điểm chung nữa đó là các thành phần bên trong struct và tuple có thể khác kiểu dữ liệu. Tuy nhiên, sự khác nhau cơ bản ở đây là các phần tử trong struct sẽ được đặt tên tương ứng cho từng trường, làm cho struct sẽ có ý nghĩa rõ ràng hơn so với tuple. Có thể gán tên đồng nghĩa với việc struct sẽ linh hoạt hơn tuple: ví dụ, bạn sẽ không phải dựa vào thứ tự của các phân tử để truy cập giá trị.
Để định nghĩa một struct, chúng ta sử dụng từ khóa struct
kèm theo tên struct đó. Tên của struct nên đặt một cách gợi nhớ và có ý nghĩa. Sau đó, bên trong cặp ngoặc nhọn, ta sẽ định nghĩa tên và kiểu dữ liệu cho từng phần tử , hay "trường dữ liệu" (được gọi là field) trong struct đó. Ví dụ, mục 5-1 thể hiện một struct lưu trữ thông tin về một tài khoản của người dùng.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn main() {}
Listing 5-1: Định nghĩa một struct có tên User
Để sử dụng struct sau khi đã định nghĩa, chúng ta sẽ tạo ra một instance của struct đó bằng cách đặt giá trị cho từng trường. Một instance được tạo ra bắt đầu bằng tên struct, bên trong cặp ngoặc nhọn sẽ chứa các cặp khóa: giá trị
(key: value
), trong đó keys đại diện cho tên của từng trường và value thể hiện cho giá trị cần lưu của trường đó trong struct. Nói một cách khác, struct như một bản mẫu chung cho kiểu dữ liệu, còn instances sẽ hoàn thiện struct đó bằng cách điền các giá trị vào mẫu chung đó. Ví dụ, ta có thể khởi tạo một user cụ thể như sau.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn main() { let user1 = User { email: String::from("[email protected]"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; }
Listing 5-2: Tạo một instance "User"
Để lấy giá trị của các trường trong struct, ta sử dụng dấu chấm. Nếu bạn muốn lấy ra địa chỉ email của user, có thể dùng user1.email
. Nếu instance có thể thay đổi được (mutable), ta có thể thay đổi giá trị của bất kì trường nào mà mình muốn. Listing 5-3 cho ta thấy làm sao để thay đổi email
trong instance User
.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn main() { let mut user1 = User { email: String::from("[email protected]"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; user1.email = String::from("[email protected]"); }
Listing 5-3: Thay đổi email trong instance "User"
Chú ý rằng instance(thực thể) này phải thay đổi được (mutable); Rust không cho phép chúng ta đánh dấu mutable cho các trường dữ liệu bên trong struct. Ta cũng có thể tạo ra một instance và đặt nó ở cuối của thân hàm (last expression) để ngầm định giá trị trả về cho hàm đó.
Listing 5-4 cho ta thấy một hàm build_user
trả về một User
instance với email và username. Trường active
có giá trị true
và trường sign_in_count
có giá trị 1.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn build_user(email: String, username: String) -> User { User { email: email, username: username, active: true, sign_in_count: 1, } } fn main() { let user1 = build_user( String::from("[email protected]"), String::from("someusername123"), ); }
Listing 5-4: Hàm build_user
trả về User
instance với email và username
Đặt tên các tham số truyền vào của hàm trùng với tên của các trường trong struct sẽ giúp chương trình dễ đọc hơn, tuy nhiên việc này sẽ khiến ta cảm thấy hơi "khó chịu" nếu gặp một struct phức tạp. May mắn thay, ta đã có một cách thuận tiện hơn!
Khởi tạo vắn tắt (Field Init Shorthand)
Nếu tham số truyền vào trùng tên với tên trường dữ liệu, ta có thể sử dụng cú pháp vắn tắt (field init shorthand) để viết lại như sau.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn build_user(email: String, username: String) -> User { User { email, username, active: true, sign_in_count: 1, } } fn main() { let user1 = build_user( String::from("[email protected]"), String::from("someusername123"), ); }
Listing 5-5: Hàm build_user
sử dụng cách khởi tạo mới bởi vì email
và username
ở tham số truyền vào trùng tên với tên trường dữ liệu struct
Ở đây, chúng ta tạo mới một instance của User struct, có trường email
. Ta cũng muốn gán giá trị của trường email
bởi giá trị của tham số email
truyền vào hàm build_user
. Do chúng đều có cùng tên, nên ta chỉ cần viết email
thay vì email:email
.
Tạo Instances từ Instances khác với Struct Update Syntax
Việc tạo ra một instance từ một instance khác gần giống nó là một việc làm rất phổ biến trong lập trình. Với Rust, bạn có thể sử dụng struct update syntax.
Đầu tiên, Listing 5-6 sẽ cho ta thấy cách tạo User instance một cách thông thường, không sử dụng update syntax. Ta sẽ gán giá trị mới cho trường email
, còn các trường còn lại sẽ giữ nguyên như ở user1
trong Listing 5-2.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn main() { // --snip-- let user1 = User { email: String::from("[email protected]"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; let user2 = User { active: user1.active, username: user1.username, email: String::from("[email protected]"), sign_in_count: user1.sign_in_count, }; }
Listing 5-6: Tạo mới User
instance sử dụng lại một vài giá trị của user1
Sử dụng struct syntax update, ta có thể có kết quả tương tự nhưng với ít dòng code hơn, như ở Listing 5-7. Cú pháp ..
chú thích rằng các trường còn lại không được khai báo một cách tường minh sẽ có cùng một giá trị với instance cho trước.
struct User { active: bool, username: String, email: String, sign_in_count: u64, } fn main() { // --snip-- let user1 = User { email: String::from("[email protected]"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; let user2 = User { email: String::from("[email protected]"), ..user1 }; }
Listing 5-7: Sử dụng struct update syntax để gán giá trị cho
email
của User
instance nhưng sử dụng các giá trị còn lại từ user1
Đoạn code ở Listing 5-7 tạo ra instance user2
khác email
nhưng lại giống username
, active
và sign_in_count
với user1
. Cú pháp ..user1
phải được đặt ở cuối để thể hiện rằng các giá trị còn lại sẽ phải bằng với các trường tương ứng của user1
.
Chú ý rằng struct update syntax sử dụng =
như một phép gán; điều này có đươc là bởi vì nó đã chuyển quyền sở hữu dữ liệu (move), như chúng ta đã biết trong phần “Ways Variables and Data Interact: Move”. Ở trong ví dụ này, ta không thể sử dung user1
sau khi đã tạo user2
vì String
trong trường username
của user1
đã chuyển quyền sở hữu (move) vào trong user2
. Do đó, ta chỉ có thể sử dụng active
và sign_in_count
từ user1
. Kiểu dữ liệu của active
và sign_in_count
là những kiểu đã implement Copy
trait, các bạn có thể xem thêm phần “Stack-Only Data: Copy” để hiểu hơn.
Sử dụng Tuple Structs
Rust cũng hỗ trợ tạo structs trông giống như tuples, được gọi là tuple struct. Tuple structs không có tên của các trường dữ liệu trong struct đó; chúng chỉ có các kiểu dữ liệu. Tuple structs rất hữu dụng khi bạn muốn tạo cho tuple đó một cái tên và khiến cho chúng nổi bật hơn so với những tuples còn lại.
Để định nghĩa một tuple struct, hãy bắt đầu với từ khóa struct
và tên của struct, sau đó đến kiểu dữ liệu trong tuple. Ví dụ, hãy tạo hai tuple structs có tên là Color
và Point
:
struct Color(i32, i32, i32); struct Point(i32, i32, i32); fn main() { let black = Color(0, 0, 0); let origin = Point(0, 0, 0); }
Chú ý rằng black
và origin
có kiểu dữ liệu khác nhau. Mỗi struct bạn định nghĩa đều có kiểu riêng của nó, kể cả khi các trường trong struct đó có chung một kiểu dữ liệu. Ví dụ, một hàm truyền tham số kiểu Color
không thể nhận tham số truyền vào kiểu Point
, kể cả khi chúng đều có chung kiểu dữ liệu của từng trường (là i32
). Mặt khác, instance của tuple struct có thể sự dụng như một tuple: bạn có thể tách chúng thành nhiều phần bằng cách sử dụng .
để truy cập đến từng trường.
Unit-like Structs
Bạn có thể định nghĩa một struct mà không hề có bất kì một trường dữ liệu nào! Những kiểu structs này được gọi là unit-like structs vì chúng tương tự như ()
, là một kiểu dữ liệu được đề cập trong phần “The Tuple Type”. Unit-like structs rất thích hợp khi bạn muốn implement một trait và không có bất kì dữ liệu nào cần lưu trữ. Ta sẽ bàn thêm về trait ở chương 10. Sau đây là ví dụ về việc tạo unit struct có tên là AlwaysEqual
.
struct AlwaysEqual; fn main() { let subject = AlwaysEqual; }
Để định nghĩa AlwaysEqual
, ta sử dụng từ khóa struct
đi kèm với tên mình muốn, kết thúc bởi dấu chấm phẩy và không cần có ngoặc nhọn hay ngoặc đơn đi kèm! Khi đó ta có thể tạo ra một instance của AlwaysEqual
là subject
.
Ownership of Struct Data
User struct định nghĩa ở Listing 5-1 dùng kiểu String thay vì dùng &str. Việc này là có chủ ý vì ta muốn struct sở hữu toàn bộ dữ liệu bên trong nó, như vậy vòng đời của dữ liệu sẽ ngang bằng với vòng đời của struct.
Struct hoàn toàn có thể lưu trữ các tham chiếu, nhưng để làm được điều đó thì cần sử dụng tới lifetimes, một tính năng của Rust sẽ được đề cập đến trong chương 10. Lifetimes sẽ đảm bảo rằng dữ liệu trong struct sẽ có vòng đời ít nhất là ngang với vòng đời của chính struct đó. Nếu bạn làm như ví dụ sau, lỗi sẽ xảy ra:
Filename: src/main.rs
struct User { active: bool, username: &str, email: &str, sign_in_count: u64, } fn main() { let user1 = User { email: "[email protected]", username: "someusername123", active: true, sign_in_count: 1, }; }
Compiler sẽ nói rằng bạn cần dùng lifetime:
p
$ cargo run Compiling structs v0.1.0 (file:///projects/structs) error[E0106]: missing lifetime specifier --> src/main.rs:3:15 | 3 | username: &str, | ^ expected named lifetime parameter | help: consider introducing a named lifetime parameter | 1 ~ struct User<'a> { 2 | active: bool, 3 ~ username: &'a str, | error[E0106]: missing lifetime specifier --> src/main.rs:4:12 | 4 | email: &str, | ^ expected named lifetime parameter | help: consider introducing a named lifetime parameter | 1 ~ struct User<'a> { 2 | active: bool, 3 | username: &str, 4 ~ email: &'a str, | For more information about this error, try `rustc --explain E0106`. error: could not compile `structs` due to 2 previous errors
Trong chương 10, ta sẽ tìm hiểu cách để sửa lỗi trên. Còn hiện tại, hãy cứ sử dụng String thay vì &str.
Một vài ví dụ khi sử dụng Structs
Để hiểu khi nào ta nên dùng structs, hãy cùng đến với một ví dụ về chương trình tính toán diện tích hình chữ nhật. Ta sẽ bắt đầu với việc sử dụng các biến đơn, sau đó sẽ thay thế bằng struct để so sánh.
Đầu tiền, tạo một binary project với Cargo đặt tên là rectangles, có đầu vào là chiều dài và chiều rộng của một hình chữ nhật cụ thể và sau đó tính toán ra diện tích của hình chữ nhật đó. Listing 5-8 cho ta thấy một đoạn code mẫu cho chương trình trên.
Filename: src/main.rs
fn main() { let width1 = 30; let height1 = 50; println!( "The area of the rectangle is {} square pixels.", area(width1, height1) ); } fn area(width: u32, height: u32) -> u32 { width * height }
Listing 5-8: Tính diện tích của hình chữ nhật với chiều dài và chiều rộng cho trước
Chạy chương trình với cargo run
:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished dev [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.
Ta có thể chỉnh sửa một chút để code rõ ràng và dễ đọc hơn...
fn main() {
let width1 = 30;
let height1 = 50;
println!(
"The area of the rectangle is {} square pixels.",
area(width1, height1)
);
}
fn area(width: u32, height: u32) -> u32 {
width * height
}
Hàm area
tính toán diện tích của một hình chữ nhật, sử dụng 2 tham số, như vậy chương trình sẽ không rõ ràng và ta không thấy được mối quan hệ giữa các tham số. Để cải thiện điều này, có thể nhóm 2 tham số này lại với nhau. Ở phần “The Tuple Type” của chương 3, việc sử dụng tuple sẽ giúp ích trong trường hợp này.
Chỉnh sửa code với Tuples
Listing 5-9 là một cách làm khác sử dụng tuples.
Filename: src/main.rs
fn main() { let rect1 = (30, 50); println!( "The area of the rectangle is {} square pixels.", area(rect1) ); } fn area(dimensions: (u32, u32)) -> u32 { dimensions.0 * dimensions.1 }
Listing 5-9: Nhóm chiều dài và chiều rộng của hình chữ nhật vào trong tuple
Chương trình này cũng có điểm tốt và chưa tốt. Điểm tốt ở chỗ các tham số đã được nhóm lại và trông có cấu trúc hơn, hàm lúc này chỉ cần nhận một tham số. Tuy nhiên, điểm trừ là tuple sẽ không rõ ràng tên các tham số, ta không biết đâu là chiều dài và đâu là chiều rộng.
Việc lẫn lộn giữa chiều dài và chiều rộng sẽ không phải vấn đề trong trường hợp tính diện tích, nhưng giả sử yêu cầu bài toán là vẽ hình chữ nhật, lúc này sẽ có vấn đề xảy ra! Bạn có thể nhớ trong đầu rằng phần tử 0
là chiều dài và phần tử 1
là chiều rộng. Tuy nhiên sẽ gây khó khăn cho người khác nếu họ sử dụng code của bạn.
Chỉnh sửa code dùng struct: làm rõ nghĩa chương trình
Ta sử dụng structs để gán nhãn cho dữ liệu, làm chúng dễ đọc hơn. Sử dụng struct cho bài toán trên như sau.
Filename: src/main.rs
struct Rectangle { width: u32, height: u32, } fn main() { let rect1 = Rectangle { width: 30, height: 50, }; println!( "The area of the rectangle is {} square pixels.", area(&rect1) ); } fn area(rectangle: &Rectangle) -> u32 { rectangle.width * rectangle.height }
Listing 5-10: Định nghĩa một Rectangle
struct
Ta sẽ tạo ra một struct có tên Rectangle
. Bên trong có 2 trường width
và height
đều có kiểu u32
. Trong hàm main
, một instance sẽ được tạo ra với chiều dài bằng 50 và chiều rộng bằng 30.
Hàm area
bây giờ chỉ có một tham số duy nhất có tên rectangle
. Như đã đề cập trong chương 4, ta nên mượn (borrow) struct hơn là lấy quyền sở hữu của nó, main
lúc này sẽ giữ lại quyền sở hữu của rect1
.
Thêm các chức năng hữu dụng khác với Derived Traits
Sẽ rất tuyệt với nếu ta có thể in ra màn hình cả một struct trong khi debug. Listing 5-11 sử dụng println!
macro mà chúng ta thường dùng trong các chương trước. Tuy nhiên, sẽ xảy ra lỗi.
Filename: src/main.rs
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!("rect1 is {}", rect1);
}
Listing 5-11: In Rectangle
instance ra console
Khi biên dịch đoạn code này, lỗi sẽ xảy ra với message:
error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`
Macro println!
có thể dùng cho rất nhiều định dạng, mặc định, cặp ngoặc nhọn {}
sẽ chỉ dẫn cho println!
sử dụng một loại định dạng có tên là Display
. Các kiểu dữ liệu nguyên thủy (primitive types) đều implement Display
. Nhưng với structs, mọi thứ sẽ khác, do có rất nhiều cách để thể hiện một struct: có dùng dấu phẩy hay không, có muốn in dấu ngoặc nhọn hay không, ... Vì vậy mặc định structs sẽ không implement Display
.
Nếu bạn để ý lỗi in ra màn hình, bạn có thể tìm được giải pháp:
= help: the trait `std::fmt::Display` is not implemented for `Rectangle`
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
Hãy thử cách này! Macro println!
sẽ sử dụng {:?}
. Cách này giúp cho macro println!
sử dụng kiểu định dạng có tên là Debug
. Debug
cho phép ta in một struct ra console, rất thuận tiền trong quá trình debug code.
Biên dịch chương trình với cách mới. Ta vẫn sẽ gặp lỗi:
error[E0277]: `Rectangle` doesn't implement `Debug`
Nhưng một lần nữa, compiler lại cho ta một gợi ý:
= help: the trait `Debug` is not implemented for `Rectangle`
= note: add `#[derive(Debug)]` to `Rectangle` or manually `impl Debug for Rectangle`
Ta phải khai báo tường minh một outer attribute #[derive(Debug)]
ngay trên phần định nghĩa struct, như Listing 5-12.
Filename: src/main.rs
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } fn main() { let rect1 = Rectangle { width: 30, height: 50, }; println!("rect1 is {:?}", rect1); }
Listing 5-12: Thêm attribute để sử dụng Debug
trait và in ra màn hình Rectangle
instance
Chạy chương trình, ta sẽ nhận được kết quả:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished dev [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }
Tuyệt! Output này chưa dễ nhìn lắm, tuy nhiên nó đã đáp ứng được việc thể hiện ra tất cả các trường dữ liệu. Ngoài ra, có thể sử dụng {:#?}
để in ra dễ nhìn hơn.
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished dev [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/rectangles`
rect1 is Rectangle {
width: 30,
height: 50,
}
Một cách khác để có thể in struct ra màn hình là sử dụng macro dbg!
macro, chiếm quyền sở hữu, in ra tên file, số dòng mà dbg!
được gọi cùng với kết quả mong muốn, trả lại quyền sở hữu (ownership).
Chú ý: Macro
dbg!
sử dụng chuẩnstderr
(StandardError) để in ra màn hình, khác vớiprintln!
sử dụngstdout
(StandardOutput). Ta sẽ bàn rõ hơn vềstderr
vàstdout
ở phần “Writing Error Messages to Standard Error Instead of StandardOutput” trong chương 12.
Dưới đây là một ví dụ về việc in giá trị của width
cũng như của struct rect1
ra màn hình:
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } fn main() { let scale = 2; let rect1 = Rectangle { width: dbg!(30 * scale), height: 50, }; dbg!(&rect1); }
Ta có thể đặt 30 * scale
vào trong dbg!
, vì dbg!
ngay sau đó sẽ trả về quyền sở hữu của giá trị truyền vào, trường width
vẫn sẽ có cùng giá trị ngay cả khi có dbg!
hay không. Macro dgb!
không nên chiếm quyền sở hữu (ownership) của rect1
, vì vậy ta sẽ dùng tham chiều trong trường hợp này:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished dev [unoptimized + debuginfo] target(s) in 0.61s
Running `target/debug/rectangles`
[src/main.rs:10] 30 * scale = 60
[src/main.rs:14] &rect1 = Rectangle {
width: 60,
height: 50,
}
Nhìn vào dòng số 10, ta sẽ nhận được 30 * scale
và sau đó nó sẽ trả về giá trị là 60 (Debug
implement cho kiểu integers sẽ chỉ in ra giá trị mà thôi). Dòng số 14 sẽ in ra toàn bộ struct rect1
. Tóm lại, macro dbg!
sẽ hữu dụng khi bạn muốn tìm hiểu xem đoạn code này đang làm gì!
Ngoài kiểu trait là Debug
, Rust cung cấp rất nhiều các traits khác để sử dụng với derive
attribute giúp lập trình viên có thể tùy chỉnh rất nhiều thứ theo ý muốn. Traits và cách sử dụng chúng được nói trong phần Appendix C. Ta sẽ bàn về việc làm sao để implement traits theo ý muốn ở chương 10. Ngoài derive
, ta còn có rất nhiều các attributes khác; tất cả có trong phần the “Attributes” section of the Rust Reference.
Hàm area
được tạo ra ở đây với mục đích rất cụ thể: tính toán diện hình chữ nhật. Vì vậy, nếu ta khiến cho hàm này trở nên "gần gũi" hơn với struct Rectangle
, code khi đó sẽ rõ ràng hơn bởi area
không sử dụng được với kiểu dữ liệu khác ngoài Rectangle
. Bài sau sẽ giới thiệu một cách tiếp cận khác: chuyển từ hàm (function) area
thành phương thức (method) area
của kiểu Rectangle
.
Phương thức (method)
Các thuật ngữ:
- block: Khối lệnh {}
- Asscociated Functions: Hàm liên kết
- Method: Phương thức
Method (phương thức) khá tương đồng với functions (hàm) ở điểm: đều sử dụng từ khóa fn
kèm theo tên, đều có tham số truyền vào và giá trị trả về, đều chứa các đoạn code để thực thi khi được gọi trong chương trình. Điểm khác biệt với functions ở chỗ, methods được định nghĩa ở bên trong struct (có thể là enum hoặc trait, ta sẽ đi sâu hơn trong chương 6 và 17); tham số đầu tiên của method luôn là self
, đại diện cho instance của struct đó.
Định nghĩa phương thức
Biến đổi hàm area
thành phương thức area
như sau:
Filename: src/main.rs
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } impl Rectangle { fn area(&self) -> u32 { self.width * self.height } } fn main() { let rect1 = Rectangle { width: 30, height: 50, }; println!( "The area of the rectangle is {} square pixels.", rect1.area() ); }
Listing 5-13: Định nghĩa một phương thức area
thuộc struct Rectangle
Để định nghĩa các phương thức của Rectangle
, ta sẽ sử dụng từ khóa impl
(implementation) kèm theo một cú pháp {} (block) của Rectangle
. Mọi thứ ở trong impl
block sẽ thuộc về Rectangle
. Tiếp theo, đưa hàm area
vào bên trong impl
block và thêm self
vào làm tham số đầu tiên của hàm đó. Trong hàm main
, sử dụng method syntax để gọi phương thức area
của Rectangle
instance. Cú pháp ở đây được sử dụng bằng cách thêm dấu chấm sau khi gọi instance.
Phần khai báo của area
, ta sử dụng &self
thay vì rectangle: &Rectangle
, &self
là viết tắt của self: &Self
. Ở trong impl
block, Self
đại diện cho kiểu dữ liệu mà nó được implement. Method phải có tham số self
ở đầu tiên, vì vậy Rust giúp ta viết thuận tiện hơn với việc chỉ cần &self
thay vì self: &Self
. Để ý rằng vẫn cần có &
ở trước self
để báo hiệu việc mượn instance. Method có thể chiếm quyền sở hữu của self
, vì vậy ta cần cân nhắc khi sử dụng.
Sử dụng &self
bởi cũng giống như &Rectangle
: ta không muốn chiếm quyền sở hữu của biến, chỉ cần mượn để đọc. Nếu muốn thay đổi giá trị của instance, hãy sử dụng &mut self
làm tham số đầu tiên của method. Method chiếm quyền sở hữu của instance bằng cách dùng self
rất ít khi được dùng; kĩ thuật này chỉ được sử dụng khi ta không muốn người gọi phương thức có thể sử dụng tiếp instance này sau khi gọi mà thôi.
Mục đích chính của việc sử dụng method thay vì function đó là: có thể nhóm mọi thứ liên quan đến instance của một kiểu dữ liệu vào với nhau, giúp cho việc quản lí code cũng như bảo trì code sau này trở nên dễ dàng hơn.
Chú ý rằng ta có thể đặt tên method trùng với tên trường của struct. Ví dụ, method width
của Rectangle
:
Filename: src/main.rs
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } impl Rectangle { fn width(&self) -> bool { self.width > 0 } } fn main() { let rect1 = Rectangle { width: 30, height: 50, }; if rect1.width() { println!("The rectangle has a nonzero width; it is {}", rect1.width); } }
Ở đây, phương thức width
sẽ trả về true
nếu giá trị của width
lớn hơn 0, và false
nếu trong trường hợp còn lại. Trong hàm main
, nếu sử dụng rect1.width()
, Rust sẽ hiểu đây là method width
, nếu không có cặp ngoặc tròn ()
, Rust sẽ hiểu đây là trường width
.
Thông thường, ta sẽ đặt tên method trùng với tên trường nếu chỉ muốn trả về giá trị của chính trường đó. Những method dạng này được gọi là getters, Rust không implement chúng một cách tự động như những ngôn ngữ khác. Getters rất hữu dụng vì bạn có thể điều khiển được quyền truy cập biến, trường trong struct; cho phép trường đó có thể được thay đổi hay không, hay chỉ có quyền đọc mà thôi. Chủ đề về quyền truy cập (public và private) sẽ được nói đến trong chương 7.
Toán tử
->
Trong C và C++, có hai toán tử được dùng để gọi method: dùng
.
nếu bạn đang dùng trực tiếp object để gọi method, dùng->
nếu gọi method dùng con trỏ trỏ đến object đó.Rust không hỗ trợ toán tử
->
; thay vào đó, Rust cung cấp tính năng được gọi là automatic referencing and dereferencing.Đây là cách hoạt động: mỗi khi bạn gọi một method như
object.something()
, Rust sẽ tự động thêm&
,&mut
hay*
vào object. Xem xét ví dụ sau:#![allow(unused)] fn main() { #[derive(Debug,Copy,Clone)] struct Point { x: f64, y: f64, } impl Point { fn distance(&self, other: &Point) -> f64 { let x_squared = f64::powi(other.x - self.x, 2); let y_squared = f64::powi(other.y - self.y, 2); f64::sqrt(x_squared + y_squared) } } let p1 = Point { x: 0.0, y: 0.0 }; let p2 = Point { x: 5.0, y: 6.5 }; p1.distance(&p2); (&p1).distance(&p2); }
Cách gọi method
p1.distance
phía trên sẽ dễ nhìn hơn cách phía dưới. Rust sẽ tự động thêm tham chiếu cho p1, ngoài ra Rust có thể kiểm tra được khi nào method chỉ được đọc (&self
), có thể thay đổi đươc (&mut self
) hay consuming (self
). Đây là một cơ chế khá hay mà Rust hỗ trợ cho chúng ta trong quá trình lập trình.
Methods nhiều tham số
Lần này ta sẽ thử implement thêm method thứ 2 của Rectangle
struct. Method này có nhiệm vụ kiểm tra xem hình chữ nhật truyền vào có đặt vừa vào bên trong hình chữ nhật cho trước hay không. Method này sẽ có tên là can_hold
với kiểu trả về là bool
:
Filename: src/main.rs
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
Listing 5-14: Sử dụng can_hold
method
Output sẽ trông giống như bên dưới, vì cả 2 chiều của rect2
đều nhỏ hơn rect1
còn rect3
thì lớn hơn rect1
:
Can rect1 hold rect2? true
Can rect1 hold rect3? false
Method mới này cũng sẽ được đặt trong impl Rectangle
block. Đặt tên cho method là can_hold
, có tham số truyền vào là một Rectangle
khác. Như đoạn code dưới đây:
Filename: src/main.rs
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } impl Rectangle { fn area(&self) -> u32 { self.width * self.height } fn can_hold(&self, other: &Rectangle) -> bool { self.width > other.width && self.height > other.height } } fn main() { let rect1 = Rectangle { width: 30, height: 50, }; let rect2 = Rectangle { width: 10, height: 40, }; let rect3 = Rectangle { width: 60, height: 45, }; println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2)); println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3)); }
Listing 5-15: Implementing can_hold
method của struct Rectangle
Hàm liên kết (Associated Functions)
Tất cả các hàm được định nghĩa bên trong impl
đều được gọi là associated functions vì chúng đều có liên quan đến struct được impl
. Ta có thể định nghĩa associated functions mà không có self
làm tham số truyền vào (do đó không gọi là methods) vì chúng không cần instance của struct đó để hoạt động. Ví dụ như hàm from
trong String::from
là một associated function.
Những associated functions mà không phải là method thường được dùng để khởi tạo instance cho struct.
Filename: src/main.rs
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } impl Rectangle { fn square(size: u32) -> Rectangle { Rectangle { width: size, height: size, } } } fn main() { let sq = Rectangle::square(3); }
Để gọi một associated function, sử dụng dấu ::
với tên của struct; let sq = Rectangle::square(3);
là một ví dụ. Cú pháp ::
được sử dụng cho cả associated functions và namespaces để khởi tạo modules. Ta sẽ bàn thêm trong chương 7.
Multiple impl
Blocks
Mỗi struct có thể có nhiều impl
blocks. Ví dụ , Listing 5-15 cũng tương đương với Listing 5-16, đều sở hữu các method như nhau.
#[derive(Debug)] struct Rectangle { width: u32, height: u32, } impl Rectangle { fn area(&self) -> u32 { self.width * self.height } } impl Rectangle { fn can_hold(&self, other: &Rectangle) -> bool { self.width > other.width && self.height > other.height } } fn main() { let rect1 = Rectangle { width: 30, height: 50, }; let rect2 = Rectangle { width: 10, height: 40, }; let rect3 = Rectangle { width: 60, height: 45, }; println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2)); println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3)); }
Listing 5-16: Viết lại Listing 5-15 sử dụng multiple impl
blocks
Không có mục đích cụ thể nào cho việc tạo nhiều impl
blocks cả, chỉ đơn giản là cú pháp này được chấp nhận trong Rust. Tuy nhiên đôi khi nó cũng khá hữu dụng, xem thêm chương 10 phần generic types và traits.
Tổng kết
Structs giúp bạn có thể tạo ra một kiểu dữ liệu mà mình mong muốn. Sử dụng structs, ta có thể nhóm các hàm, biến có mối liên hệ với nhau và làm cho code rõ ràng, dễ hiểu hơn. Khi impl
blocks, có 2 loại hàm là associated functions và method (một dạng đặc biệt của asscociated functions), giúp bạn thể hiện các hành vi (behavior) của instance đó.
Structs không phải là cách duy nhất để tạo một kiểu dữ liệu mới: hãy xem thêm kiểu enum trong Rust.
Enums và Mẫu Matching
Trong chương này chúng ta sẽ tìm hiểu về enumerations, còn được gọi là enums.
Enums cho phép bạn có thể định nghĩa một kiểu dữ liệu bằng cách liệt kê các kiểu dữ liệu của nó. Đầu tiên,
chúng ta sẽ định nghĩa và sử dụng một enum để chỉ cách một enum có thể mã hoá ý nghĩa cùng với dữ liệu.
Tiếp theo, chúng ta sẽ khá phá một enum đặc biệt hữu ích, được sử dụng rất nhiều trong Rust,
đó là Option
, điều này thể hiện một giá trị có thể có giá trị nào đó hoặc không.
Sau đó chúng ta sẽ cách sử dụng match
với enum giúp bạn dễ dàng chạy các đoạn
code khác nhau cho những giá trị khác nhau của một enum.
Cuối cùng, chúng ta sẽ đề cập đến cách sử dung if let
để xử lý các enum trong code của bạn
Enums là một tính năng được sử dụng trong nhiều ngôn ngữ lập trình, nhưng khả năng sử dụng của chúng khác nhau trong mỗi ngôn ngữ. Enum của Rust giống kiểu dữ liệu đại số trong ngôn ngữ lập trình chức năng, như là F#, OCaml và Haskell
Định nghĩa một Enum
Enums là định nghĩa một kiểu dữ liệu tuỳ chỉnh khác với structs. Hãy xem xét một tình huống chúng ta phải diễn đạt trong code và xem tại sao enums lại hữu ích và phù hợp hơn struct trong trường hợp này. Giả sử chúng ta làm việc với các địa chỉ IP. Hiện tại, 2 tiêu chuẩn chính được sử dụng cho địa chỉ IP là: Ipv4 và Ipv6. Bởi vì đây là khả năng duy nhất cho 1 địa chỉ IP mà chương trình của chúng ta sẽ bắt gặp, chúng ta có thể sử dụng enumerate để liệt kê hết các biến có thể có, which is where enumeration gets its name.
Bất kì địa chỉ IP nào cũng có thể là Ipv4 hoặc Ipv6, nhưng không phải cả 2 tại 1 thời điểm. Thuộc tính trên làm cho cấu trúc của enum thích hợp để sử dụng cho trường hợp này, bởi vì một enum chỉ có thể lấy 1 giá trị trong các loại của nó. Cả Ipv4 và Ipv6 về cơ bản vẫn là một địa chỉ IP, vì vậy nên chúng được coi là 1 loại giá trị khi đoạn code áp dụng cho bất kì loại địa chỉ IP nào.
Chúng ta có thể thực hành khái niệm trên trong code bằng cách khai báo 1 *enum" IpAddrKind
và
liệt kê các loại địa chỉ IP có thể có: V4
và V6
. Bên dưới là các loại của enum
enum IpAddrKind { V4, V6, } fn main() { let four = IpAddrKind::V4; let six = IpAddrKind::V6; route(IpAddrKind::V4); route(IpAddrKind::V6); } fn route(ip_kind: IpAddrKind) {}
IpAddrKind
là một kiểu dữ liệu tuỳ chỉnh mà ta có thể sử dụng ở những nơi khác nhau trong code của mình.
Enum Values
Chúng ta có thể tạo ra từng biến cho 2 loại IpAddrKind
giống như thế này:
enum IpAddrKind { V4, V6, } fn main() { let four = IpAddrKind::V4; let six = IpAddrKind::V6; route(IpAddrKind::V4); route(IpAddrKind::V6); } fn route(ip_kind: IpAddrKind) {}
Lưu ý rằng các loại của enum có thể đặt tên dưới định dang của nó, và chúng ta
sử dụng 2 dấu 2 chấm (::) để phân tách. Điều này rất có ích vì cả 2 giá trị
IpAddrKind::V4
và IpAddrKind::V6
đều có kiểu giá trị: IpAddrKind
. Chúng ta có thể định một hàm xử dụng
bất kì IpAddrKind
nào:
enum IpAddrKind { V4, V6, } fn main() { let four = IpAddrKind::V4; let six = IpAddrKind::V6; route(IpAddrKind::V4); route(IpAddrKind::V6); } fn route(ip_kind: IpAddrKind) {}
Và chúng ta có thể gọi hàm này với 1 trong 2 loại enum
enum IpAddrKind { V4, V6, } fn main() { let four = IpAddrKind::V4; let six = IpAddrKind::V6; route(IpAddrKind::V4); route(IpAddrKind::V6); } fn route(ip_kind: IpAddrKind) {}
Sử dụng enum thậm chí còn nhiều điểm mạnh hơn. Chúng tôi suy nghĩ thêm về địa IP, hiện tại chúng tôi không có cách nào để lưu trữ dữ liệu thực tế của địa chỉ IP; chúng tôi chỉ biết chúng là kiểu dữ liệu nào. Bạn mới học về cấu struct ở chương 5, bạn có thể giải quyết vấn đề này với truct như trong Listing 6-1.
fn main() { enum IpAddrKind { V4, V6, } struct IpAddr { kind: IpAddrKind, address: String, } let home = IpAddr { kind: IpAddrKind::V4, address: String::from("127.0.0.1"), }; let loopback = IpAddr { kind: IpAddrKind::V6, address: String::from("::1"), }; }
Listing 6-1: Lưu trữ dữ liệu IpAddrKind
bằng cách sử dụng struct
an IP address using a struct
Ở đây, chúng tôi dã định nghĩa một struct IpAddr
có 2 trường: trường kind
có kiểu dữ liệu là
IpAddrKind
(enum chúng ta đã định nghĩa trước đó) và một trường là address
có kiểu dữ liệu String
.
Chúng ta có 2 trường hợp của struct này. Đầu tiên là home
,
và nó có giá trị IpAddrKind::V4
như là kind
với địa chỉ của dữ liệu là 127.0.0.1
.
Trường hợp thứ 2 là loopback
. Nó là một trường hợp khác của IpAddrKind
giá trị kind
là V6
, và có địa chỉ ::1
liên kết với nó.
Chúng ta sử dụng 1 struct để nhóm giá trị kind
và address
với nhau, vì vậy hiện giờ biến thể được thể liên kết với nhau.
Tuy nhiên, đại diện cho cùng 1 khái niệm dùng một enum là ngắn gọn hơn: hơn là 1 enum bên trong 1 struct
, chúng ta có thể đưa dữ liệu trực tiếp vào từng trường hợp của enum.
Định nghĩa mới này của enum IpAddr
cho biết rằng cả 2 giá trị V4
and V6
sẽ có các giá trị String
:
fn main() { enum IpAddr { V4(String), V6(String), } let home = IpAddr::V4(String::from("127.0.0.1")); let loopback = IpAddr::V6(String::from("::1")); }
Chúng ta gán giá trị trực tiếp vào cho mỗi trường hợp enum,
vì vậy nên không cần thêm cấu trúc.
Tại đây, bạn cũng có thể dễ dàng xem một chi tiết khác về cách hoạt động của enum:
tên của mỗi trường hợp enum mà chúng ta định nghĩa đã trở thành một hàm tạo của enum.
Đó là, IpAddr::V4()
là một hàm sử dụng 1 String
là tham số và trả về một instance của kiểu IpAddr
.
Chúng tự động định nghĩa hàm khởi tạo này như là kết quả của định nghĩa một enum.
Có một lợi thế khác khi sử dụng enum thay vì cấu trúc: mỗi trường hợp trong enum có thể có
các loại dữ liệu khác nhau. Địa chỉ IP của V4
sẽ luôn có bốn thành phần số sẽ có giá trị từ 0 đến 255.
Nếu chúng tôi muốn lưu trữ địa chỉ V4
dưới dạng bốn giá trị u8 nhưng
vẫn diễn đạt được địa chỉ V6
là một giá trị String
, điều này không thể với struct.
Enums xử lý trường hợp này một cách dễ dàng:
fn main() { enum IpAddr { V4(u8, u8, u8, u8), V6(String), } let home = IpAddr::V4(127, 0, 0, 1); let loopback = IpAddr::V6(String::from("::1")); }
Chúng tôi đã chỉ ra một số cách khác nhau để xác định cấu trúc dữ liệu để lưu trữ địa chỉ IP V4
và V6
.
Tuy nhiên, hóa ra, muốn lưu trữ địa chỉ IP và mã hóa loại nào chúng rất phổ biến nên Rust
định nghĩa một thư viện chuẩn mà chúng ta có thể sử dụng!
Hãy xem cách thư viện chuẩn định nghĩa IpAddr
: nó có enum chính xác
và các trường hợp mà chúng ta định nghĩa và sử dụng,
nhưng nó nhúng dữ liệu địa chỉ bên trong các trường hợp enum dưới dạng hai cấu trúc khác nhau,
được định nghĩa khác nhau cho từng trường hợp:
#![allow(unused)] fn main() { struct Ipv4Addr { // --snip-- } struct Ipv6Addr { // --snip-- } enum IpAddr { V4(Ipv4Addr), V6(Ipv6Addr), } }
Đoạn mã này minh họa rằng bạn có thể đặt bất kỳ loại dữ liệu nào bên trong một trường hợp của enum: strings, numeric, hay struct... ví dụ. Thậm chí có thể chứa cả một enum khác! Ngoài ra, các loại thư viện chuẩn thường không phức tạp hơn nhiều so với những gì mà bạn có thể nghĩ ra.
Lưu ý rằng mặc dù thư viện chuẩn có chứa định nghĩa cho IpAddr
,
chúng ta vẫn có thể tạo và sử dụng định nghĩa riêng của chúng ta mà không bị xung đột
bởi vì chúng ta không đưa thư viện chuẩn vào trong phạm vi sử dụng của chúng ta.
Chúng ta sẽ nói nhiều hơn về việc đưa các loại vào trong phạm vi sử dụng ở Chương 7.
Hã xem một ví dụ khác về enum trong Listing 6-2: cái này có nhiều loại dữ liệu được định nghĩa trong các trường hợp enum:
enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32), } fn main() {}
Listing 6-2: Một enum Message
mà mỗi trường hợp của nó khác nhau về số lượng
và kiểu dữ liệu
Enum này có 4 trường hợp với 4 loại khác nhau:
Quit
không có chứa dữ liệu nào cả.Move
giống như một struct.Write
bao gồm 1String
.ChangeColor
chứa 3 giá trịi32
.
Định nghĩa 1 enum với các trường hợp như trong Listing 6-2 tương tự như việc xác định các loại định nghĩa
struct khác nhau, trừ trường hợp enum không sử dụng từ khoá struct
và tất cả các trường hợp trong nhóm lại với nhau bên dưới kiểu Message
.
Các struct có thể chứa cùng một dữ liệu mà các trường hợp của enum trước đó giữ:
struct QuitMessage; // unit struct struct MoveMessage { x: i32, y: i32, } struct WriteMessage(String); // tuple struct struct ChangeColorMessage(i32, i32, i32); // tuple struct fn main() {}
Nhưng nếu chúng ta sử dụng các struct khác nhau, mỗi struct có kiểu riêng của chúng,
chúng ta không thể dễ dàng định nghĩa một hàm để nhận bất kì một thông báo nào như
chúng ta có thể làm với enum Message
được định nghĩa ở Listing 6-2,
một kiểu duy nhất.
Có một điểm tương đồng nữa giữa enum và struct:: chúng đều định nghĩa các phương thức sử dụng impl
.
Đây là một phương thức call
, chúng ta có thể định nghĩa trong enum Message
:
fn main() { enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32), } impl Message { fn call(&self) { // method body would be defined here } } let m = Message::Write(String::from("hello")); m.call(); }
Phần thân của phương thức sẽ sử dụng self
để lấy giá trị mà chúng ta đã gọi phương thức trên.
Trong ví dụ này, chúng tôi đã tạo một biến m có giá trị là Message::Write(String::from("hello"))
,
và đó là những gì self
sẽ ở trong phần thân hàm call
khi m.call()
chạy.
Chúng ta hãy xem xét một enum khác trong thư viện chuẩn rất phổ biến và hữu ích: Option
.
Option
Enum và ưu điểm của nó so với giá trị Null
Trong phần này chúng ta sẽ khám phá 1 trường hợp điển hình của Enum là Option
,
là một enum khác được định nghĩa bởi thư viện tiêu chuẩn.
Option
là 1 loại mã hóa rất phổ biến trong đó giá trị có thể là một cái gì đó hoặc nó có thể không là gì cả.
Ví dụ, nếu bạn yêu cầu phần tử đầu tiên của một danh sách chứa những mục, bạn sẽ nhận một giá trị.
Nếu bạn yêu cầu phần tử đầu tiên của một danh sách rỗng, bạn không nhận được gì.
Diễn đạt khái niệm này theo kiểu hệ thống có nghĩa là trình biên dịch có thể kiểm tra xem bạn đã xử lý tất cả các trường hợp cần xử lý chưa;
chức năng này có thể ngăn chặn các lỗi rất phổ biến trong các ngôn ngữ lập trình khác.
Thiết kế ngôn ngữ lập trình thường được xem xét về các tính năng bạn bao gồm những tính năng nào, nhưng các tính năng bạn loại trừ cũng quan trọng. Rust không có giá trị rỗng mà nhiều ngôn ngữ khác có. Null là một giá trị có nghĩa là không có giá trị nào ở đó. Trong các ngôn ngữ có null, các biến luôn có thể ở một trong hai trạng thái: null hoặc not-null.
Trong bài thuyết trình năm 2009 của anh ấy “Null References: The Billion Dollar Mistake,” Tony Hoare, người phát minh ra null, có điều này để nói:
Tôi gọi đó là sai lầm hàng tỷ đô la của mình. At that time, Vào thời điểm đó, tôi đang thiết kế hệ thống đầu tiên cho các tham chiếu bằng ngôn ngữ hướng đối tượng. Mục tiêu của tôi là đảm bảo rằng tất cả việc sử dụng các tham chiếu phải an toàn tuyệt đối, với việc kiểm tra được thực hiện tự động bởi trình biên dịch. Nhưng tôi không thể cưỡng lại sự cám dỗ để đưa vào một tham chiếu rỗng, đơn giản vì nó rất dễ thực hiện. Điều này đã dẫn đến vô số lỗi, lỗ hổng bảo mật và sự cố hệ thống mà có lẽ đã gây ra đau đớn và thiệt hại hàng tỷ đô la trong bốn mươi năm qua.
Vấn đề với giá trị null là nếu bạn cố gắng sử dụng giá trị null làm giá trị không null, bạn sẽ gặp một lỗi nào đó. Bởi vì thuộc tính null hoặc not-null này là phổ biến, rất dễ mắc phải loại lỗi này.
Tuy nhiên, khái niệm null đang cố gắng diễn đạt vẫn hữu ích: null là một giá trị hiện không hợp lệ hoặc vắng mặt vì lý do nào đó.
Vấn đề không thực sự nằm ở khái niệm mà là ở cách triển khai cụ thể.
Như vậy, Rust không có null, nhưng nó có một enum có thể mã hóa khái niệm giá trị hiện diện hoặc vắng mặt.
Enum này là Option<T>
, và nó là defined by the standard library như sau:
#![allow(unused)] fn main() { enum Option<T> { None, Some(T), } }
Option<T>
enum hữu ích đến mức chứa phần báo trước; bạn không cần phải đưa nó vào phạm vi một cách rõ ràng.
Các biến thể của nó cũng được bao gồm trong phần mở đầu: bạn có thể sử dụng Some
và None
trực tiếp
mà không có tiền tố Option::
. Option<T>
enum vẫn là 1 enum bình thường, và Some(T)
và
None
cũng là các biến thể trong kiểu Option<T>
.
Cú pháp <T>
là một tính năng của Rust mà chúng tôi chưa nói đến. Nó là 1 kiểu generic,
và chúng tôi sẽ trình bày chi tiết hơn trong Chương 10.
Hiện tại, tất cả những gì bạn cần biết là <T>
nghĩa là Some
là biến thể
Option
enum có thể chứa bất kì loại dữ liệu nào, và mỗi loại dữ liệu cụ thể được sử dụng thay cho T
làm cho loại Option<T>
trở thành một loại khác.
Dưới đây là một số ví dụ về việc sử dụng giá trị Option
để lưu các loại số và loại chuỗi:
fn main() { let some_number = Some(5); let some_string = Some("a string"); let absent_number: Option<i32> = None; }
Kiểu some_number
là Option<i32>
. Kiểu some_string
là
Option<&str>
, đó là một loại kiểu khác . Rust có thể suy ra các loại này bởi vì chúng tôi đã chỉ định một giá trị bên trong biến thể Some
.
Đối với absent_number
, Rust yêu cầu chúng tôi chú thích loại Option
: trình biên dịch không thể suy ra loại mà tương ứng
Some
đang lưu trữ là giá trị None
. Ở đây, chúng tôi nói với Rust rằng ý của chúng tôi là để absent_number
có kiểu Option<i32>
.
khi Some
có một giá trị nào đó, chúng tôi biết rằng một giá trị hiện diện và giá trị được giữ trong
Some
. Khi chúng tôi cố 1 giá trị None
, theo một nghĩa nào đó, nó có nghĩa giống như là null:
chúng tôi không có giá trị hợp lệ. Vậy tại sao có Option<T>
lại tốt hơn là null?
Nói ngắn gọn, bởi vì Option<T>
và T
(T
có thể là bất kì một kiểu nào) là những loại khác nhau
, trình biên dịch sẽ không cho phép chúng tôi sử dụng một giá trị Option<T>
nếu như nó
không phải một giá trị hợp lệ. Ví dụ: mã này sẽ không biên dịch vì nó đang cố gắng sử dụng
phép cộng một i8
với một Option<i8>
:
fn main() {
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y;
}
Nếu chúng tôi chạy mã này, chúng tôi nhận được thông báo lỗi như sau:
$ cargo run
Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
--> src/main.rs:5:17
|
5 | let sum = x + y;
| ^ no implementation for `i8 + Option<i8>`
|
= help: the trait `Add<Option<i8>>` is not implemented for `i8`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` due to previous error
Mãnh liệt! Thực tế, thông báo lỗi này có nghĩa là Rust không hiểu làm cách nào
cộng một i8
với một Option<i8>
, bởi vì chúng là những loại khác nhau.
Khi chúng ta có một giá trị kiểu i8
trong Rust, trình biên dịch sẽ chắc chắn
chúng ta có một giá trị hợp lệ. Chúng ta có thể tiến hành một cách tự tin mà không cần phải kiểm tra null trước khi sử dụng giá trị đó
. Chỉ khi chúng ta có một Option<i8>
(hoặc bất kỳ loại giá trị nào mà chúng ta đang làm việc)
chúng ta phải lo lắng về việc có thể không có giá trị, và trình biên dịch sẽ đảm bảo rằng chúng tôi xử lý trường hợp đó trước khi sử dụng giá trị đó.
Nói cách khác, bạn phải chuyển một kiểu Option<T>
thành một kiểu T
trước khi bạn thực hiện bất kì
thao tác nào với nó. Nói chung, điều này giúp khắc phục một trong những vấn đề phổ biến nhất với null:
giả sử rằng một cái gì đó không phải là null khi nó thực sự là như vậy.
Loại bỏ rủi ro giả định không chính xác giá trị không phải là null giúp bạn tin hơn vào mã của mình.
Để có một giá trị có thể là null, bạn phải chọn một cách rõ ràng bằng cách đặt loại giá trị đó là Option<T>
.
Sau đó, khi bạn sử dụng giá trị đó, bạn được yêu cầu xử lý rõ ràng trường hợp khi giá trị là null.
Ở mọi nơi mà một giá trị có một loại không phải là Option<T>
, bạn có thể an toàn giả định rằng giá trị không phải là null.
Đây là một quyết định thiết kế có chủ ý của Rust để hạn chế lỗi phổ biến của null và tăng độ an toàn của mã Rust.
Vì vậy, làm thế nào để bạn có được giá trị T
từ một kiểu Some
khi bạn có một giá trị thuộc loại
Option<T>
để bạn có thể sử dụng giá trị đó? Option<T>
enum có một số lượng lớn các phương pháp hữu ích
trong nhiều tình huống khác nhau; bạn có thể kiểm tra chúng tại its documentation.
Làm quen với các phương pháp trên Option<T>
sẽ cực kỳ hữu ích trong hành trình của bạn với Rust.
Nói chung, để sử dụng một giá trị Option<T>
, bạn muốn có mã sẽ xử lý từng biến thể.
Bạn muốn một số mã sẽ chỉ chạy khi bạn có một giá trị Some(T)
,
và mã này được phép sử dụng bên trong T
. Bạn muốn một số mã khác chạy nếu bạn có
một giá trị None
, và mã đó không có sẵn giá trị T
. Biểu thức match
là một cấu trúc luồng điều khiển thực hiện điều này khi được sử dụng với enums:
nó sẽ chạy mã khác nhau tùy thuộc vào biến thể của enum mà nó có, và mã đó có thể sử dụng dữ liệu bên trong giá trị phù hợp.
The match
Control Flow Construct
Rust có một cấu trúc luồng điều khiển cực kỳ mạnh mẽ được gọi là match
cho
phép bạn so sánh một giá trị với một loạt các mẫu và sau đó thực thi mã dựa
trên mẫu nào phù hợp. Các mẫu có thể được tạo thành từ các giá trị chữ,
tên biến, ký tự đại diện và nhiều thứ khác; Chương 18 bao gồm tất cả các
loại mẫu khác nhau và những gì chúng làm. Sức mạnh của match
đxuất phát
từ sự biểu đạt của các mẫu và thực tế là trình biên dịch xác nhận rằng tất
cả các trường hợp có thể xảy ra đều được xử lý.
Hãy nghĩ về một biểu thức match
như là giống như một cỗ máy phân loại tiền xu:
đồng xu trượt xuống một đường ray với các lỗ có kích thước khác nhau dọc theo nó,
và mỗi đồng xu rơi qua lỗ đầu tiên mà nó gặp phải mà nó vừa vào.
Theo cách tương tự, các giá trị đi qua từng mẫu trong một match
,
và ở mẫu đầu tiên, giá trị "phù hợp",
giá trị rơi vào khối mã liên kết sẽ được sử dụng trong quá trình thực thi
Nói về tiền xu, hãy sử dụng chúng làm ví dụ bằng cách sử dụng match
!
Chúng ta có thể viết một hàm lấy một đồng xu Hoa Kỳ không xác định và,
theo cách tương tự như máy đếm, xác định đó là đồng xu nào và trả về
giá trị của nó bằng xu, như được hiển thị ở đây trong Listing 6-3.
enum Coin { Penny, Nickel, Dime, Quarter, } fn value_in_cents(coin: Coin) -> u8 { match coin { Coin::Penny => 1, Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter => 25, } } fn main() {}
Listing 6-3: Một enum và một biểu thức so khớp có các biến thể của enum là các mẫu của nó
Hãy chia nhỏ match
trong hàm value_in_cents
. Đầu tiên, chúng ta liệt kê từ khoá match
là một biểu thức, trong trường hợp này là coin
. Điều này có vẻ rất giống với một biểu thức
được sử dụng với if
, nhưng có một sự khác biệt lớn: với if
,
biểu thức cần trả về giá trị Boolean, nhưng ở đây, nó có thể trả về bất kỳ loại nào. Kiểu của coin
trong ví dụ này là một enum Coin
mà chúng ta đã định nghĩa ở dòng đầu tiên.
Tiếp theo là các nhánh match
. Một nhánh gồm 2 phần: mẫu và code. Nhánh đầu tiên ở đây có một mẫu là giá trị Coin::Penny
và sau đó toán tử =>
phân tách mẫu và code để chạy. Code trong trường hợp này nhận giá trị là 1
. Mỗi nhánh được ngăn cách với nhánh tiếp theo bằng dấu phẩy.
Khi biểu thức match
thực thi, nó so sánh giá trị kết quả với mẫu của mỗi nhánh, theo thứ tự.
Nếu một mẫu khớp với giá trị, code với mẫu đó sẽ được thực thi.
Nếu mẫu đó không khớp với giá trị, thì việc thực thi sẽ tiếp tục cho nhánh tiếp theo,
giống như trong một máy phân loại tiền xu.
Chúng ta có thể có nhiều nhánh như chúng ta cần: trong Listing 6-3, match
của chúng ta có 4 nhánh.
Code được liên kết với mỗi nhánh là một biểu thức, và giá trị kết quả của biểu thức trong nhánh phù hợp là giá trị được trả về cho toàn bộ biểu thức match
.
Chúng ta thường không sử dụng dấu ngoặc nhọn nếu mã nhánh đối sánh ngắn, như là trong Listing 6-3
trong đó mỗi nhánh chỉ trả về một giá trị. Nếu bạn muốn chạy nhiều dòng mã trong một nhánh, bạn phải sử dụng dấu ngoặc nhọn.
Ví dụ, mã sau in “Lucky penny!” mỗi khi phương thức được gọi tới một Coin::Penny
, nhưng vẫn trả về giá trị cuối cùng của block, 1
:
enum Coin { Penny, Nickel, Dime, Quarter, } fn value_in_cents(coin: Coin) -> u8 { match coin { Coin::Penny => { println!("Lucky penny!"); 1 } Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter => 25, } } fn main() {}
Các mẫu ràng buộc với giá trị
Một tính năng hữu ích khác của các nhánh match là chúng có thể liên kết với các phần của giá trị khớp với mẫu. Đây là cách chúng tôi có thể trích xuất các giá trị từ các trường hợp của enum.
Như ví dụ dưới, hãy thay đổi một trong các biến thể enum của chúng tôi để giữ dữ liệu bên trong nó.
Từ năm 1999 đến năm 2008, Hoa Kỳ đúc đồng 25 xu với các thiết kế khác nhau cho mỗi bên trong số 50 tiểu bang.
Không có đồng xu nào khác có thiết kế trạng thái, vì vậy chỉ các đồng 25 xu có giá trị bổ sung này. Chúng ta có thể thêm thông tin này vào enum
bằng cách thay đổi trường hợp Quarter
có chứa 1 giá trị UsState
được lưu trữ bên trong nó, mà chúng ta đã làm ở đây trong Listing 6-4.
#[derive(Debug)] // so we can inspect the state in a minute enum UsState { Alabama, Alaska, // --snip-- } enum Coin { Penny, Nickel, Dime, Quarter(UsState), } fn main() {}
Listing 6-4: Một enum Coin
trong đó trường hợp Quarter
chứa 1 giá trị UsState
Hãy tưởng tượng rằng một người bạn đang cố gắng thu thập tất cả 50 đồng 25 xu của các tiểu bang. Trong khi chúng ta phân loại tiền lẻ của mình theo loại tiền xu, chúng tôi cũng sẽ gọi ra tên của tiểu bang được liên kết với mỗi đồng 25 xu vì vậy nếu đó là một trong những người bạn của chúng tôi không có, họ có thể thêm nó vào bộ sưu tập của họ.
Trong biểu thức match cho code này, chúng tôi thêm một biến được gọi là state
vào mẫu phù hợp với các giá trị của trường hợp Coin::Quarter
. Khi một
Coin::Quarter
khớp, biến state
sẽ liên kết với giá trị của trạng thái của đồng 25 xu đó. Sau đó, chúng ta có thể sử dụng state
trong code cho nhánh này, giống như bên dưới:
#[derive(Debug)] enum UsState { Alabama, Alaska, // --snip-- } enum Coin { Penny, Nickel, Dime, Quarter(UsState), } fn value_in_cents(coin: Coin) -> u8 { match coin { Coin::Penny => 1, Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter(state) => { println!("State quarter from {:?}!", state); 25 } } } fn main() { value_in_cents(Coin::Quarter(UsState::Alaska)); }
Nếu chúng ta gọi value_in_cents(Coin::Quarter(UsState::Alaska))
, coin
sẽ là Coin::Quarter(UsState::Alaska)
.
Khi chúng tôi so sánh giá trị đó với từng nhánh, không ai trong số chúng phù hợp cho đến khi chúng tôi đạt được Coin::Quarter(state)
.Tại thời điểm đó, ràng buộc đối với state
sẽ là giá trị UsState::Alaska
. Chúng tôi có thể sử dụng ràng buộc đó trong câu lệnh println!
, do đó nhận được giá trị trạng thái bên trong của giá trị Coin
cho Quarter
.
Matching với Option<T>
Trong phần trước, chúng ta muốn có được bên trong giá trị T
của Some
trường hợp khi sử dụng Option<T>
;
chúng ta cũng có thể xử lý Option<T>
sử dung match
như là chúng ta đã làm với Coin
! Thay vì so sánh tiền xu, chúng tôi sẽ so sánh các trường hợp của
Option<T>
, nhưng cách thức hoạt động của biểu thức match
vẫn giống nhau.
Giả sử chúng tôi muốn viết một hàm sử dụng Option<i32>
, nếu có một giá trị bên trong, hãy thêm 1 vào giá trị đó.
Nếu không có giá trị bên trong, hàm sẽ trả về giá trị None
và không cố gắng thực hiện bất kỳ hoạt động nào.
Hàm này rất dễ viết, nhờ match
, và sẽ trông như Listing 6-5.
fn main() { fn plus_one(x: Option<i32>) -> Option<i32> { match x { None => None, Some(i) => Some(i + 1), } } let five = Some(5); let six = plus_one(five); let none = plus_one(None); }
Listing 6-5: Một hàm sử dụng biểu thức match
h trên Option<i32>
Chúng ta hãy kiểm tra việc thực hiện đầu tiên của plus_one
chi tiết hơn. Khi chúng ta gọi
plus_one(five)
, biến x
trong thân hàm plus_one
sẽ có giá trị
Some(5)
. Sau đó, chúng tôi so sánh điều đó với từng nhánh match
.
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Giá trị Some(5)
không khớp với mẫu None
,vì vậy chúng ta tiếp tục đến nhánh tiếp theo.
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Some(5)
có khớp với Some(i)
? Tại sao lại có nó! Chúng ta có cùng một trường hợp.
i
liên kết với giá trị chứa trong Some
, vì vậy i
nhận giá trị 5
.
Sau đó, đoạn code trong nhánh match
được thực thi, vì vậy chúng ta cộng thêm 1 vào giá trị của i
và
tạo ra một giá trị mới Some
với tổng là 6
.
Bây giờ chúng ta hãy xem xét lời gọi hàm thứ hai của plus_one
trong Listing 6-5, trong đó x
là
None
. Chúng ta nhập match
và so sánh giá trị ở nhánh đầu tiên.
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Nó phù hợp! Không có giá trị nào để thêm vào, vì vậy chương trình dừng và trả về giá trị
None
ở phía bên phải của =>
. Bởi vì nhánh đầu tiên khớp với nhau, nên không có nhánh nào khác được so sánh.
Kết hợp match
và enum
rất hữu ích trong nhiều trường hợp. Bạn sẽ thấy mẫu này rất nhiều trong mã Rust:
match
chống lại một enum, liên kết một biến với dữ liệu bên trong, và sau đó thực thi mã dựa trên nó.
Lúc đầu hơi phức tạp, nhưng một khi bạn đã quen với nó, bạn sẽ ước bạn có nó trong tất cả các ngôn ngữ. Nó luôn là một sự yêu thích của người dùng.
Matches là đầy đủ
Có một khía cạnh khác của match
chúng ta cần thảo luận. Hãy xem xét phiên bản hàm plus_one
này của chúng ta
có một lỗi và sẽ không biên dịch:
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Chúng ta không xử lý trường hợp None
, vì vậy mã này sẽ gây ra lỗi. May mắn thay, đó là một lỗi mà Rust biết cách bắt.
Nếu chúng ta cố gắng biên dịch mã này, chúng ta sẽ gặp lỗi sau:
$ cargo run
Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
--> src/main.rs:3:15
|
3 | match x {
| ^ pattern `None` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
= note: the matched value is of type `Option<i32>`
For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` due to previous error
Rust biết rằng chúng ta không bao gồm trường hợp nào có thể xảy ra và thậm chí biết chúng ta đã quên mẫu nào!
Matches trong Rust là đầy đủ: chúng ta phải sử dụng hết mọi khả năng để mã có hiệu lực.
Đặc biệt là trong trường hợp của Option<T>
, khi Rust ngăn chúng ta quên xử lý rõ ràng trường hợp None
,
nó bảo vệ chúng ta khỏi giả định rằng chúng ta có một giá trị khi chúng ta có thể có null,
do đó làm cho sai lầm hàng tỷ đô la đã được thảo luận trước đó là không thể.
Catch-all Patterns and the _
Placeholder
Sử dụng enum, chúng ta cũng có thể thực hiện các hành động đặc biệt đối với một số giá trị cụ thể,
nhưng đối với tất cả các giá trị khác thì thực hiện một hành động mặc định. Hãy tưởng tượng chúng tôi đang triển khai một trò chơi trong đó,
nếu bạn tung một con xúc xắc là 3, người chơi sẽ không di chuyển,
nhưng thay vào đó nhận được một chiếc mũ mới nhiều màu sắc. Nếu bạn tung ra 7, người chơi sẽ mất một chiếc mũ.
Đối với tất cả các giá trị khác, người chơi của bạn di chuyển số khoảng trắng đó trên bảng trò chơi.
Đây là một triển khai logic match
, với kết quả của cuộn xúc xắc được mã hóa cứng chứ không phải là một giá trị ngẫu nhiên,
và tất cả các logic khác được đại diện bởi các hàm không có phần thân bởi vì thực sự việc triển khai chúng nằm ngoài phạm vi của ví dụ này:
fn main() { let dice_roll = 9; match dice_roll { 3 => add_fancy_hat(), 7 => remove_fancy_hat(), other => move_player(other), } fn add_fancy_hat() {} fn remove_fancy_hat() {} fn move_player(num_spaces: u8) {} }
Đối với hai nhánh đầu tiên, các mẫu là các giá trị 3 và 7. Đối với nhánh cuối cùng bao gồm mọi giá trị có thể có khác,
biến chúng ta đã chọn để đặt tên other
. Mã chạy cho nhánh other
sử dụng biến bằng cách chuyển nó đến hàm move_player
.
Biên dịch đoạn code này, mặc dù chúng tôi chưa liệt kê tất cả các giá trị có thể có của một u8
,
vì mẫu cuối cùng sẽ khớp với tất cả các giá trị không được liệt kê cụ thể.
Mẫu tổng hợp này đáp ứng yêu cầu rằng match
phải đầy đủ. Lưu ý rằng chúng ta phải đặt nhánh thu thập tất cả cuối cùng vì các mẫu được đánh giá theo thứ tự.
Rust sẽ cảnh báo chúng ta nếu chúng ta thêm nhánh nào đó sau khi bắt được tất cả vì những nhánh sau đó sẽ không bao giờ khớp với nhau!
Rust cũng có một mẫu mà chúng ta có thể sử dụng khi không muốn sử dụng giá trị trong mẫu tổng hợp: _
,
là một mẫu đặc biệt phù hợp với bất kỳ giá trị nào và không liên kết với giá trị đó.
Điều này cho Rust biết rằng chúng ta sẽ không sử dụng giá trị,
vì vậy Rust sẽ không cảnh báo chúng ta về một biến không được sử dụng.
Hãy thay đổi quy tắc của trò chơi thành nếu bạn tung bất kỳ thứ gì khác ngoài số 3 hoặc số 7,
bạn sẽ phải tung lại. Chúng ta không cần sử dụng giá trị trong trường hợp đó, vì vậy chúng ta có thể thay đổi mã của mình để sử dụng _
thay vì biến có tên other
:
fn main() { let dice_roll = 9; match dice_roll { 3 => add_fancy_hat(), 7 => remove_fancy_hat(), _ => reroll(), } fn add_fancy_hat() {} fn remove_fancy_hat() {} fn reroll() {} }
Ví dụ này cũng đáp ứng yêu cầu đầy đủ vì chúng ta đang bỏ qua tất cả các giá trị khác trong nhánh cuối cùng; chúng ta đã không quên bất cứ điều gì.
Nếu chúng tôi thay đổi các quy tắc của trò chơi một lần nữa, để không có gì khác xảy ra trong lượt của bạn nếu bạn tung bất kỳ thứ gì khác ngoài con 3 hoặc con 7,
chúng ta có thể thể hiện điều đó bằng cách sử dụng giá trị đơn vị (loại tuple trống mà chúng tôi đã đề cập trong phần “The Tuple
Type”) như mã đi với nhánh _
:
fn main() { let dice_roll = 9; match dice_roll { 3 => add_fancy_hat(), 7 => remove_fancy_hat(), _ => (), } fn add_fancy_hat() {} fn remove_fancy_hat() {} }
Ở đây, chúng ta đang nói với Rust một cách rõ ràng rằng chúng ta sẽ không sử dụng bất kỳ giá trị nào khác không khớp với một mẫu trong nhánh trước đó, và chúng tôi không muốn chạy bất kỳ mã nào trong trường hợp này.
Có nhiều thông tin hơn về các mẫu và matchings mà chúng ta sẽ đề cập đến ở Chapter
18. Bây giờ, chúng ta sẽ chuyển sang cú pháp if let
, có thể hữu ích trong các tình huống mà match
diễn đạt hơi dài dòng.
Cú pháp kiểm tra biến với if let
Cú pháp if let
cho phép bạn kết hợp if
và let
thành một cách ít dài dòng hơn để xử lý các giá trị khớp với một mẫu trong khi bỏ qua phần còn lại.
Xem xét chương trình trong Listing 6-6 phù hợp với một giá trị Option<u8>
trong config_max
nhưng chỉ muốn thực thi mã nếu giá trị là trường hợp Some
.
fn main() { let config_max = Some(3u8); match config_max { Some(max) => println!("The maximum is configured to be {}", max), _ => (), } }
Listing 6-6: match
chỉ quan tâm đến việc thực thi mã khi giá trị là
Some
Nếu giá trị là Some
, chúng ta in ra giá trị Some
bằng cách liên kết giá trị với biến max
trong mẫu.
Chúng ta không muốn làm bất cứ điều gì với giá trị None
. Để đáp ứng biểu thức match
, chúng ta phải thêm _ => ()
sau khi chỉ xử lý một trường hợp, đó là đoạn mã khó chịu để thêm vào.
Thay vào đó, chúng ta có thể viết điều này theo cách ngắn hơn bằng cách sử dụng if let
.
Đoạn mã sau hoạt động giống như match
trong Listing 6-6:
fn main() { let config_max = Some(3u8); if let Some(max) = config_max { println!("The maximum is configured to be {}", max); } }
Cú pháp if let
nhận một mẫu và một biểu thức được phân tách bằng dấu bằng.
Nó hoạt động giống như cách một match
mà trong đó biểu thức được đưa ra cho match
và mẫu là nhánh đầu tiên. Trong trường hợp này, mẫu là Some(max)
,
và giá trị max
liên kết với giá trị bên trong Some
. Sau đó chúng ta có thể sử dụng max
trong phần thân của khối if let
theo cách tương tự như chúng tôi đã sử dụng max
in
tương ứng nhánh match
. Đoạn mã trong khối if let
sẽ không chạy nếu giá trị không khớp với mẫu.
Sử dụng if let
có nghĩa là ít nhập hơn, ít thụt lề hơn và ít mã mẫu hơn.
Tuy nhiên, bạn sẽ matts đi sự kiểm tra đầy đủ mà một match
được thực thi. Lựa chọn giữa match
và if let
phụ thuộc vào những gì bạn đang làm trong tình huống cụ thể của bạn và và liệu việc đạt được sự ngắn gọn có phải là một sự đánh đổi thích hợp để đánh mất việc kiểm tra đầy đủ hay không.
Nói cách khác, bạn có thể nghĩ về if let
như là cú pháp ngọt ngào cho một match
chạy mã khi giá trị khớp với một mẫu và sau đó bỏ qua tất cả các giá trị khác.
Chúng tôi có thể bao gồm một else
với một if let
. Khối code đó sẽ đi với else
giống như khối mã sẽ đi với trường hợp _
casetrong biểu thức
match
điều đó tương đương với if let
và else
. Nhớ lại định nghĩa enum Coin
ở Listing 6-4, trường hợp Quarter
cũng có giá trị là một
UsState
. Nếu chúng ta muốn đếm tất cả các đồng tiền không phải đồng 25 xu mà chúng ta thấy đồng thời thông báo trạng thái của đồng 25 xu, chúng tôi có thể làm điều đó với một biểu thức match
như thế này:
#[derive(Debug)] enum UsState { Alabama, Alaska, // --snip-- } enum Coin { Penny, Nickel, Dime, Quarter(UsState), } fn main() { let coin = Coin::Penny; let mut count = 0; match coin { Coin::Quarter(state) => println!("State quarter from {:?}!", state), _ => count += 1, } }
Hoặc chúng ta có thể sử dụng một biểu thức if let
và else
như thế này:
#[derive(Debug)] enum UsState { Alabama, Alaska, // --snip-- } enum Coin { Penny, Nickel, Dime, Quarter(UsState), } fn main() { let coin = Coin::Penny; let mut count = 0; if let Coin::Quarter(state) = coin { println!("State quarter from {:?}!", state); } else { count += 1; } }
Nếu bạn gặp tình huống trong đó chương trình của bạn có logic quá dài dòng để diễn đạt bằng cách sử dụng
match
, nhớ rằng that if let
cũng có trong hộp công cụ Rust của bạn.
Tóm tắt
Bây giờ chúng ta đã đề cập đến cách sử dụng enum để tạo các loại tùy chỉnh có thể là một trong tập hợp các giá trị được liệt kê.
Chúng tôi đã chỉ ra cách thư viện tiêu chuẩn Option<T>
loại giúp bạn sử dụng hệ thống loại để ngăn ngừa lỗi.
Khi các giá trị enum có dữ liệu bên trong chúng, bạn có thể sử dụng match
hoặc if let
để trích xuất và sử dụng các giá trị đó, tùy thuộc vào số lượng trường hợp bạn cần xử lý.
Các chương trình Rust của bạn hiện có thể diễn đạt các khái niệm trong miền của bạn bằng cách sử dụng cấu trúc và enum. Tạo các loại tùy chỉnh để sử dụng trong API của bạn đảm bảo an toàn cho loại: trình biên dịch sẽ đảm bảo các hàm của bạn chỉ nhận các giá trị kiểu mà mỗi hàm mong đợi.
Để cung cấp một API được tổ chức tốt cho người dùng của bạn, dễ sử dụng và chỉ hiển thị chính xác những gì người dùng của bạn sẽ cần, bây giờ hãy chuyển sang các mô-đun của Rust.
Quản lý các dự án lớn với Packages, Crates, and Modules
Khi bạn viết các chương trình lớn, tổ chức code của bạn sẽ rất quan trọng vì theo dõi toàn bộ chương trình của bạn trong đầu sẽ trở nên không thể. Bằng cách nhóm chức năng liên quan và phân tách code với các tính năng riêng biệt, bạn sẽ làm rõ nơi tìm code thực hiện một tính năng cụ thể và nơi để thay đổi cách thức hoạt động của một tính năng.
Các chương trình chúng tôi đã viết cho đến nay đã có trong một mô-đun trong một file. Là một dự án phát triển, bạn có thể tổ chức code bằng cách chia nó thành nhiều mô-đun và sau đó nhiều file. Một package có thể chứa nhiều binary crates và tùy chọn một library crate. Như một package phát triển, bạn có thể chia nhỏ các phần vào các crates, những crates này trở thành external dependencies. Chương này bao gồm tất cả các kỹ thuật trên. Đối với các dự án rất lớn của một tập hợp các package có liên quan đến nhau, Cargo cung cấp workspaces, chúng tôi sẽ đề cập trong phần “Cargo Workspaces”trong Chương 14.
Ngoài chức năng nhóm, triển khai tính đóng gói chi tiết cho phép bạn sử dụng lại code ở mức cao: khi bạn triển khai một hành động, các đoạn code khác sẽ gọi code đó thông qua public interface mà không cần biết cách triển khai hoạt động. Các mà bạn viết code xác định phần nào public để đoạn code khác sử dụng và phần nào private để bạn có thể tuỳ chỉnh khi cần. Đây là một cách khác để hạn chế số lượng tổ chức code mà bạn phải nhớ
Một khái niệm liên quan nữa là scope: ngữ cảnh mà code được viết lồng nhau trong đó một tập hợp các tên được định nghĩa là “in scope.” Khi đọc, viết và biên dịch code, các lập trình viên và trình biên dịch cần biết tại một thời điểm cụ thể đề cập tới một biến, function, struct, enum, module, constant hoặc các item khác và các item đó có nghĩa là gì. Bạn có thể tạo ra phạm vi và thay đổi cái tên nào trong hoặc ngoài phạm vi. Bạn không thể có hai item có cùng tên trong cùng phạm vi; tools có sẵn để giải quyết xung đột tên.
Rust có một số tính năng cho phép bạn quản lý tổ chức code của mình, bao gồm cả chi tiết nào được công khai, chi tiết nào là private và tên nào trong mỗi phạm vi trong các chương trình của bạn. Những tính năng này, đôi khi được gọi chung là module system, bao gồm:
- Packages: Một tính năng Cargo cho phép bạn build, test, and chia sẻ crates
- Crates: Một cây của modules tạo ta một lib hoặc thực thi
- Modules and use: để bạn kiểm soát tổ chức (dự án), phạm vi và quyền riêng tư của các đường dẫn
- Paths: một cách để đặt tên một item, chẳng hạn như một struct, function hoặc module
Trong chương này, chúng ta sẽ đề cập tới tất cả các tính năng trên, bàn luận về cách chúng tương tác và giải thích cách sử dụng chúng để quản lý phạm vi. Cuối cùng, bạn nên có một sự hiểu biết vững chắc về phân chia module để có thể làm việc một cách hiệu quả.
Packages and Crates
Các phần đầu tiên của module system chúng ta sẽ bao gồm packages và crates.
Một package là một hoặc nhiều crates cung cấp một loạt các chức năng. Một package chứa một file Cargo.toml mô tả cách build các crate của package đó.
Một crate có thể là một binary crate hoặc một library crate. Binary crates là các chương trình bạn có thể biên dịch và thực thi để chạy,
chẳng hạn như một command-line program hoặc một server. Chúng ta cần có một function được gọi là main
, function này
xác định điều gì xảy ra khi chạy thực thi. Tất cả các crates được tạo ra thường là binary crates.
Library crates không có main
function, và chúng không được biên dịch để thực thi.
Chúng định nghĩa các chức năng dự định để chia sẻ với nhiều projects.
Ví dụ, crate rand
chúng tôi sử dụng trong Chapter 2 cung cấp chức năng tạo các số ngẫu nhiên.
crate root là một file mà nguồn mà trình biên dịch Rust bắt đầu và tạo thành các root module (chúng tôi sẽ giải thích về module sâu hơn trong phần “Defining Modules to Control Scope and Privacy”).
Một số quy tắc xác định những gì mà một package có thể chứa. Một package có thể chứa nhiều nhất một library crate. Nó có thể chứa bao nhiêu binary crates tùy thích, nhưng nó phải chứa ít nhất một crate (hoặc là library hoặc binary).
Hãy xem điều gì xảy ra khi chúng ta tạo ra một package. Đầu tiên chúng ta gõ lệnh cargo new
:
$ cargo new my-project
Created binary (application) `my-project` package
$ ls my-project
Cargo.toml
src
$ ls my-project/src
main.rs
Khi chúng ta nhập lệnh, Cargo tạo một file Cargo.toml , cho chúng ta một
package. Nhìn vào nội dung của Cargo.toml, Không đề cập đến
src/main.rs bởi vì Cargo tuân theo một quy ước rằng src/main.rs là
crate root của một binary crate cùng tên với package. Hơn nữa, Cargo
biết rằng nếu thư mục package chứa src/lib.rs, package chứa
một library crate có cùng tên với package, và src/lib.rs là
crate root của nó. Cargo đưa các file crate root tới rustc
để build the library
or binary.
Ở đây chúng ta có một package chỉ chứa src/main.rs, có nghĩa là nó chỉ
chứa một binary crate tên là my-project
. Nếu một package chứa src/main.rs
và src/lib.rs, nó có 2 crates: một binary và một library, cả hai đều cùng tên với package.
Một package có thể chứa nhiều binary crates bằng cách đặt các files trong thư mục src/bin : mỗi file sẽ là một binary crate riêng biệt.
Định nghĩa module với chính sách và phạm vi truy cập (privacy)
Trong phần này, chúng ta sẽ nói về modules và các phần khác của module system,
cụ thể là paths cho phép bạn đặt tên cho các mục; từ khóa use
đưa ra một
đường dẫn tới scope; và từ khóa pub
làm cho các mục public. Chúng ta sẽ thảo luận
về từ khóa as
, external packages, và toán tử toàn cục.
Đầu tiên, chúng ta sẽ bắt đầu với một danh sách các quy tắc để dễ dàng tham khảo. Khi bạn tổ chức code của mình trong tương lai. Sau đó, chúng tôi sẽ giải thích chi tiết từng quy tắc.
Tham chiếu tới module một cách ngắn gọn (Modules Quick Reference)
Đây là cách mà modules, paths, từ khóa use
, và từ khóa pub
hoạt động trong
trình biên dịch, và làm thế nào hầu hết các developer tổ chức code của họ.
Chúng ta sẽ trải qua các ví dụ về từng quy tắc này, nhưng đây là một nơi tuyệt vời
để tìm kiếm trong tương lai như một lời nhắc nhở về cách các module hoạt động.
- Bắt đầu từ crate root: Khi biên dịch một crate, Trình biên dịch sẽ nhìn vào file crate root đầu tiên (thường là src/lib.rs cho một library crate hoặc src/main.rs cho một binary crate).
- Khai báo modules: Trong file crate root, bạn có thể khai báo một module mới
có tên gọi là “garden”, với cú pháp
mod garden;
. Trình biên dịch sẽ tìm kiếm code bên trong module tại đây:- Trong cùng 1 dòng, trực tiếp viết
mod garden
, trong dấu ngoặc nhọn thay vì dấu chấm phẩy. - Trong file src/garden.rs
- Trong file src/garden/mod.rs
- Trong cùng 1 dòng, trực tiếp viết
- Khái báo submodules: Trong bất kì file nào khác crate root, được
biên dịch như là một phần của crate (ví dụ, src/garden.rs), bạn cần khai báo
submodules (ví dụ,
mod vegetables;
). Trình biên dịch sẽ tìm kiếm trong dòng code submodules ở những nơi trong thư mục được đặt tên theo module cha:- Trong cùng 1 dòng, trực tiếp viết
mod vegetables
, trong dấu ngoặc nhọn thay vì dấu chấm phẩy. - Trong file src/garden/vegetables.rs
- Trong file src/garden/vegetables/mod.rs
- Trong cùng 1 dòng, trực tiếp viết
- Đừng dẫn đến code trong modules: Khi một module đang được biên dịch là một phần
crate của bạn, bạn có thể tham khảo code trong module đó (ví dụ, một loại
Asparagus
(măng tây) trong module garden) từ bất cứ nơi nào khác trong crate này bằng cách sử dụng đường dẫncrate::garden::vegetables::Asparagus
miễn là các quy tắc bảo mật cho phép. - Private vs public: Code trong một module là private từ các modules cha theo mặc định.
Để làm cho một module public, khai báo nới với từ khóa
pub mod
thay vìmod
là tốt nhất, sử dụngpub
trước khi khai báo. - **Từ khóa
use
**: Trong phạm vi, từ khóause
Tạo các lối tắt cho các mục để giảm sự lặp lại của các đường dẫn dài. Trong bất kỳ phạm vi nào có thể tham khảocrate::garden::vegetables::Asparagus
, bạn có thể tạo một lối tắt vớiuse crate::garden::vegetables::Asparagus;
và sau đó chỉ cần viếtAsparagus
để sử dụng loại đó trong phạm vi.
Đây là một binary crate được đặt tên là backyard
minh họa cho những quy tắc này. Thư mục của crates,
cũng được đặt tên là backyard
, chứa các file và thư mục này:
backyard
├── Cargo.lock
├── Cargo.toml
└── src
├── garden
│ └── vegetables.rs
├── garden.rs
└── main.rs
File crate root, trong trường hợp này src/main.rs, chứa:
Filename: src/main.rs
use crate::garden::vegetables::Asparagus;
pub mod garden;
fn main() {
let plant = Asparagus {};
println!("I'm growing {:?}!", plant);
}
The pub mod garden;
means the compiler includes the code it finds in
src/garden.rs, which is:
Filename: src/garden.rs
pub mod vegetables;
Và pub mod vegetables;
có nghĩa là code trong src/garden/vegetables.rs cũng được bao gồm:
#[derive(Debug)]
pub struct Asparagus {}
Bây giờ, hãy cùng tìm hiểu chi tiết về các quy tắc này và chứng minh chúng trong thực tế!
Nhóm code liên quan thành một modules (Grouping Related Code in Modules)
Modules hãy tổ chức code của bạn trong một crate thành các group để dễ dàng đọc và sử dụng lại. Các module cũng kiểm soát privacy của các mục, đó là một mục có thể sử dụng bởi code bên ngoài (public) hoặc là một triển khai nội bộ chi tiết và không có sẵn để sử dụng bên ngoài (private).
Ví dụ: hãy viết một library crate cung cấp chức năng của một nhà hàng. Chúng tôi xác định chữ kí hàm nhưng phần thân để trống để tập trung vào việc tổ chức code, thay vì thực sự thực hiện một nhà hàng trong code. Chữ ký của một hàm mô tả:
- tên của nó
- đối số của nó
- kết quả của nó
- trong trường hợp của các chức năng chung, các tham số chung của nó, với các giới hạn cụ thể có khả năng Ví dụ: nếu bạn xác định:
fn hello(s: &str) {
println!("Hello {}", s);
}
- Chữ ký hàm là fn hello(&str).
Trong ngành nhà hàng, Một số phần của một nhà hàng được gọi là
Trước nhà và những cái khác như là Sau nhà. Phía trước nhà là nơi khách hàng
; Đây là nơi khách hàng ngồi, servers nhận đơn đặt hàng và thanh toán,
và người pha chế làm đồ uống. Phía sau nhà là nơi các đầu bếp
làm việc trong bếp, máy rửa chén rửa chén, và các nhà quản lý làm công việc hành chính
Để cấu trúc crate cũng giống như cách mà nhà hàng hoạt động, Chúng ta có thể tổ chức các functions
vào các modules lồng nhau. Tạo mới một library đặt tên làrestaurant
bằng cách chạy cargo new --lib restaurant
;
Sau đó đặt mã vào Listing 7-1 vào src/lib.rs để xác định một số modules and chữ kí hàm.
Filename: src/lib.rs
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
fn seat_at_table() {}
}
mod serving {
fn take_order() {}
fn serve_order() {}
fn take_payment() {}
}
}
Listing 7-1: Một front_of_house
module chứa các module khác sau đó chứa các function
Chúng ta định nghĩa một module với từ khóa mod
và sau đó chỉ định tên module
(trong trường hợp này là front_of_house
) và đặt dấu ngoặc nhọn bao quanh phần thân của module.
Bên trong module, chúng ta cần có các module khác, trong trường hợp này
là với các module hosting
và serving
. Các module cũng có thể chứa
các định nghĩa cho những mục khác, như là structs, enums, constants, traits, hoặc như
trong Listing 7-1—functions.
Bằng cách sử dụng các module, chúng tôi có thể nhóm các định nghĩa có liên quan lại với nhau và đặt tên cho lý do tại sao chúng có liên quan. Các lập trình viên sử dụng code này sẽ có thời gian dễ dàng hơn trong việc tìm các định nghĩa mà họ muốn sử dụng vì họ có thể điều hướng code dựa trên các nhóm thay vì phải đọc qua tất cả các định nghĩa. Các lập trình viên thêm chức năng mới vào mã này sẽ biết nơi đặt code để giữ cho chương trình có tổ chức.
Trước đó, chúng tôi đã đề cập rằng src/main.rs và src/lib.rs được gọi là crate
roots. Lý do cho tên của chúng là vì nội dung của một trong hai tệp này tạo thành một module có tên crate
ở cấu trúc root crate module, được gọi là module tree.
Listing 7-2 hiển thị cây module cho cấu trúc trong Listing 7-1.
crate
└── front_of_house
├── hosting
│ ├── add_to_waitlist
│ └── seat_at_table
└── serving
├── take_order
├── serve_order
└── take_payment
Listing 7-2: Cây module cho code trong Listing 7-1
Cây này cho thấy cách một số module lồng vào nhau(Ví dụ, hosting
lồng bên trong front_of_house
).
Cây cũng cho thấy rằng một số module là anh chị em với nhau, nghĩa là chúng được xác định trong cùng một module
(hosting
và serving
được xác định trong front_of_house
).Tiếp tục phép ẩn dụ về gia đình,
Nếu module A được chứa bên trong module B, chúng tôi nói rằng module A là con của module B và module B là cha của module
Lưu ý rằng toàn bộ cây module được bắt nguồn từ module ngầm định có tên crate
.
Cây module có thể nhắc bạn về cây thư mục của hệ thống tệp trên máy tính của bạn; đây là một so sánh rất phù hợp! Cũng giống như các thư mục trong hệ thống tệp, bạn sử dụng các module để tổ chức mã của mình. Và cũng giống như các tệp trong thư mục, chúng ta cần một cách để tìm các module của mình.
Đường dẫn tham chiếu đến một mục trong cây module
Để chỉ cho Rust nơi tìm một mục trong cây module, chúng tôi sử dụng một đường dẫn giống như cách chúng ta sử dụng một đường dẫn khi điều hướng một hệ thống tệp. Nếu chúng ta muốn gọi một hàm, chúng ta cần biết đường dẫn của nó.
Một đường dẫn có thể có 2 dạng:
- Một đường dẫn tuyệt đối bắt đầu từ một crate bằng cách sử dụng tên một crate (đối với mã từ external crate)
hoặc theo nghĩa đen
crate
(cho code từ crate hiện tại). - Một đường dẫn tương đối bắt đầu từ module hiện tại và sử dụng
self
,super
, hoặc một mã định danh trong module hiện tại.
Cả hai đường dẫn tuyệt đối và tương đối đều được theo sau bởi một hoặc nhiều định danh được phân tách bằng dấu hai chấm kép(::
).
Hãy quay lại ví dụ trong Listing 7-1. Làm thế nào để chúng tôi gọi hàm
add_to_waitlist
? Điều này cũng giống như yêu cầu, đừng dẫn của function là gì
add_to_waitlist
? Listing 7-3 chứa Listing 7-1 với một số
module và hàm bị loại bỏ. Chúng tôi sẽ chỉ ra hai cách để gọi hàm
add_to_waitlist
từ một hàm mới eat_at_restaurant
được định nghĩa trong
crate root. Hàm eat_at_restaurant
là một phần của public API trong thư viện crate của chúng ta
, vì vậy chúng ta đánh dấu nó với từ khóa pub
. Trong phần “Exposing Paths with
the pub
Keyword”, Chúng ta sẽ đi vào chi tiết hơn
về pub
.Lưu ý rằng ví dụ này sẽ chưa biên dịch; chúng tôi sẽ giải thích một chút lý do tại sao.
Filename: src/lib.rs
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
}
}
pub fn eat_at_restaurant() {
// Absolute path
crate::front_of_house::hosting::add_to_waitlist();
// Relative path
front_of_house::hosting::add_to_waitlist();
}
Listing 7-3: Gọi hàm add_to_waitlist
sử dụng các đường dẫn tuyệt đối và tương đối
Lần đầu tiên chúng ta gọi hàm add_to_waitlist
trong eat_at_restaurant
,
chúng tôi sử dụng một đường dẫn tuyệt đối. Hàm add_to_waitlist
được xác định trong cùng một crate như eat_at_restaurant
,
có nghĩa là chúng ta có thể sử dụng từ khóa crate
để bắt đầu một đường dẫn tuyệt đối.
Sau crate
, chúng tôi bao gồm từng module kế tiếp nhau cho đến khi chúng ta thực hiện theo cách
add_to_waitlist
.Bạn có thể tưởng tượng một hệ thống tệp có cấu trúc giống nhau,
và chúng tôi sẽ chỉ định đường dẫn /front_of_house/hosting/add_to_waitlist
để chạy chương trình
add_to_waitlist
; sử dụng tên crate
để bắt đầu từ crate root
giống như sử dụng /
để bắt đầu từ gốc hệ thống tệp trong shell của bạn.
Lần thứ hai chúng ta gọi add_to_waitlist
trong eat_at_restaurant
, chúng ta sử dụng đường dẫn tương đối.
Đường dẫn bắt đầu với front_of_house
, tên của module được xác định ở cùng cấp của cây module như eat_at_restaurant
.
Ở đây hệ thống tệp tương đương sẽ sử dụng đường dẫn front_of_house/hosting/add_to_waitlist
.
Bắt đầu bằng một cái tên có nghĩa là đường dẫn đó là tương đối.
Việc chọn sử dụng đường dẫn tương đối hay đường dẫn tuyệt đối là quyết định bạn sẽ thực hiện dựa trên dự án của mình.
Quyết định sẽ phụ thuộc vào việc bạn có nhiều khả năng di chuyển các mục code được xác định riêng biệt hoặc cùng với code sử dụng các mục hay không.
Ví dụ, nếu chúng ta di chuyển module front_of_house
và hàmeat_at_restaurant
vào một module được đặt tên customer_experience
,
chúng tôi cần cập nhật đường dẫn tuyệt đối đếnadd_to_waitlist
, nhưng đường dẫn tương đối sẽ vẫn hợp lệ. Tuy nhiên, nếu chúng ta di chuyển
hàm eat_at_restaurant
riêng biệt thành một module có tên dining
,đường dẫn tuyệt đối dẫn đến add_to_waitlist
cuộc gọi sẽ giữ nguyên,
nhưng đường dẫn tương đối sẽ cần được cập nhật. Sở thích của chúng tôi là chỉ định đường dẫn tuyệt đối vì có nhiều khả năng chúng tôi muốn
di chuyển các định nghĩa code và lệnh gọi các mục độc lập với nhau.
Hãy thử biên dịch Listing 7-3 và tìm hiểu lý do tại sao nó vẫn chưa được biên dịch! Lỗi chúng tôi gặp phải được hiển thị trong Listing 7-4.
$ cargo build
Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: module `hosting` is private
--> src/lib.rs:9:28
|
9 | crate::front_of_house::hosting::add_to_waitlist();
| ^^^^^^^ private module
|
note: the module `hosting` is defined here
--> src/lib.rs:2:5
|
2 | mod hosting {
| ^^^^^^^^^^^
error[E0603]: module `hosting` is private
--> src/lib.rs:12:21
|
12 | front_of_house::hosting::add_to_waitlist();
| ^^^^^^^ private module
|
note: the module `hosting` is defined here
--> src/lib.rs:2:5
|
2 | mod hosting {
| ^^^^^^^^^^^
For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` due to 2 previous errors
Listing 7-4: Lỗi trình biên dịch khi xây dựng code trong Listing 7-3
Các thông báo lỗi cho biết module hosting
là private. Nói cách khác, chúng tôi có
các đường dẫn chính xác cho module hosting
và hàm add_to_waitlist
,nhưng Rust sẽ không cho phép
chúng tôi sử dụng chúng vì nó không có quyền truy cập vào các phần private.
Các module không chỉ hữu ích cho việc tổ chức code của bạn. Chúng cũng định nghĩa Rust’s privacy boundary: bao gồm chi tiết triển khai code bên ngoài không được phép biết, gọi hoặc phụ thuộc vào. Vì vậy, nếu bạn muốn đặt một mục như function hoặc structs ở chế độ private, bạn đặt nó trong một module.
Cách thức hoạt động của quyền riêng tư trong Rust là tất cả các mục (functions, methods, structs, enums, modules, and constants) là private theo mặc định. Các mục ở module cha không thể sử dụng các mục private bên trong các module con,nhưng các mục trong module con có thể sử dụng các mục trong module tổ tiên của chúng. Lý do là các module con bao bọc và ẩn triển khai chi tiết của chúng, nhưng các module con có thể thấy ngữ cảnh mà chúng được xác định. Để tiếp tục với phép ẩn dụ về nhà hàng, hãy nghĩ về các quy tắc bảo mật giống như văn phòng phía sau của một nhà hàng: những gì diễn ra trong đó là riêng tư đối với khách hàng của nhà hàng, nhưng những người quản lý văn phòng có thể thấy và làm mọi thứ trong nhà hàng mà họ điều hành.
Rust đã chọn để hệ thống module hoạt động theo cách này để ẩn các chi tiết triển khai bên trong là mặc định.
Bằng cách đó, bạn biết những phần nào của code bên trong mà bạn có thể thay đổi mà không cần phá vỡ mã bên ngoài.
Nhưng bạn có thể hiển thị các phần bên trong của code module con cho các module tổ tiên bên ngoài bằng cách sử dụng từ khóa pub
để đặt một mục ở chế độ public.
Hiển thị các Đường dẫn với Từ khoá pub
Hãy quay lại lỗi trong Listing 7-4 Hãy quay lại lỗi trong module hosting
là private.Chúng ta muốn function eat_at_restaurant
trong module cha để có quyền truy cập vào functionadd_to_waitlist
trong module con, vì vậy chúng ta đánh dấu module
hosting
với từ khóa pub
, như được hiển thị trong Listing 7-5.
Filename: src/lib.rs
mod front_of_house {
pub mod hosting {
fn add_to_waitlist() {}
}
}
pub fn eat_at_restaurant() {
// Absolute path
crate::front_of_house::hosting::add_to_waitlist();
// Relative path
front_of_house::hosting::add_to_waitlist();
}
Listing 7-5: Khai báo module hosting
như pub
sử dụng nó từ eat_at_restaurant
Thật không may, mã trong Listing 7-5 vẫn dẫn đến lỗi, như được hiển thị trong Listing 7-6.
$ cargo build
Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: function `add_to_waitlist` is private
--> src/lib.rs:9:37
|
9 | crate::front_of_house::hosting::add_to_waitlist();
| ^^^^^^^^^^^^^^^ private function
|
note: the function `add_to_waitlist` is defined here
--> src/lib.rs:3:9
|
3 | fn add_to_waitlist() {}
| ^^^^^^^^^^^^^^^^^^^^
error[E0603]: function `add_to_waitlist` is private
--> src/lib.rs:12:30
|
12 | front_of_house::hosting::add_to_waitlist();
| ^^^^^^^^^^^^^^^ private function
|
note: the function `add_to_waitlist` is defined here
--> src/lib.rs:3:9
|
3 | fn add_to_waitlist() {}
| ^^^^^^^^^^^^^^^^^^^^
For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` due to 2 previous errors
Listing 7-6:Lỗi trình biên dịch khi xây dựng mã trong Listing 7-5
Chuyện gì đã xảy ra? Thêm từ khóa pub
vào trước mod hosting
đặt
module ở chế độ public. Với sự thay đổi này, nếu chúng ta có thể truy cập front_of_house
,
chúng ta có thể truy cập hosting
. Nhưng nội dung của hosting
vẫn còn private; đặt module ở chế độ public không làm public nội dung của module.
Từ khóa pub
trên một module chỉ cho phép code trong các module tổ tiên của nó tham chiếu đến nó.
Các lỗi trong Listing 7-6 nói rằng function add_to_waitlist
là private.
Các quy tắc bảo mật áp dụng cho structs, enums, functions, and methods cũng như các module.
Hãy cũng làm cho function add_to_waitlist
public bằng cách thêm từ khóa pub
trước định nghĩa của nó, như trong Listing 7-7.
Filename: src/lib.rs
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
pub fn eat_at_restaurant() {
// Absolute path
crate::front_of_house::hosting::add_to_waitlist();
// Relative path
front_of_house::hosting::add_to_waitlist();
}
Listing 7-7: Thêm từ khóa pub
vào mod hosting
và fn add_to_waitlist
cho phép chúng tôi gọi hàm từ
eat_at_restaurant
Bây giờ code sẽ biên dịch!Hãy xem xét đường dẫn tuyệt đối và đường dẫn tương đối và kiểm tra kỹ lý do tại sao lại thêm từ khóa pub
cho phép chúng tôi sử dụng những đường dẫn này trong add_to_waitlist
đối với các quy tắc bảo mật.
Trong đường dẫn tuyệt đối, chúng ta bắt đầu với crate
, root của cây crate’s module
. Sau đó module front_of_house
được định nghĩa trong crate root. module
front_of_house
không là public, nhưng bởi vì function eat_at_restaurant
được định nghĩa trong cùng một module như front_of_house
(đó là,
eat_at_restaurant
và front_of_house
là chị em), chúng ta có thể tham khảo
front_of_house
từ eat_at_restaurant
.Tiếp theo là module hosting
được đánh dấu
với pub
. Chúng ta có thể truy cập module cha của hosting
, vì vậy chúng ta có thể truy cập
hosting
.Cuối cùng function add_to_waitlist
được đánh dấu với pub
và chúng tôi có thể truy cập module cha của nó, vì vậy lệnh gọi hàm này hoạt động!
Trong đường dẫn tương đối, logic giống như đường dẫn tuyệt đối ngoại trừ bước đầu tiên: thay vì bắt đầu từ crate root,
đường dẫn bắt đầu từ front_of_house
. Module front_of_house
được định nghĩa trong cùng một module
như eat_at_restaurant
, vì vậy đường dẫn tương đối bắt đầu từ module trong đó
eat_at_restaurant
là việc định nghĩa. Sau đó,bởi vì hosting
và
add_to_waitlist
được đánh dấu với pub
, phần còn lại của đường dẫn hoạt động và lệnh gọi hàm này hợp lệ!
Nếu bạn định chia sẻ library crate của mình để các dự án khác có thể sử dụng code của bạn, Public API của bạn là hợp đồng của bạn với người dùng trong crate về cách họ tương tác với mã của bạn. Có nhiều cân nhắc xung quanh việc quản lý các thay đổi đối với public API của bạn để giúp mọi người phụ thuộc vào crate của bạn dễ dàng hơn. Những cân nhắc này nằm ngoài phạm vi của cuốn sách này; nếu bạn quan tâm đến chủ đề này, hãy xem The Rust API Guidelines.
Các phương pháp hay nhất cho các package có một Binary và a Library
Chúng tôi đã đề cập đến một package có thể chứa cả hai src/main.rs binary crate root giống như một src/lib.rs library crate root, và cả crates sẽ có tên package theo mặc định. hông thường, các package có mẫu này sẽ chỉ có đủ code trong binary crate để bắt đầu một tệp thực thi gọi code bằng library crate. Điều này cho phép các project khác được hưởng lợi nhiều nhất chức năng mà package cung cấp, vì code của library crate có thể được chia sẻ.
Cây module nên được định nghĩa trong src/lib.rs. Sau đó, bất kỳ mục public nào có thể được sử dụng trong binary crate bằng cách bắt đầu các đường dẫn với tên của package. Binary crate trở thành người dùng của library crate giống như một crate bên ngoài sẽ sử dụng library crate: nó chỉ có thể sử dụng public API. Điều này giúp bạn thiết kế một API tốt; bạn không chỉ là tác giả, bạn còn là client!
In Chapter 12,chúng ta sẽ chứng minh tổ chức này thực hành với một command-line program sẽ chứa cả một binary crate và một library crate.
Bắt đầu Đường dẫn tương đối với super
Chúng tôi cũng có thể xây dựng các đường dẫn tương đối bắt đầu trong module cha bằng cách sử dụng
super
ở đầu đường dẫn. Điều này giống như bắt đầu một đường dẫn hệ thống tệp với cú pháp ..
. Tại sao chúng tôi muốn làm điều này?
Hãy xem xét đoạn mã trong Listing 7-8 mô hình hóa tình huống trong đó đầu bếp sửa một đơn hàng không chính xác
và đích thân mang món đó ra cho khách hàng.Chức năng fix_incorrect_order
được định nghĩa trong module back_of_house
gọi hàm deliver_order
được định nghĩa trong module cha bằng cách chỉ định đường dẫn đến
deliver_order
bắt đầu với super
:
Filename: src/lib.rs
fn deliver_order() {}
mod back_of_house {
fn fix_incorrect_order() {
cook_order();
super::deliver_order();
}
fn cook_order() {}
}
Listing 7-8: Calling a function using a relative path
starting with super
Hàm fix_incorrect_order
nằm trong module back_of_house
,
vì vậy chúng ta có thể sử dụng super
để chuyển đến module cha của back_of_house
,
trong trường hợp này là crate
root. Từ đó, chúng tôi tìm kiếm delivery_order
và tìm thấy nó.
Thành công! Chúng tôi nghĩ rằng module back_of_house
và hàm delivery_order
có thể giữ nguyên mối quan hệ với nhau
và được di chuyển cùng nhau nếu chúng tôi quyết định tổ chức lại cây module của crate.
Do đó, chúng tôi đã sử dụng super
nên chúng tôi sẽ có ít nơi để cập nhật mã hơn trong tương lai nếu mã này được chuyển sang một module khác.
Làm cho Structs và Enums Public
Chúng ta cũng có thể sử dụng pub
để chỉ định các struct và enums là public, nhưng có một số chi tiết bổ sung.
Nếu chúng ta sử dụng pub
trước định nghĩa struct, chúng ta đặt struct ở chế độ public,
nhưng các trường của struct sẽ vẫn ở chế độ riêng tư. Chúng tôi có thể public từng trường hoặc không tùy từng trường hợp cụ thể.
Trong Listing 7-9, chúng tôi đã xác định cấu trúc back_of_house :: Breakfast
public với trường toast
public nhưng là trường season_fruit
riêng. Điều này mô tả trường hợp trong một nhà hàng,
nơi khách hàng có thể chọn loại bánh mì đi kèm với bữa ăn, nhưng đầu bếp quyết định loại trái cây nào đi kèm với
bữa ăn dựa trên những gì đang có trong mùa và trong kho. Trái cây có sẵn thay đổi nhanh chóng,
vì vậy khách hàng không thể chọn trái cây hoặc thậm chí không thể xem họ sẽ lấy trái cây nào.
Filename: src/lib.rs
mod back_of_house {
pub struct Breakfast {
pub toast: String,
seasonal_fruit: String,
}
impl Breakfast {
pub fn summer(toast: &str) -> Breakfast {
Breakfast {
toast: String::from(toast),
seasonal_fruit: String::from("peaches"),
}
}
}
}
pub fn eat_at_restaurant() {
// Order a breakfast in the summer with Rye toast
let mut meal = back_of_house::Breakfast::summer("Rye");
// Change our mind about what bread we'd like
meal.toast = String::from("Wheat");
println!("I'd like {} toast please", meal.toast);
// The next line won't compile if we uncomment it; we're not allowed
// to see or modify the seasonal fruit that comes with the meal
// meal.seasonal_fruit = String::from("blueberries");
}
Listing 7-9:Một struct với một số trường public và một số trường riêng tư
Vì trường toast
trong struct back_of_house :: Breakfast
là public nên trong eat_at_restaurant
,
chúng ta có thể viết và đọc trường toast
bằng ký hiệu :: . Xin lưu ý rằng chúng ta không thể sử
dụng trường season_fruit
trong eat_at_restaurant
bởi vì season_fruit
là private.
Hãy thử bỏ ghi chú dòng sửa đổi giá trị trường season_fruit
để xem bạn gặp lỗi gì!
Ngoài ra, hãy lưu ý rằng vì back_of_house :: Breakfast
có một trường private,
nên struct cần cung cấp một hàm liên kết public để tạo một phiên bản của Breakfast
(chúng tôi đã đặt tên nó là summer
ở đây). Nếu Breakfast
không có chức năng như vậy,
chúng tôi không thể tạo phiên bản của Breakfast
trong eat_at_restaurant
vì chúng tôi không thể đặt giá trị của trường private theo seasonal_fruit
trong eat_at_restaurant
.
Ngược lại, nếu chúng ta public enum, thì tất cả các biến thể của nó sẽ được public.
Chúng tôi chỉ cần pub
trước từ khóa enum
, như được hiển thị trong Listing 7-10.
Filename: src/lib.rs
mod back_of_house {
pub enum Appetizer {
Soup,
Salad,
}
}
pub fn eat_at_restaurant() {
let order1 = back_of_house::Appetizer::Soup;
let order2 = back_of_house::Appetizer::Salad;
}
Listing 7-10:Việc chỉ định một enum là public làm cho tất cả các biến thể của nó ở chế độ public
Vì chúng tôi đã đặt enum Appetizer
ở chế độ public nên chúng tôi có thể sử dụng các biến thể Soup
và Salad
trong eat_at_restaurant
.
Enums không hữu ích lắm trừ khi các biến thể của chúng được public; sẽ rất khó chịu khi phải chú thích tất cả các biến thể enum bằng pub
trong mọi trường hợp,
vì vậy mặc định cho các biến thể enum là public. Các struct thường hữu ích mà không cần trường của chúng là public,
vì vậy, các trường của struct tuân theo quy tắc chung là mọi thứ là private theo mặc định trừ khi được chú thích bằng pub
.
Còn một trường hợp nữa liên quan đến pub
mà chúng tôi chưa đề cập đến và đó là tính năng hệ thống public cuối cùng của chúng tôi: từ khóa use
.
Trước tiên, chúng tôi sẽ đề cập đến vấn đề use
, sau đó chúng tôi sẽ chỉ ra cách kết hợp giữa pub
và use
.
Định nghĩa phạm vi sử dụng cho đường dẫn với từ khoá use
Có vẻ như các đường dẫn mà chúng tôi đã viết để gọi các hàm cho đến nay là dài
và lặp đi lặp lại một cách bất tiện. Ví dụ: trong Listing 7-7,
cho dù chúng ta chọn đường dẫn tuyệt đối hay tương đối đến hàm add_to_waitlist
,
mỗi khi chúng ta muốn gọi add_to_waitlist
, chúng ta cũng phải chỉ định front_of_house
và hosting
.
May mắn thay, có một cách để đơn giản hóa quy trình này. Chúng ta có thể tạo một lối tắt đến một đường dẫn với từ khóa use
một lần,
sau đó sử dụng tên ngắn hơn ở mọi nơi khác trong scope.
Trong Listing 7-11, chúng ta đưa module crate :: front_of_house :: hosting
vào scope của hàm eat_at_restaurant
vì vậy chúng tôi chỉ phải chỉ định hosting :: add_to_waitlist
để gọi hàm add_to_waitlist
trong eat_at_restaurant
.
Filename: src/lib.rs
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}
Listing 7-11: Đưa một module vào scope với
use
Thêm use
và một đường dẫn trong một scope tương tự như tạo một liên kết tượng trưng trong hệ thống tệp.
Bằng cách thêm use crate :: front_of_house :: hosting
trong crate root, hosting
bây giờ là một tên hợp lệ trong scope đó,
giống như module hosting
đã được xác định trong crate root.
Các đường dẫn được đưa vào scope với use
cũng kiểm tra quyền riêng tư, giống như bất kỳ đường dẫn nào khác.
Lưu ý rằng use
chỉ tạo lối tắt cho scope cụ thể mà use
xảy ra. Listing 7-12 di chuyển hàm eat_at_restaurant
vào một module con mới có tên là customer
, sau đó là một scope khác với câu lệnh use
và thân hàm sẽ không biên dịch:
Filename: src/lib.rs
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
use crate::front_of_house::hosting;
mod customer {
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}
}
Listing 7-12: Câu lệnh use
chỉ áp dụng trong scope mà nó nằm trong
Lỗi trình biên dịch cho thấy rằng phím tắt không còn áp dụng trong module customer
:
$ cargo build
Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0433]: failed to resolve: use of undeclared crate or module `hosting`
--> src/lib.rs:11:9
|
11 | hosting::add_to_waitlist();
| ^^^^^^^ use of undeclared crate or module `hosting`
warning: unused import: `crate::front_of_house::hosting`
--> src/lib.rs:7:5
|
7 | use crate::front_of_house::hosting;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_imports)]` on by default
For more information about this error, try `rustc --explain E0433`.
warning: `restaurant` (lib) generated 1 warning
error: could not compile `restaurant` due to previous error; 1 warning emitted
Lưu ý rằng cũng có một cảnh báo rằng use
không còn được sử dụng trong scope của nó nữa!
Để khắc phục sự cố này, hãy di chuyển luôn cả use
trong module customer
hoặc tham chiếu lối tắt
trong module cha với super :: hosting
trong module con customer
.
Tạo các đường dẫn use
theo kiểu Idiomatic
Trong Listing 7-11, bạn có thể thắc mắc tại sao chúng tôi chỉ định use crate :: front_of_house :: hosting
và sau đó gọi là hosting :: add_to_waitlist
trong eat_at_restaurant
thay vì chỉ định đường dẫn use
đến tận hàm add_to_waitlist
để đạt được kết quả tương tự, như trong Listing 7-13.
Filename: src/lib.rs
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
use crate::front_of_house::hosting::add_to_waitlist;
pub fn eat_at_restaurant() {
add_to_waitlist();
}
Listing 7-13: Đưa hàm add_to_waitlist
vào scope với use
, đó là unidiomatic
Mặc dù cả Listing 7-11 và 7-13 đều hoàn thành cùng một nhiệm vụ, nhưng Listing 7-11 là cách theo khuôn mẫu để đưa một hàm vào scope với use
.
Đưa module cha của hàm vào scope với use
có nghĩa là chúng ta phải chỉ định module cha khi gọi hàm.
Việc chỉ định module cha khi gọi hàm làm rõ rằng hàm không được xác định cục bộ trong khi vẫn giảm thiểu sự lặp lại của đường dẫn đầy đủ.
Mã trong Listing 7-13 không rõ ràng về nơi mà add_to_waitlist
được định nghĩa.
Mặt khác, khi nhập các structs, enums, và các item khác với use
,
it’s khuôn mẫu để chỉ định đường dẫn đầy đủ. Listing 7-14 cho thấy một cách theo khuôn mẫu
để đưa cấu trúc HashMap
của thư viện tiêu chuẩn vào scope của binary crate.
Filename: src/main.rs
use std::collections::HashMap; fn main() { let mut map = HashMap::new(); map.insert(1, 2); }
Listing 7-14: Đưa HashMap
vào scope một cách theo khuôn mẫu/span>
Không có lý do chính đáng nào đằng sau mẫu này: đó chỉ là quy ước đã xuất hiện và mọi người đã quen với việc đọc và viết mã Rust theo cách này.
Ngoại lệ cho khuôn mẫu này là nếu chúng ta đưa hai mục có cùng tên vào scope với câu lệnh use
,
bởi vì Rust không cho phép điều đó. Listing 7-15 cho thấy cách đưa hai kiểu Result
vào scope có cùng tên nhưng khác module cha và cách tham chiếu đến chúng.
Filename: src/lib.rs
use std::fmt;
use std::io;
fn function1() -> fmt::Result {
// --snip--
Ok(())
}
fn function2() -> io::Result<()> {
// --snip--
Ok(())
}
Listing 7-15: Đưa hai kiểu có cùng tên vào cùng một scope yêu cầu sử dụng module cha của chúng
Như bạn có thể thấy, việc sử dụng các module cha sẽ phân biệt hai kiểu Result
.
Nếu thay vào đó, chúng tôi chỉ định use std :: fmt :: Result
và use std :: io :: Result
, chúng tôi sẽ có hai loại Result
trong cùng một scope và Rust sẽ không biết chúng tôi muốn nói đến loại nào khi chúng tôi đã sử dụng Result
Cung cấp Tên Mới với Từ khoá as
Có một giải pháp khác cho vấn đề đưa hai kiểu tên giống nhau vào cùng một
scope với use
: sau đường dẫn, chúng ta có thể chỉ định as
và một tên cục bộ mới hoặc bí danh cho kiểu đó. Listing 7-16 chỉ ra một cách khác để viết mã trong
Listing 7-15 bằng cách đổi tên một trong hai kiểu Result
bằng cách sử dụng as
.
Filename: src/lib.rs
use std::fmt::Result;
use std::io::Result as IoResult;
fn function1() -> Result {
// --snip--
Ok(())
}
fn function2() -> IoResult<()> {
// --snip--
Ok(())
}
Listing 7-16: Đổi tên một loại khi nó được đưa vào scope với từ khóa as
Trong câu lệnh use
thứ hai, chúng tôi đã chọn tên mới IoResult
cho kiểu std :: io :: Result
,
sẽ không xung đột với Result
từ std :: fmt
mà chúng tôi có cũng được đưa vào scope.
Listing 7-15 và Listing 7-16 được coi là theo khuôn mẫu, vì vậy sự lựa chọn là tùy thuộc vào bạn!
Re-exporting tên với pub use
Khi chúng tôi đưa một tên vào scope với từ khóa use
, tên có sẵn trong scope mới là private.
Để cho phép code gọi code của chúng tôi tham chiếu đến tên đó như thể nó đã được xác định trong scope của code đó,
chúng tôi có thể kết hợp pub
và use
. Kỹ thuật này được gọi là re-exporting
vì chúng tôi đang đưa một item
vào scope nhưng cũng làm cho item đó khả dụng để những người khác đưa vào scope của họ.
Listing 7-17 hiển thị code trong Listing 7-11 với use
trong module root được thay đổi thành pub use
.
Filename: src/lib.rs
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}
Listing 7-17: Tạo một tên khả dụng cho bất kỳ code nào để sử dụng từ một scope mới với pub use
Trước thay đổi này, external code sẽ phải gọi hàm add_to_waitlist
bằng cách
sử dụng đường dẫnrestaurant :: front_of_house :: hosting :: add_to_waitlist ()
.
Bây giờ, pub use
này đã re-exported lại module hosting
từ module root, external code
hiện có thể sử dụng đường dẫnrestaurant :: hosting :: add_to_waitlist ()
để thay thế.
Re-exporting hữu ích khi cấu trúc bên trong của code của bạn khác với cách
các lập trình viên gọi code của bạn sẽ nghĩ về domain.
Ví dụ, trong phép ẩn dụ về nhà hàng này, những người điều hành nhà hàng nghĩ về “front of house” và “back of house”.
Nhưng khách hàng đến thăm một nhà hàng có thể sẽ không nghĩ về các bộ phận của nhà hàng theo những thuật ngữ đó.
Với pub use
, chúng ta có thể viết code của mình với một cấu trúc nhưng hiển thị một cấu trúc khác.
Làm như vậy làm cho thư viện của chúng tôi được tổ chức tốt cho các lập trình viên làm việc trên thư viện
và các lập trình viên gọi thư viện. Chúng ta sẽ xem xét một ví dụ khác về pub use
và cách nó ảnh hưởng đến
crate’s documentation của bạn trong phần “Exporting a
Convenient Public API with pub use
” của Chapter 14.
Sử dụng External Packages
Trong Chương 2, chúng tôi đã lập trình một guessing game project sử dụng một external
package gọi là rand
để lấy số ngẫu nhiên. Để sử dụng rand
trong project của bạn,
chúng tôi đã thêm dùng này vào Cargo.toml:
Filename: Cargo.toml
rand = "0.8.3"
Thêm rand
như là một dependency trong Cargo.toml yêu cầu Cargo
tải xuống gói rand
và bất kỳ dependencies từ crates.io và cung cấp rand
cho project của chúng tôi.
Sau đó, để đưa các định nghĩa rand
vào scope của package của chúng tôi,
chúng tôi đã thêm một dòng use
bắt đầu bằng tên của crate, rand
,
và liệt kê các mục chúng tôi muốn đưa vào scope.Nhớ lại rằng trong phần “Generating a Random
Number” trong Chương 2,chúng tôi đã đưa đặc điểm Rng
vào scope và gọi hàm rand :: thread_rng
:
use std::io;
use rand::Rng;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
Các thành viên của cộng đồng Rust đã cung cấp nhiều package tại
crates.io, và pull bất kỳ trong số chúng vào package của bạn bao gồm các bước tương tự: liệt kê chúng trong
file package’s Cargo.toml và sử dụng use
đưa các item từ crate của chúng vào scope.
Note that the standard library (std
) is also a crate that’s external to our
package. Because the standard library is shipped with the Rust language, we
don’t need to change Cargo.toml to include std
. But we do need to refer to
it with use
to bring items from there into our package’s scope. For example,
with HashMap
we would use this line:
#![allow(unused)] fn main() { use std::collections::HashMap; }
Đây là một đường dẫn tuyệt đối bắt đầu bằng std
, tên của library crate tiêu chuẩn.
Sử dụng các đường dẫn lồng nhau để clear up danh sách use
lớn
Nếu chúng tôi đang sử dụng nhiều item được xác định trong cùng một crate hoặc cùng một module,
thì việc liệt kê từng item trên một dòng riêng có thể chiếm nhiều không gian theo chiều dọc trong file của chúng tôi.
Ví dụ: hai câu lệnh use
mà chúng ta có trong Guessing Game trong Listing 2-4 đưa các item từ std
vào scope:
Filename: src/main.rs
use rand::Rng;
// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
Thay vào đó, chúng ta có thể sử dụng các đường dẫn lồng nhau để đưa các item giống nhau vào scope trong một dòng. Chúng tôi thực hiện điều này bằng cách chỉ định phần chung của đường dẫn, theo sau là hai dấu hai chấm, sau đó là dấu ngoặc nhọn xung quanh danh sách các phần khác nhau của đường dẫn, như được hiển thị trong Listing 7-18.
Filename: src/main.rs
use rand::Rng;
// --snip--
use std::{cmp::Ordering, io};
// --snip--
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
Listing 7-18: Chỉ định một đường dẫn lồng nhau để đưa nhiều item có cùng tiền tố vào scope
Trong các chương trình lớn hơn, đưa nhiều item vào scope từ cùng một crate hoặc module bằng cách sử dụng các
đường dẫn lồng nhau có thể làm giảm số lượng các câu lệnh use
riêng biệt cần thiết đi rất nhiều!
Chúng ta có thể sử dụng một đường dẫn lồng nhau ở bất kỳ mức nào trong một đường dẫn,
điều này rất hữu ích khi kết hợp hai câu lệnh use
dùng chung một đường dẫn con.
Ví dụ: Listing 7-19 hiển thị hai câu lệnh use
: một câu đưa std :: io
vào scope và một câu đưa std :: io :: Write
vào scope.
Filename: src/lib.rs
use std::io;
use std::io::Write;
Listing 7-19: Two use
statements where one is a subpath
of the other
Phần chung của hai đường dẫn này là std :: io
và đó là đường dẫn đầu tiên hoàn chỉnh.
Để hợp nhất hai đường dẫn này thành một câu lệnh use
, chúng ta có thể sử dụng self
trong đường dẫn lồng nhau, như được hiển thị trong Listing 7-20.
Filename: src/lib.rs
use std::io::{self, Write};
Listing 7-20: Kết hợp các đường dẫn trong Listing 7-19 thành một câu lệnh use
Dòng này đưa std :: io
và std :: io :: Write
vào scope.
Toán tử Glob
Nếu chúng ta muốn đưa tất cả các item public được xác định trong một đường dẫn vào scope, chúng ta có thể chỉ định đường dẫn đó theo sau là *
, toán tử Glob:
#![allow(unused)] fn main() { use std::collections::*; }
Câu lệnh use
này đưa tất cả các item public được định nghĩa trong std :: collection
vào scope hiện tại.
Hãy cẩn thận khi sử dụng toán tử cầu! Glob có thể khiến việc phân biệt những tên nào trong scope
và nơi tên được sử dụng trong chương trình của bạn được xác định là khó hơn.
Toán tử glob thường được sử dụng khi kiểm tra để đưa
mọi thứ đang được kiểm tra vào module tests
; chúng ta sẽ nói về điều đó trong phần “How to Write
Tests” trong chương 11.Toán tử glob
đôi khi cũng được sử dụng như một phần của mẫu dạo đầu: xem the standard
library documentation
để biết thêm thông tin về mẫu đó.
Tách các module thành các file khác nhau
Cho đến nay, tất cả các ví dụ trong chương này đều xác định nhiều module trong một file. Khi các module trở nên lớn, bạn có thể muốn chuyển định nghĩa của chúng sang một file riêng biệt để làm cho code điều hướng dễ dàng hơn.
Ví dụ: hãy bắt đầu từ code trong Listing 7-17 và trích xuất các module vào các file thay vì xác định tất cả các module trong file crate root. Trong trường hợp này,file crate root là src/lib.rs, nhưng quy trình này cũng hoạt động với các binary crate có file crate root là src/main.rs.
Đầu tiên, chúng tôi sẽ giải nén module front_of_house
vào file nó sở hữu. Xóa code bên trong dấu ngoặc nhọn cho module front_of_house
,
chỉ để lại khai báomod front_of_house;
, để src/lib.rs chứa code được hiển thị trong Listing 7-21.
Lưu ý rằng điều này sẽ không được biên dịch cho đến khi chúng tôi tạo tệp src/front_of_house.rs trong Listing 7-22.
Filename: src/lib.rs
mod front_of_house;
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}
Listing 7-21: Khai báo module front_of_house
có phần thân sẽ nằm trong src/front_of_house.rs
Tiếp theo, đặt code nằm trong dấu ngoặc nhọn vào một tệp mới có tên
src/front_of_house.rs, như được hiển thị trong Listing 7-22.
Trình biên dịch biết tìm kiếm trong file này vì khai báo module mà nó tìm thấy trong crate root với tên front_of_house
.
Filename: src/front_of_house.rs
pub mod hosting {
pub fn add_to_waitlist() {}
}
Listing 7-22: Các định nghĩa bên trong module front_of_house
trong src/front_of_house.rs
Lưu ý rằng bạn chỉ cần tải nội dung của file bằng cách sử dụng mod
khai báo một lần ở đâu đó trong cây module của bạn. Sau khi trình biên dịch biết file
là một phần của dự án (và biết mã nằm ở đâu trong cây module vì nơi bạn đã đặt câu lệnh mod
),
các file khác trong dự án của bạn nên tham chiếu đến code trong file đó bằng cách sử dụng
đường dẫn đến nơi nó được khai báo như được đề cập trong phần “Paths for Referring to an Item in the Module
Tree”. Nói cách khác, mod
không phải là một hoạt động “bao gồm ”mà các ngôn ngữ lập trình khác có.
Tiếp theo, chúng tôi cũng sẽ giải nén module hosting
vào file nó sở hữu. Quá trình này
hơi khác một chút vì hosting
là một module con của front_of_house
, không phải của root module.
Tệp cho hosting
sẽ nằm trong một thư mục được đặt tên cho vị trí của nó trong cây module.
Để bắt đầu di chuyển hosting
, chúng tôi thay đổi src/front_of_house.rs để chỉ chứa phần khai báo của module hosting
:
Filename: src/front_of_house.rs
pub mod hosting;
Sau đó, chúng tôi tạo một thư mục src/front_of_house và một file src/front_of_house/hosting.rs để
chứa các định nghĩa được thực hiện trong module hosting
:
Filename: src/front_of_house/hosting.rs
pub fn add_to_waitlist() {}
Thay vào đó, nếu chúng tôi đặt hosting.rs trong thư mục src, trình biên dịch sẽ mong đợi code
đó nằm trong module hosting
được khai báo trong crate root, không phải là phần tử con của module front_of_house
.
Các quy tắc mà trình biên dịch tuân theo để biết những file nào cần tìm cho code của module có nghĩa
là các thư mục và tệp phù hợp hơn với cây module.
Đường dẫn tệp thay thế
Phần này bao gồm các đường dẫn file khuôn mẫu nhất mà trình biên dịch Rust sử dụng; nhưng một đường dẫn file cũ hơn cũng vẫn được hỗ trợ.
Đối với module có tên
front_of_house
được khai báo trong crate root, trình biên dịch sẽ tìm thấy code của module trong:
- src/front_of_house.rs (những gì chúng tôi đã đề cập)
- src/front_of_house/mod.rs (đường dẫn cũ hơn, vẫn được hỗ trợ)
Đối với một module có tên là
hosting
là một module con củafront_of_house
, trình biên dịch sẽ tìm kiếm code của module trong:
- src/front_of_house/hosting.rs (những gì chúng tôi đã đề cập)
- src/front_of_house/hosting/mod.rs (đường dẫn cũ hơn, vẫn được hỗ trợ)
Nếu bạn sử dụng cả hai cho cùng một module, bạn sẽ gặp lỗi trình biên dịch.Sử dụng cho phép các kiểu khác nhau cho các module khác nhau trong cùng một dự án,nhưng có thể gây nhầm lẫn cho những người đang điều hướng dự án của bạn.
Nhược điểm chính của kiểu sử dụng file có tên mod.rs là dự án có thể kết thúc với nhiều file có tên mod.rs, điều này có thể gây nhầm lẫn khi bạn mở chúng trong editor của mình cùng một lúc.
Việc chuyển code của từng module sang một file riêng biệt hiện đã hoàn tất và cây module vẫn giữ nguyên.
Các lệnh gọi hàm trong eat_at_restaurant
sẽ hoạt động mà không có bất kỳ sửa đổi nào, mặc dù các định nghĩa nằm trong các file khác nhau.
Kỹ thuật này cho phép bạn di chuyển các module sang các file mới khi chúng phát triển về kích thước.
Lưu ý rằng câu lệnh pub use crate :: front_of_house :: hosting
trong src/lib.rs cũng không thay đổi, cũng như use
không có bất kỳ
tác động nào đến những file nào được biên dịch như một phần của crate. Từ khóa mod
khai báo các module và Rust tìm kiếm trong một file
có cùng tên với module cho code đi vào module đó.
Tổng kết
Rust cho phép bạn chia một package thành nhiều crate và một crate thành các module để bạn có thể tham chiếu
đến các item được xác định trong một module từ một module khác. Bạn có thể làm điều này bằng cách chỉ định
các đường dẫn tuyệt đối hoặc tương đối. Các đường dẫn này có thể được đưa vào scope bằng câu lệnh use
để bạn có thể
sử dụng đường dẫn ngắn hơn cho nhiều mục đích sử dụng trong scope đó. Code module là private theo mặc định, nhưng bạn có thể
đặt định nghĩa ở chế độ public bằng cách thêm từ khóa pub
.
Trong chương tiếp theo, chúng ta sẽ xem xét một số cấu trúc dữ liệu thu thập trong thư viện chuẩn mà bạn có thể sử dụng trong code được sắp xếp gọn gàng của mình.
Các collections phổ biến
collections: Bộ sưu tập, tập hợp, chỉ cấu trúc dữ liệu lưu trữ nhiều thành phần thành một tập hợp có đặc tính chung nào đó
Thư viện tiêu chuẩn của Rust bao gồm một số cấu trúc dữ liệu rất hữu ích được gọi là collections. Hầu hết các kiểu dữ liệu khác đại diện cho một giá trị cụ thể, nhưng các collections có thể chứa nhiều giá trị. Không giống như các loại array(mảng) và tuple(bộ) được tích hợp sẵn, dữ liệu mà các collections này trỏ tới được lưu trữ trên vùng heap, có nghĩa là lượng dữ liệu không cần biết tại thời điểm biên dịch và có thể tăng lên hoặc thu nhỏ khi chương trình chạy. Mỗi loại collections có tính năng và giá (cost) khác nhau, và chọn một tính năng thích hợp cho tình huống hiện tại của bạn là một tính năng bạn sẽ phát triển theo thời gian. Trong chương này, chúng ta sẽ thảo luận về ba collections được sử dụng rất thường xuyên trong các chương trình Rust:
- Vector cho phép bạn lưu trữ một số lượng giá trị bên cạnh nhau.
- String là một tập hợp các ký tự. Trước đây chúng ta đã đề cập đến kiểu
String
, nhưng trong chương này chúng ta sẽ nói sâu hơn về nó. - Hash map cho phép bạn liên kết giá trị với một khóa cụ thể. Đó là một triển khai cụ thể của cấu trúc dữ liệu chung hơn gọi là một map.
Để tìm hiểu về các loại collections khác được cung cấp bởi thư viện tiêu chuẩn, hãy xem the documentation.
Chúng ta sẽ thảo luận về cách tạo và cập nhật vectors, strings, and hash maps, cũng như những gì làm cho mỗi thứ trở nên đặc biệt.
Lưu trữ danh sách các giá trị với Vectors
Cho tới nay chúng ta đã nhìn thấy kiểu danh sách là Vec<T>
- đọc là vector. xwVector cho phép chúng ta lưu trữ
nhiều các giá trị cùng kiểu bằng cách đặt chúng cạnh nhau trong bộ nhớ. Vector chỉ cho phép lưu trữ các giá trị
cùng kiểu dữ liệu. Eg: Cùng kiểu i32, i64, str, u8... Chúng hưu dụng khi chúng ta có danh sách các đối tượng, giống
như mỗi dòng text trong một file hoặc giá của các items trong một giỏ hàng.
Cách tạo một vector
Để tạo một vector mới và rỗng, chúng ta gọi hàm Vec::new
, xem ví dụ Listing 8-1
fn main() { let v: Vec<i32> = Vec::new(); }
Listing 8-1: Tạo một vector mới, rỗng, kiểu dữ liệu i32
Chú ý rằng, chúng thêm ký hiệu ở đây. Bởi vì, chúng ta đã không chèn bất kỳ giá trị nào vào vector này, Rust
sẽ không biết kiểu dữ liệu nào chúng ta định lưu trữ. Điều này khá là quan trọng. Bởi vì Vector đã
thực hiện sử dụng kiểu dữ liệu tổng quát (generics). Chúng ta sẽ xem xét cách để sử dụng
generics với kiểu dữ liệu mà bạn muốn trong Chương 10. Hiện tại, Kiểu Vec<T>
được cung cấp
bởi thư viện chuẩn và có thể lưu trữ bất kỳ giá tị nào. Khi chúng tạo một vector để lưu trữ một kiểu cụ thể,
chúng ta có thể chi tiết kiểu trong dấu <>. Trong 9-1, chúng ta đã nói rằng Vec<T>
trong đó v sẽ giữ thành phần với kiểu dữ liệu i32
Thường xuyên hơn, bạn sẽ tạo một Vec<T>
với giá trị khởi tạo và Rust sẽ tự ngầm hiểu(infer)) kiểu mà bạn muốn
lưu trữ, do đó hiếm bạn cần ký hiệu cho kiểu dữ liệu. Rust cũng cấp một macro vec!
mà sẽ tạo
một vector mới mà sẽ giữ các giá trị mà bạn truyền vào. Listing 8-2 tạo một Vec<i32
và dữ giá tị
1
,2
, và 3
. Kiểu số nguyên là i32
bởi vì nó là kiểu số nguyên mặc định (4 bytes). Điều này chúng ta
đã thảo luận trong “Data types” Chương 3
fn main() { let v = vec![1, 2, 3]; }
Listing 8-2: Tạo một vectỏ mới bao gồm các giá trị
Bởi vì chúng ta khởi tạo các giá trị i32
, Rust có thể ngầm hiểu kiểu của v
là Vec<i32>
, và ký hiệu
cho kiểu là không cần thiết. Tiêp theo, chúng ta sẽ xem xét cách để thay đổi một vector
Cập nhật một Vector
Để tạo một vector và sau đó thêm các thành phần tới chúng, chúng ta sử dụng phương thức push
như được chỉ ra
trong Listing 8-3
fn main() { let mut v = Vec::new(); v.push(5); v.push(6); v.push(7); v.push(8); }
Listing 8-3: Sử dụng phương thức push
để thêm các giá trị tới một
vector
Bởi vì với bất kỳ biến nào, nếu bạn muôn có thể thay đổi giá trị của chúng, bạn cũng sẽ cần làm cho nó mutable
(có thể thay đổi được) bằng cách sử dụng từ khoá mut
, như đã nói đến trong Chương 3. Số chúng đặt trong vector là kiểu i32
, và Rust
ngầm hiểu từ dữ liệu, do đó chúng ta không thực sự cần ký hiệu Vec<i32>
Huỷ thành phần trong một vector
Giống như bất kỳ kiếu struct
nào, một vector được giải phóng khi nó ra ngoài phạm vi của nó xem Listing 8-4.
fn main() { { let v = vec![1, 2, 3, 4]; // do stuff with v } // <- v goes out of scope and is freed here }
Listing 8-4: Nơi vector và các giá trị của nó bị huỷ
Khi vector bị huỷ, tất cả nội dung trong nó sẽ bị huỷ, nghĩa rằng tất cả số nguyên nó giữ sẽ bị xoá sạch.
Điều này có vẻ dường như đơn giản nhưng nếu như chúng ta bắt đầu học về tham chiếu
(reference
) tới các thành phần
của một vector, chắc chắn nó không còn dễ hiểu như vậy nữa
Đọc thành phần (elements) trong Vector
Có 2 cách để tham chiếu một giá trị lưu trong một vector: thông qua index (chỉ số) hoặc sử dụng phương thức get
.
Trong ví dụ dưới đây, chúng ta ký hiệu kiểu của các giá trị mà được trở về từ các hàm trên cho mục địch phân làm rõ hơn.
Listing 8-5 chỉ ra cả 2 phương thức truy xuất một giá trị trong một vector, một sử dụng chỉ số, một sử dụng phương thức get
fn main() { let v = vec![1, 2, 3, 4, 5]; let third: &i32 = &v[2]; println!("The third element is {}", third); match v.get(2) { Some(third) => println!("The third element is {}", third), None => println!("There is no third element."), } }
Listing 8-5: Sử dụng cú pháp chỉ số hoặc phương thức get
để truy xuất một đối tượng trong một vector
Chú ý có 2 chi tiết ở đây. Đầu tiên, chúng ta sử dụng giá trị chỉ số 2
để lấy phần tử thứ 3 bởi vì vector được
đánh chỉ số bắt đầu từ 0. Thứ hai, chúng ta lấy phần tử thứ 3 bởi sử dụng &
hoặc []
, mà đưa chúng ta
một tham chiếu hoặc sử dụng phương thức get
với chỉ số truyền vào như tham số, kết quả là Option<&T>
Lý do Rust cung cấp 2 cách để tham chiếu một thành phần là bạn có thể chọn cách chương trình hành xử (behaves) khi bạn cố gắng để sử dụng một giá trị ngoài dãy các thành phần xác định. Ví dụ, xem xét chuyện gì xảy ra khi chúng ta có một vector với chỉ 5 thành phần và bạn lại luốn truy xuất tới thành phần có index 100. Xem xét Listing 8-6.
fn main() { let v = vec![1, 2, 3, 4, 5]; let does_not_exist = &v[100]; let does_not_exist = v.get(100); }
Listing 8-6: Attempting to access the element at index 100 in a vector containing five elements
Khi bạn chạy đoạn code này, phương thức đầu tiên []
sẽ gây chương trình panic
(ngắt) bởi vì
nó tham chiếu tới một thành phần không tồn tại. Điều này là tốt khi bạn muốn chương trình crash
nếu
như bạn không muốn có sự truy xuất tới thành phần ngoài vector (Ví dụ như 1 số chương trình cố gắn truy nhập ô nhớ sau vector đề biết nhiều thông tin hơn chẳng hạn)
Khi phương thức get
được sử dụng với chỉ số nằm ngoài một vector, nó trở về None
ngoài trừ panicking (ngắt
).
Bạn sẽ sử dụng phương thức này nếu truy xuất một thành phần vược ra ngoài khoảng của vector có thể xảy ra thường xuyên
trong một số trường hợp. Code của bạn sẽ có logic để xử lý hoặc là Some(&element)
hoặc None
như đã thảo luận trong chương 6.Ví dụ, chỉ số có thể đến từ một người nhập vào một số. Nếu họ vô tình nhập một số mà quá lớn, chương trình
sẽ có giá trị None
, bạn có thể nói người dùng bao nhiều items trong vector hiện tại, và đưa cho họ một cơ hội khác với
giá trị nhập vào hợp lý hơn. Điều này là nhiều thân thiện hơn là ngắt chương trình chỉ vì một lỗi nhập số ngớ ngẩn.
Khi chương trình có một tham chiếu hợp lệ, chương trình borrow checker
(bộ kiểm tra nguyên lý mượn) thực thi luật
quyền sở hữu (ownership) và nguyên lý borrowing (đã nói trong chương 4) để đảm bảo các tham chiếu và bất kỳ tham chiếu
khác tới nội dung của vector còn lại hợp lệ. Nhắc lại luật này, bạn không thể có cùng lúc tham chiếu mutable và immutable trong cùng phạm vi (scope - Ví dụ cùng 1 hàm). Luật này áp dụng trong Listing 8-7, nơi chúng ta giữ một tham chiếu immutable(không thay đổi được) tới thành phần đầu tiên của vector và cố gắn thêm một thành phần tới cuối cùng. Chương trình này sẽ
không chạy nếu chúng ta cố gắng tham chiếu tới thành phần đó trong hàm.
fn main() {
let mut v = vec![1, 2, 3, 4, 5];
let first = &v[0];
v.push(6);
println!("The first element is: {}", first);
}
Listing 8-7: Cố gắng thêm một thành phần tới một vector trong khi giữ một tham chiếu tới một thành phần
Biên dịch code này sẽ lỗi:
$ cargo run
Compiling collections v0.1.0 (file:///projects/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
--> src/main.rs:6:5
|
4 | let first = &v[0];
| - immutable borrow occurs here
5 |
6 | v.push(6);
| ^^^^^^^^^ mutable borrow occurs here
7 |
8 | println!("The first element is: {}", first);
| ----- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` due to previous error
Code trong Listing 8-7 thoạt nhìn không có gì sai: Tại sao một tham chiếu tới thành phần đầu tiên quan tâm tới sự thay đổi tại thành phần cuối của một vector? Lỗi này là bởi vì cách vector hoạt động: bởi vì vectors đặt các giá trị cạnh trong trong bộ nhớ, thêm một thanh phần mới vào cuối của vector có thể yêu cầu cấp phát bộ nhớ và copy các thành phần của tới không gian mới này, nếu không đủ bộ nhớ để đặt tất cả các thành phần cạnh nhau nơi vector được lưu trữ hiện tại. Trong trường hợp này, tham chiếu tới thành phần đầu tiên trỏ tới bộ nhớ được thu hồi (deallocated memory). Luật borrowing ngăn chặn chương trình rơi vào tình huống này.
Chú ý: Cho nhiều thông tin chi tiết thực hiện kiểu
Vec<T>
, xem cuốn “The Rustonomicon”.
Duyệt qua các giá trị trong một Vector
Để truy xuất mỗi thành phàn trong một vector lần lượt, chúng ta có thể duyệt qua (iterate) tất các thành phần
hhown là sử dụng chỉ thị để truy xuất mỗi thành phần. Listing 8-8 chỉ cách để sử dụng for
lặp để có tham chiếu immutable tới mỗi thành phần trong một Vector i32
và in chúng
fn main() { let v = vec![100, 32, 57]; for i in &v { println!("{}", i); } }
Listing 8-8: In mỗi thành phần trong một Vector bởi duyệt qua các thành phần sử dụng vòng lặp for
Chúng ta cũng có thể duyệt qua tham chiếu mutable tới mỗi thành phần trong một vector mutable lần lượt để thay đổi tất cả thành phần.
Vòng lặp for
trong Listing 8-9 sẽ cộng thêm 50
tới mỗi thành phần
fn main() { let mut v = vec![100, 32, 57]; for i in &mut v { *i += 50; } }
Listing 8-9: Duyệt qua các tham chiếu mutable trỏ tới các thành phần trong một vector
Để thay đổi giá trị mà một tham chiếu mutable trỏ tới, chúng ta có thể sử toàn tử *
(gọi là dereference operator) để lấy giá trị trong i
trước khi chúng ta
có thể sử dụng toán tử +=
. Chúng ta sẽ nói nhiều về toán tử derefence này
“Toán từ Dereference như một con trỏ tới một giá trị”
trong chương 15
Sử dụng Enum để lưu trữ nhiều kiểu dữ liệu
Vectors có thể chỉ lưu trữ các giá trị mà có cùng kiểu. Điều này có thể hơi bất tiện; rõ ràng có trường hợp cho cần dể lưu trữ một danh sách các phần tử của kiểu khác nhau
May mắn thay, biến thể của một enum định nghĩa dưới cùng kiểu enum, nên khi chúng ta cần 1 kiểu để thể hiện các thành phần của kiểu khác nhau, chúng ta có thể sử dụng enum
!
Ví dụ, chúng ta muốn lấy gái trị từ một dòng trong 1 spreadsheet (tài liệu) nơi một số cột trong hàng bao gồm số nguyên dượng, một vài sốt thực, và một số string.
Chúng ta có thể định nghĩa một enum mà các biến của nó sẽ giữ kiểu khác nhau, và tất các biến enum sẽ được xem là cùng một kiểu: kiểu enum. Sau đó chúng ta có thể tạo một vector
để lưu trữ enum và do đó không giới giạn lưu trữ kiểu dữ liệu khác nhau. Chúng ta sẽ trình bày điều này trong Listing 8-10
fn main() { enum SpreadsheetCell { Int(i32), Float(f64), Text(String), } let row = vec![ SpreadsheetCell::Int(3), SpreadsheetCell::Text(String::from("blue")), SpreadsheetCell::Float(10.12), ]; }
Listing 8-10: Định nghĩa enum
để lưu trữ giá trị của kiểu khác nhau trong một vector
Rust cần để biết kiểu dữ liệu nào sẽ trong một Vector tại lúc biên dịch do đó nó biết trình chính xác bao nhiều bộ nhớ trong vùng heap sẽ được cần để lưu trữ mỗi thành phần.
Chúng ta cũng phải chính xác về kiểu dữ liệu nào được cho phép trong vector này. Nếu Rust cho phép một vector để lưu trữ bất kỳ kiểu nào, sẽ có lúc rằng một hoặc nhiều kiểu
sẽ gây lỗi với điều khiển thực hiện trong thành phần của Vector. Sử dụng enum với match
cú pháp nghĩa rằng Rust sẽ đảm bảo tại lúc biên dịch mõi trường hợp có thể xảy ra sẽ được
xử lý, bởi như đã nói ở Chương 6.
Nếu bạn không biết tập hợp kiểu có thể của kiểu dữ liệu mà một chương trình tại lúc runtime (lúc chạy chương trình) lưu giữ trong một Vector, công nghệ enum sẽ áp dụng được. Thay vào
đó, bạn có thể sử dụng trait object (đối tuợng trait), mà chúng ta sẽ học trong Chương 17
Nào, chúng ta đã thảo luận một số cách thông thường để sử dụng Vector, xem lại the API documentation để tất cả các phương thức hữu dụng định nghĩa trong
Vec<T>
trong thư viện chuẩn. Ví dụ, trong hàm push
, phương thức pop
xoá và trả về giá trị cuối cùng. Tiếp theo, cùng xem xét kiểu collection String
Lưu trữ UTF-8 Encoded Text (Chữ định dạng UTF-8) với kiểu Strings
Chúng ta đã nói về string
trong chương 4, nhưng chúng sẽ xem xét kỹ lưỡng chúng bây giờ.
Một Rustaceans mới thường gặp rắc rối với string khi kết hợp 3 thứ sau: Biểu thị lỗi trong string,
cấu trúc dữ liệu phức tạp của string
và thứ 3: Mã hoá dạng UTF-8.
Ba nhân tố này kết hợp thành thứ mà dường như khó khi bạn đến từ một ngôn ngữ khác.
Chúng ta thảo luận string trong ngữ cảnh collections bởi vì strings được coi như một tập hợp của các bytes, vài phương
thức thêm vào cung cấp chức năng hữu dụng khi bytes của nó được coi như là text. Trong chương này, chúng ta sẽ nói về
những điều khiển trong String
(kiểu dữ liệu) mà mọi kiểu collection có, giống như điều khiển thông thường như tạo, cập nhật, và đọc. Chúng ta cũng sẽ bàn về việc
String
là đôi chút khác với các kiểu collection khác, và việc indexing thành một String
là phức tạp bởi có sự khác nhau giữa cách người và máy tính giải thích kiểu String
;
String là gì?
Đầu tiên, Chúng ta sẽ định nghĩa thuật ngữ string. Rust chỉ có một kiểu string trong ngôn ngữ, nơi nó là dạng slice
str
mà thường
được coi biểu thị trong &str
(mượn). Trong chương 4, chúng ta đã nói về string slices, mà là tham chiếu tới dữ liệu text định dạng UTF-8. String, bản chất
ví dụ, là được lưu trữ trong tệp nhị phân và do đó là string slices
Kiểu String
, nơi được cung cấp bởi thư viện chuẩn của Rust hơn là được lập trình thành ngôn ngữ core, là một kiểu chuỗi (string) có thể mở rộng, thay đổi, owned,
định dạng UTF8. Khi lập trình viên Rust (Rustaceans) tham chiếu "string" trong Rust, họ có thể đang tham chiếu tới kiểu String
hoặc kiểu &str
, hoặc không phải một
trong 2 kiểu trên. Mặc dù chương này mục đích chính là về String
, cả 2 kiểu là được sử dụng nhiều trong thư viện chuẩn Rust, và cả String
và slices
là dưới dạng UTF8-encoded
Thư viện chuẩn Rust cũng bao gồm một số kiểu string khác, giống như OsString
, OsStr
, CString
, và CStr
. Những thư viện crates có thể cung cấp cả nhiều lựa chọn
cho việc lưu trữ dữ liệu dạng string. Nhìn cách kiểu kia đều kết thức với String
hoặc Str
?. Chúng tahm chiếu tới biến hoặc sở hữu hoặc mượn, cũng giống String
và
str
bạn đã nhìn thầy trước đó. Các kiểu string này có thể lưu trữ text trong định dạng mã hoá khác nhau hoặc được thể hiện trong bộ nhớ theo một cách nào đó. Ví dụ, Chúng
ta sẽ không thảo luận các kiểu dữ liệu này trong chương này; xem tài liệu của chúng nhiều hơn hoặc cách sử dụng để biết cách khi nào sử dụng chúng một cách thích hợp.
Tạo một String
Nhiều thao tác với Vec<T>
cũng được sử dụng với String
, ví dụ hàm new
để tạo một string, xem Listing 8-11
fn main() { let mut s = String::new(); }
Listing 8-11: Tạo mới một String
rỗng
Dòng này tạo một mới một string rỗng và gán tới s
. Thông thường, chúng ta sẽ khởi tạo với một giá trị mà chúng ta muốn
Để làm điều này, chúng ta có thể sử dụng phương thức to_string
, mà nó có trong tất cả các kiểu mà thực hiện trait Display
, và string cũng thế. Listing 8-12 xem xét 2 ví dụ
fn main() { let data = "initial contents"; let s = data.to_string(); // the method also works on a literal directly: let s = "initial contents".to_string(); }
Listing 8-12: Using the to_string
method to create a
String
from a string literal
This code creates a string containing initial contents
.
We can also use the function String::from
to create a String
from a string
literal. The code in Listing 8-13 is equivalent to the code from Listing 8-12
that uses to_string
.
fn main() { let s = String::from("initial contents"); }
Listing 8-13: Sử dụng hàm String::from
để tạo String
từ một chuỗi
Bởi vì chuỗi được sử dụng cho nhiều thứ, chúng ta có thể sử dụng generic khác nhau cho chuỗi, cho phép
chúng ta nhiều lựa chọn. Một trong số đó dường như hơi thừa thãi, nhưng không sao cả. Trong trường hợp này, String::from
và to_string
cùng hành động giống nhau, do đó bạn có thể chọn phương thức nào cũng được phụ thuộc vào bạn.
Nhớ rằng strings là có định dạng mã hoá UTF-8, do dó chúng có bao gồm bất kỳ dữ liệu mã hoá trong đó, Listing 8-14 là ví dụ
fn main() { let hello = String::from("السلام عليكم"); let hello = String::from("Dobrý den"); let hello = String::from("Hello"); let hello = String::from("שָׁלוֹם"); let hello = String::from("नमस्ते"); let hello = String::from("こんにちは"); let hello = String::from("안녕하세요"); let hello = String::from("你好"); let hello = String::from("Olá"); let hello = String::from("Здравствуйте"); let hello = String::from("Hola"); }
Listing 8-14: Lưu trữ câu lời chào trong các ngôn ngữ khác nhau
Tất cả chúng là giá trị String
hợp lệ
Cập nhật một String
Nếu bạn đẩy nhiều dữ liệu, một String
có thể tự tăng kích thước, và nội dụng sẽ thay đổi, giống nội dụng của một Vec<T>
.
Thêm vào đó, bạn có thể sử dụng toán tử +
hoặc macro format!
để hợp nhất 2 giá trị String
Thêm dữ liệu tới một String sử dụng push_str
và push
Chúng ta thêm dữ liệu vào String
bởi sử dụng phương thức push_str
và kích thước String
sẽ tăng lên. Xem Listing 5-15
fn main() { let mut s = String::from("foo"); s.push_str("bar"); }
Listing 8-15: Thêm một string slice vào một String
sử dụng phương
thức push_str
Sau 2 dòng trên, s
sẽ là foobar
. Phương thức push_str
nhận tham số là string sclie bởi vì chúng ta không
cần thiết truyền vào tham số với một ownership. Ví dụ, trong code Listing 8-16, chúng ta muốn sử dụng s2
sau khi
thêm nội dung nó tới s1
.(Nếu truyền ownership vào hàm push_str rồi thì s2 không dùng được nữa - đó là điều chúng ta không muốn)
fn main() { let mut s1 = String::from("foo"); let s2 = "bar"; s1.push_str(s2); println!("s2 is {}", s2); }
Listing 8-16: Sử dụng string slice sau khi thêm nội dung của nó tới một String
Nếu push_str
lấy quyền sở hữu của s2
, chúng sẽ không thể in được giá trị của nó ở dòng cuối, Tuy nhiên, dòng code này
cũng sẽ chạy được như kỳ vọng
Phương thức push
nhân một ký tự đơn như một tham số và thêm nó tới String
. Listing 8-17 thêm ký tự "l" tới một String
sử dụng phương thức push
fn main() { let mut s = String::from("lo"); s.push('l'); }
Listing 8-17: Thêm một ký tự tới String
sử dụng `push
Kết quả là s
sẽ bao gồm chuỗi lol
As a result, s
will contain lol
.
Gộp 2 chuỗi với toán tử +
hoặc sử dụng macro format!
Thông thương, bạn sẽ muốn kết hợp 2 chuỗi với nhau. Một cách để làm điều này là sử dụng toán tử +
,Listing 8-18
fn main() { let s1 = String::from("Hello, "); let s2 = String::from("world!"); let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used }
Listing 8-18: Sử dụng toán tử +
để kết hợp 2 String
thành một String
mới
Chuỗi s3
sẽ bao gồm Hello, world!
. Lý do s1
là không còn tồn tại (valid) sau thêm vào và lý do chúng ta
đã sử dụng một tham chiếu đến s2
, là bởi vì Rust đối cử toán tử +
như sử dụng phương thức add
mà trông giống như sau:
fn add(self, s: &str) -> String {
Trong thư viện chuẩn, bạn sẽ nhìn thấy định nghĩa add
sử dụng generic. Ở đây, chúng ta đã thay thế kiểu cụ thể cho generic
nơi mà chúng ta gọi hàm này với String
. Chúng ta sẽ thảo luận về generic trong chương 10. Hàm chữ ký cho toán tử +
sẽ
giúp chúng ta có ý niệm để hiểu một chút cách +
hoạt động
Đầu tiên, s2
có &
, nghĩa là chúng ta thêm một tham chiếu (reference) của chuỗi thứ 2 tới chuỗi thứ nhất.
Điều này bởi vì tham số s
trong hàm add
: chúng ta có thể chi thêm &str
tới một String
; Chúng ta không có thể
cộng 2 String
cùng nhau. Nhưng khoan, kiểu của &s2
là '&String, không phải là
&str` mà. Nhưng tại sao Listing 8-18 lại
vẫn có thể biên dịch?
Lý do là chúng ta có thể sử dụng &s2
trong lời gọi hàm tới add
là rằng, trình biên dịch có thể ép buộc (coere)
&String
thành một &str
. Khi chúng ta gọi phương thức add
, Rust sử dụng một sự ép buộc deref (deref coercion)
nơi mà nó biến &s2
thành &s2[..]
. Chúng ta sẽ nói về ép buộc deref sâu hơn trong chương 15 Bởi vì hàm add
không
nhận quyền sở hữu của tham số s
, s2
sẽ có thể được dùng tiêp sau điều khiển này.
Thứ hai, chúng ta có thể nhìn thấy trong chữ của hàm add
nhận quyền sở hữu của self
, bởi vì self
không có &
. Điều
này nghĩa là s1
trong Listing 8-18 sẽ được move vào lời gọi hàm add
và sẽ không còn valid nữa. Do đó, mặc dù
let s3 = s1 + &s2;
trông như nó sẽ copy cả 2 strings và tạo một string nmoiws, câu lệnh này thật sự lấy ownership của s1
thêm một bản sao nội dung s2
và trở về một sỡ hữu của kết quả. Nói một cách khác, nó làm nhiều việc và hiểu quả hơn là
chỉ copy.
Nếu chúng ta cần gộp nhiều chuỗi, hành vi của toán tử +
sẽ hơi rườm rà và không hiệu quả(unwieldy)
fn main() { let s1 = String::from("tic"); let s2 = String::from("tac"); let s3 = String::from("toe"); let s = s1 + "-" + &s2 + "-" + &s3; }
Tại điểm này, s
sẽ có giá trị là tic-tac-toe
. Với tất cả ký tự +
và "
, nó sẽ khó để nhìn thấy thế nào. Cho việc kết
hợp nhiều chuỗi phức tạp, chúng ta sử dụng macro format!
thay vì.
fn main() { let s1 = String::from("tic"); let s2 = String::from("tac"); let s3 = String::from("toe"); let s = format!("{}-{}-{}", s1, s2, s3); }
Đoạn code này cũng biến s
thành tic-tac-toe
. Macro format!
làm việc giống như macro println!
, nhưng thay vì in đầu ra tới
màn hình, nó trở về một String
với nội dung. Phiên bản này sử dụng format!
là dễ để đọc và code được tạo bởi macro
format!
sử dụng tham chiếu. Do đó, lời gọi hàm này không thay đổi bất kỳ quyền sở hữu của các tham số truyền vào.
Chỉ số trong String (Indexing into String)
Trong nhiều ngôn ngữ lập trình khác, truy cập ký tự riêng rec trong một chuỗi bởi tham chiếu đến chúng thông của chỉ số (index). Tuy nhiên nếu bạn cố gắng truy xuất phần của String
sử dụng cú pháp chỉ số trong Rust, bạn sẽ nhận về một lỗi.
Xem xét đoạn code không đúng sau trong Listing 8-19
fn main() {
let s1 = String::from("hello");
let h = s1[0];
}
Listing 8-19: Cố gắng để sử dụng chỉ số để truy cập trong String
Đoạn code này sẽ nhận về một lỗi sau:
$ cargo run
Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `String` cannot be indexed by `{integer}`
--> src/main.rs:3:13
|
3 | let h = s1[0];
| ^^^^^ `String` cannot be indexed by `{integer}`
|
= help: the trait `Index<{integer}>` is not implemented for `String`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` due to previous error
Lỗi này nói với chúng ta một thứ: Chuỗi trong Rust không hỗ trợ indexing (chỉ số). Nhưng tại sao không? Để trả lời được câu hỏi này, chúng ta cần hiểu cách Rust lưu trữ strings trong bộ nhớ.
Biểu thị bộ nhớ bên trong của String
Một String
là một đối tượng chứa (wrapper) một kiểu Vec<u8>
. Cùng xem chuỗi ví dụ mã hoá UTF-8 từ Listing 8-14.
Đầu tiền, điều này:
fn main() { let hello = String::from("السلام عليكم"); let hello = String::from("Dobrý den"); let hello = String::from("Hello"); let hello = String::from("שָׁלוֹם"); let hello = String::from("नमस्ते"); let hello = String::from("こんにちは"); let hello = String::from("안녕하세요"); let hello = String::from("你好"); let hello = String::from("Olá"); let hello = String::from("Здравствуйте"); let hello = String::from("Hola"); }
Trong trường hợp này, hàm len
là 4, nghĩa vector đang giữ chuỗi "Hola" (độ dài 4 bytes). Mỗi một ký tự chúng chiếm 1 byte
khi được mã hoá trong UTF-8. Theo đoạn code trên, có thể làm cho bạn bất ngờ. (Chú ý rằng chuỗi bắt đầu với chũ cái Cyrillic Ze, không phải số 3 Ả rập)
fn main() { let hello = String::from("السلام عليكم"); let hello = String::from("Dobrý den"); let hello = String::from("Hello"); let hello = String::from("שָׁלוֹם"); let hello = String::from("नमस्ते"); let hello = String::from("こんにちは"); let hello = String::from("안녕하세요"); let hello = String::from("你好"); let hello = String::from("Olá"); let hello = String::from("Здравствуйте"); let hello = String::from("Hola"); }
Câu hỏi là chuỗi kia chiếm mấy bytes, bạn có thể nói là 12. Sự thật, Câu trả lời là 24: Số bytes nó chiếm để mã hoá chuỗi “Здравствуйте” trong UTF-8, bởi mỗi giá trị scalar Unicode trong chuỗi chiếm 2 bytes lưu trữ. Do đó, một chỉ số trong string sẽ không tương quan tới giá trị scalar Unicode. Để minh hoạ, xem đoạn code không đúng sau:
let hello = "Здравствуйте";
let answer = &hello[0];
Bạn cũng đã biết rằng câu trả lời
sẽ không phải là 3
, ký tự đầu tiên. Với mã hoá UTF-8, byte đầu tiên của 3
là 208
và byte thứ 2 là 151
, nhưng 208
không phải là ký tự hợp lệ. Trở về 208
là không giống những gì một người dùng muốn nếu họ hỏi về ký tự đầu tiên của chuỗi; tuy nhiên, điều này dữ liệu mà Rust có
tại chỉ số index 0. Người dùng một cách tổng quát không muốn sử dụng giá trị byte trở về, dù nếu chuỗi bao gồm chỉ ký tự Latin
: Nếu &"hello"[0]
là code hợp lệ mà trở về giá trị byte, nó sẽ trở về 104
chứ không phải h
Câu trả lời là để tránh trở về một giá trị không kỳ vọng và gây lỗi, Rust không biên dịch đoạn code này và ngăn chặn hiểu nhầm một cách sớm nhất trong quá trình viết code.
Bytes và Scalar Values và Grapheme Clusters! Oh My!
Một điểm khác về UTF-8 là rằng có 3 cách thực sự liên quan để quan niệm chuỗi trong Rust: Như là mảng bytes, các giá trị scalar và biểu đồ cụm (grapheme clusters) (thứ tưởng tượng gần như là các ký tự (letters))
Nếu bạn nhìn vào chữ Hindi “नमस्ते” được viết trong Devanagari script, nó sẽ được lưu trữ trong một vector của u8
trông
giống như sau:
[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]
Đó là 18 bytes cách mà máy tính lưu trữ dữ liệu của chúng ta. Nếu chúng ta nhìn chúng như giá trị Unicode scalar,
Giả trị char
trong Rust sẽ là
['न', 'म', 'स', '्', 'त', 'े']
Có 6 giá trị char
ở đay, nhưng kí tự thứ 4' (्') và thứ 6('े') không phải là từ, chúng là những dấu
mà không có ý nghĩa gì cả. Cuối cùng, nếu chúng ta nhìn chúng như biểu đồ cụm, chúng ta get 4 ký tự trong chữ Hindi
["न", "म", "स्", "ते"]
Rust cung cấp những cách khác nhau để thông dịch những dữ liệu chuỗi thô mà máy tính lưu trữ mà mỗi chương trình có thể lựa chọn thông dịch nó cần, bất kể dữ liệu được lưu trữ trong ngôn ngữ nào.
Một lý do cuối cùng, Rust không cho phép chúng ta sử dụng index trong một String
để lấy ký tự là rằng
điều khiển indexing là được kỳ vọng để lấy với thời gian độ phức tạp O(1). Nhưng điều này không có thể khả năng
để đảm bảo hiệu năng với String
, bởi vì Rust phải duyệt qua nội dung từ đầu tới chỉ số để xem xét có bao nhiêu ký tự
hợp lệ
Slicing Strings (Phần của String/ Dạng lát cắt String)
Chỉ số trong string thường ý tưởng tồi bởi nếu không biết chính xác kiểu trả về: một giá trị byte, một ký tự, một cụm hoặc một string sclie. Nếu bạn thật sự cần để sử chỉ số để tạo ra phần của string, do đo, Rust sẽ hỏi bạn chi tiết hơn.
Thay vì sử dụng chỉ số với [] với một số, bạn có thể sử dụng
[]` với một dãy để tạo một string slice bao gồm các bytes cụ thể
#![allow(unused)] fn main() { let hello = "Здравствуйте"; let s = &hello[0..4]; }
Ở đây, s
sẽ là một &str
mà bao gồm 4 bytes của 1 string. Trước đây, chúng ta đã đề cập mỗi một
ký tự là 2 bytes, nghĩa là s
sẽ là Зд
Nếu như chúng ta cố gắng tạo một phần của slice như sau
&hello[0..1]
, Rust sẽ panic tại lục run time bởi vì sử dụng chỉ số không xác định để truy xuất trong 1 vector
$ cargo run
Compiling collections v0.1.0 (file:///projects/collections)
Finished dev [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/collections`
thread 'main' panicked at 'byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`', src/main.rs:4:14
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Bạn nên sử dụng dãy để tạo một string sclice với sự cẩn trọng, bởi vì có thể làm crash chương trình của bạn
Các phương thức để duyệt qua một String
Cách tốt nhất để điều khiên một phần của strings là biết được bạn muốn ký tự hoặc bytes. Cho giá trị Unicode scalar,
sử dụng phương thức chars
. Gọi hàm chars
trong “नमस्ते” chia tách và trở về 6 giá trị của char
, và
bạn có thể duyệt qua kết quả để truy xuất tới mỗi thành phần:
#![allow(unused)] fn main() { for c in "नमस्ते".chars() { println!("{}", c); } }
Đoạn code sẽ in ra như sau
न
म
स
्
त
े
Một cách thay thế, phương thức bytes
trở về mỗi byte raw, mà có thể chính xác ý muốn chúng ta hơn:
#![allow(unused)] fn main() { for b in "नमस्ते".bytes() { println!("{}", b); } }
Đoạn code này in 18 bytes tạo nên String
này:
224
164
// --snip--
165
135
Nhưng đảm bảo luôn nhớ rằng, giá trị Unicode scalar hợp lệ có thể được tạo thành nhiều hơn 1 byte
Grapheme Clusters của strings là phức tạp, do đó chức năng này không được cung cấp bởi thư viện chuẩn. Tìm kiếm trong crates.io nếu bạn cần chức năng này
String là không đơn giản
Tổng quát, strings là phức tạp. Ngôn ngữ lập trình khác nhau chọn cách khác nhau để thể hiện sử phức tạp này đến lập trình viên. Rust đã chọn String
cho xử lý tới tất cả chương trình Rust, nghĩa là lập trình viện phải suy nghĩa cách xử lý
UTF-8 trước. Sự đánh đổi này tiết lộ nhiều sự phức tạp của strings hơn các nông ngữ khác, nhưng nó ngăn chặn bạn
tránh khỏi việc xử lý lỗi liên quan tới ký tự không phải ASCII sớm trong vòng đời phát triển.
Cùng chuyển tới một thứ phức tạp ít một chút là: Hash Maps
Lưu trữ key/value trong Hash Maps
Phần cuối của các collections phổ biến là hash map. Kiểu HashMap<K,V>
lưu trữ một liên kết giữa các Key có kiểu K
tới
giá trị của nó với kiểu V
sử dụng một hàm hashing (hashing function). Nhiều ngôn ngữ lập trình hỗ trợ cấu trúc dữ liệu này
nhưng chúng thường sử dụng tên khác như hash
, map
(trong Go), hash table
, dictionary, hoặc associative array...
Kiểu Hash maps là hữu dụng khi bạn muốn to tìm kiềm dữ liệu với một key với dữ liệu bất ký, không phải sử dụng index giống bạn làm với Vector.
Ví dụ: trong một game, bạn có thể giữ dấu vết của điểm mỗi đội trong một hash map nơi mỗi Key là tên của mỗi đội, và giá trị của nó là điểm của mỗi đội.
Khi biết tên của đội, bạn có thể truy vấn điểm của đội đó.
Chúng ta sẽ đi qua những hàm cơ bản của hash maps trong chương này, nhưng nhiều thứ là ẩn đấu trong những hàm được định nghĩa `HashMap<K,V> bởi thư viện chuẩn. Kiểm tra tài liệu thư viện chuẩn bất cứ khi nào bạn muốn tìm kiếm nhiều thông tin hơn.
Tạo mới một Hash Map
Một cách để tạo một Hash Map rỗng là sử dụng hàm new
và thêm thành với mới bằng hàm insert
. Trong Listing 8-20, chúng sẽ theo dấu của 2 dội nơi tên của họ là
Blue và Yellow. Đội Blue bắt đầu với 10 điểm, và đội Yellow bắt đầu với 50
fn main() { use std::collections::HashMap; let mut scores = HashMap::new(); scores.insert(String::from("Blue"), 10); scores.insert(String::from("Yellow"), 50); }
Listing 8-20: Tạo mới một Hash Map và chèn một keys/values
Chú ý rằng, Đầu tiên chúng ta cần sử dụng
HashMap
từ phần trong collections của bộ thư viện chuẩn.
Trong 3 collections phổ biến, thì đây là một cấu trúc ít được dùng nhất. Nó không bao gồm nhiều tính năng lúc đầu
Hashmap cũng có ít hỗ trợ trong thư viện chuẩn, không có kiều macro built-in (macro sẵn) để
tạo chúng.
Cũng giống như Vector, Hash Map lưu trữ dữ liệu trong vùng heap. HashMap
có các keys của String
và giá trị là kiểu
i32
. Giống như vector, hash map là đồng nhất, nghĩa là tất cả keys phải có cùng một kiểu dữ liệu giống nhau
và giá trị của chúng cũng phải như vậy
Một cách khác để khởi tạo một hash map là sử dụng iterators (bộ duyệt) và phương thức collect
một vector của tuples, nơi mà mỗi tuple bao gồm một key và giá trị của nó. Chúng ta sẽ chi tiết về
iterators và các phương thức liên kết của nó trong ”Xử lý items với Iterator” trong chương 13
Phương thức collect
thu thập dữ liệu thành một số kiểu collections bao gồm trong đó có HashMap
.
Ví dụ, nếu chúng có tên team, và giá trị điểm khởi tạo trong 2 vector riêng rẽ, chúng ta có thể sử dụng hàm zip
để
tạo một iterator của tupple nơi "Blue" là liên kết với 10, và ngược lại. Sau đó, chúng ta có thể sử dụng phương thức
collect
to biến iterator của tupple thành hash map như chỉ ra trong Listing 8-21
fn main() { use std::collections::HashMap; let teams = vec![String::from("Blue"), String::from("Yellow")]; let initial_scores = vec![10, 50]; let mut scores: HashMap<_, _> = teams.into_iter().zip(initial_scores.into_iter()).collect(); }
Listing 8-21: Tạo một hash map từ danh sách team và danh sach các điểm
Ký hiệu HashMap<_, _>
là cần thiết ở đây bởi nó có khả năng để collect
thành nhiều cấu trúc dữ liệu
khác nhau và Rust không biết kiểu mà chúngt a muốn trừ khi chúng ta chi tiết nó. Cho tham số key và giá trị,
tuy hiên, chúng ta có thể sử dụng ký tự "_" và Rust có thể ngầm hiểu kiểu mà Hash map bao gồm dựa trên kiểu cảu dữ
liệu trong Vector. Trong Listing 8-21, Kiểu dữ liệu key là String
và kiểu giá trị là i32
, như trong Listing 8-20
Hash Map và Quyền sở hữu (Hash Maps and Ownership)
Cho những kiểu mà thực hiện Copy trait, giống như i32
, các giá trị được copy vào thành hash map.
Cho giá trị có quyền sở hữu (owned) giống như String
, giá trị sẽ được chuyển và hashmap sẽ là owner của
các giá trị này, như demo trong Listing 8-22
fn main() { use std::collections::HashMap; let field_name = String::from("Favorite color"); let field_value = String::from("Blue"); let mut map = HashMap::new(); map.insert(field_name, field_value); // field_name and field_value are invalid at this point, try using them and // see what compiler error you get! }
Listing 8-22: Key và gía trị là được sở hữu bởi hash map khi chúng được chèn
Chúng ta đã không có thể sử dụng biến field_name
và field_value
sau khi chúng ta đã chuyển vào hash map với lời
gọi hàm insert
.
Nếu chúng ta chèn các tham chiếu tới giá trị trong hash map, các giá trị sẽ không bị chuyển vào hash map. Giá trị mà các tham chiếu trỏ tới phải hợp lệ ít nhất miễn là hash map là hợp lệ. Chúng ta sẽ nói nhiều về vấn đề trong chương "Validate tham chiếu với Lifetimes" mục trong chương 10.
Truy xuất giá trị trong Hash Map
Chúng ta có thể lấy một gía trị từ hash map by cung cấp key tới hàm get
, như chỉ ra trong Listing 8-23
fn main() { use std::collections::HashMap; let mut scores = HashMap::new(); scores.insert(String::from("Blue"), 10); scores.insert(String::from("Yellow"), 50); let team_name = String::from("Blue"); let score = scores.get(&team_name); }
Listing 8-23: Truy xuất tới điểm số của đội Blue trong hash map
Ở đây, score
sẽ có giá trị mà đã liên với Blue team, và kết quả sẽ trả về Some(&10)
. Kết quả là được bọc trong
Some
bởi get
trở lên Options<&V>
; nếu không có giá trị cho key này trong hash map
get
sẽ trở về None
. Chương trình sẽ cần để xử lý Option
một trong các cách chúng ta đã bao qua trong Chương 6.
Chúng ta có thể duyệt qua mỗi cặp key/value trong một hash map tương tự giống như trong Vector sử dụng for
:
fn main() { use std::collections::HashMap; let mut scores = HashMap::new(); scores.insert(String::from("Blue"), 10); scores.insert(String::from("Yellow"), 50); for (key, value) in &scores { println!("{}: {}", key, value); } }
Đoạn code này sẽ in ra mỗi cặp trong thứ tự tuỳ ý:
Yellow: 50
Blue: 10
Cập nhật một HashMap
Mặc dù số key và gía trị là có thể nhiều vô hạn, mỗi key chỉ có một giá trị liên với nó tại một thời điểm. Khi bạn muốn thay đổi dữ liệu trong một hahs map, bạn phải quyết định cách để xử lý khi một key đã có một giá trị liên kết. Bạn có thể thay thế giá trị cũ với giá trị mới bất kể giá trị cũ. Bạn có thể giữ giá trị cũ và tránh giá trị mới, chỉ thêm giá trị mới nếu key là không tồn tại. Hoặc bạn có thể kết hợp giá trị cũ vf giá trị mới.
Ghi đè một gía trị
Nếu chúng ta chèn một key và giá trị vào một hash map và sau đó chèn cũng key đó với giá trị khác, giá trị liên kết
với key này sẽ được thay thế. Mặc dù code trong Listing 8-23 gọi insert
2 lần, hash map sẽ chỉ bao gồm 1 cặp key/value
bởi vì chúng đang chèn giá chỉ cho Blue team 2 lần.
fn main() { use std::collections::HashMap; let mut scores = HashMap::new(); scores.insert(String::from("Blue"), 10); scores.insert(String::from("Blue"), 25); println!("{:?}", scores); }
Listing 8-24: Thay thế một giá trị lưu trữ với key cụ thể
Đoạn code này sẽ in {"Blue": 25}
. Giá trị gốc 10
sẽ bị ghi đề.
Chỉ chèn một giá trị nếu key không tồn tại
Thônng thường để check liệu một key cụ thể có giá trị hay không để chúng ta chèn nó. Hash map có một API cụ thể cho nó
gọi là entry
mà nhận key mà bạn muốn để kiểm tra. Giá trị trả về của phương thức entry
là một enum gọi là Entry
mà thể
hiện giá trị có thể có hoặc không?
Nếu chúng ta muốn kiểm tra key cho đội Yello có giá trị liên kết đến nó không. Nếu không, chúng ta muốn chen giá trị 50.
Sử dụng entry
API. Sử dụng entry
API, code sẽ giống Listing 8-25
fn main() { use std::collections::HashMap; let mut scores = HashMap::new(); scores.insert(String::from("Blue"), 10); scores.entry(String::from("Yellow")).or_insert(50); scores.entry(String::from("Blue")).or_insert(50); println!("{:?}", scores); }
Listing 8-25: Sử dụng phương thức entry
để chỉ chèn nếu key là chưa có giá trị liên kết tới
Phương thức or_insert
trong Entry
là được định nghĩa để trả về một tham chiếu mutable (có thể thay đổi)
tới giá trị tương ứng Entry
key nếu key này tồn tại, hoặc nếu không, chèn tham số như giá trị mới tới key và trở v
về một tham chiếu mutable tới giá trị mới này. Kỹ thuật này là rõ ràng hơn viết logic, thêm vào đó, chúng ta
có borrow checker (một chương trình kiểm tra luật mượn) hỗ trợ.
Chạy code trong Listing 8-25 sẽ in ra {"Yellow": 50, "Blue": 10}
. Lời gọi hàm đầu tiên entry
sẽ
chèn key cho Yellow team với giá trị 50 bởi vì Yellow team khong có giá trị trước đó. Lời gọi thứ 2 entry
sẽ không thay đổi hash map bởi vì Blue team đã có giá trị 10.
Cập nhật giá trị dựa trên giá trị cũ
Một cách khác cho hash map là tìm kiếm giá trị của một key và sau đó cập nhật giá trị này, Ví dụ, Listing 8-26 đếm số lần mỗi từ xuất hiện trong text. Chúng ta sử dụng hash map với các từ như là các key và giá trị liên kết với key đó là số lần từ đó xuất hiện. Nếu là lần đầu tiên chúng ta nhìn thấy từ, chúng ta sẽ chèn nó với giá trị là 1.
fn main() { use std::collections::HashMap; let text = "hello world wonderful world"; let mut map = HashMap::new(); for word in text.split_whitespace() { let count = map.entry(word).or_insert(0); *count += 1; } println!("{:?}", map); }
Listing 8-26: Đếm số lần xảy ra của các từ sử dụng hash map
Đoạn code này sẽ in ra {"world": 2, "hello": 1, "wonderful": 1}
. Phương thức split_whitespace
duyệt qua tất các slice con, chia chúng ra bằng khoảng trắng. Phương thức or_insert
trở về một tham chiếu mutable
(&mut V
) tới giá trị key đó. Ở đây, chúng ta lưu trữ tham chiếu mutable trong biến count
, nên, để có thể gán tới
giá trị này, chúng ta phải dereference (lấy giá trị) count
sử dụng ký hiệu (*
). Tham chiếu mutable vượt sẽ ra ngoài
phạm vị khi kết thúc hàm for
, do đó tất cả sự thay đổi là an toàn và được cho phép bởi luật borrowing
Hàm Băm (Hashing Functions)
Bởi mặc định, HashMap
sử dụng một hàm Hashing (hàm Băm) gọi là SipHash mà có thể cung cấp trở ngại tới những
tấn công như DoS(Denial of Service) liên quan tới bảng băm 1. Điều này không phải là thuật
toán băm nhanh nhất, nhưng đánh đổi hiệu năng cho bảo mật tốt hơn là đáng. Nếu bạn xem xét thời gian xử lý code, và
thấy rằng hàm băm mặc định là qúa chậm cho mục đích của bạn, bạn có thể thay đổi hàm khác bải chi tiết một hasher khác.
Một hasher là một kiểu mà thực hiện một BuildHasher
trait. Chúng ta sẽ nói về trait và cách để thực hiện chúng
trong Chương 10. Bạn không cần thiết phải thực hiện hasher của mình trừ đầu. Nhớ rằng thư viện thực hiện có thể
tìm thấy trong crates
crates.io
Tổng kết
Vector, String, và hash maps sẽ cung cấp một số lượng lớn chức năng cần thiết trong chương trình khi bạn cần để lưu trữ, truy xuất, và chỉnh sửa dữ liệu. Có một số ví dụ bài tập bạn nên trang bị để giải quyết:
-
Danh sách số nguyên, sử dụng một vector và trở về thành phần ở chính giữa the (media) và mode(giá trị mà thường xuất hiện nhiều nhất - hash map có thể giải quyết
-
Biến đổi strings tới latin pig. Phụ âm đầu của mỗi từ là chuyển tới cuối và thêm "ay", do đó, "first" trở thành "irst-fay". Những từ bắt đầu với một nguyên âm sẽ thêm "hay" tới cuối (Ví dụ: "apple" sẽ thành "apple-hay"). Nhớ rằng UTF-8
-
Sử dụng một hash map và vector, tạo một giao diện cho phép người dùng có thể thêm tên nhân viên tới một phòng ban trong công ty. Ví dụ "Add Sally tới Engineering" hoặc "Thêm Amir tới Sales". Sau đó để người dùng lays một danh sách tất cả người trong một phòng bạn hoặc tất cả người trong công ty bởi phòng ban sắp xếp theo thứ alphabet
Tài liệu API của thư viện chuẩn mô tả các phương thức mà vectors, string và hash maps có và sẽ hữu ích cho bài tập này.
Chúng ta đang đi sâu vào chương trình phức tạp, nơi các điều khiển có thể lỗi, do đó, giờ là lúc thao thuận nhiều về xử lý lỗi. Chúng ta sẽ làm điều này trong chương tiếp theo
Xử lý lỗi (Error Handling)
Lỗi là cái gì đó thực tế của cuộc sống trong phần mềm, do đó Rust có một số tính năng cho xử lý các tình huống này nơi mà một thứ gì đó là lỗi. Trong nhiều trường hợp, Rust yêu cầu bạn kiến thức về lỗi ấy và hành động trước khi code được biên dịch. Yêu cầu này làm cho chương trình của bạn nhiều thống nhất bởi đảm bảo rằng bạn sẽ khám phá lỗi và xử lý chúng một cách chính các trước khi bạn có triển khai code tới môi trường production!
Rust nhóm các lỗi thành 2 loại chính: recoverable (có thể phục hồi) và unrecoverable (không thể phục hồi) Cho một lỗi có thể phục hồi, giống như a file not found (không tìm thấy file), chúng hầu như chỉ muốn thông báo vấn đề với người dùng và thử lại điều khiển. Các lỗi không thể phục hồi là luôn luôn dấu hiêu cảu bugs, giống như cố gắng truy xuất một vị trí vượt quá một mảng, và do đó bạn muốn dừng chương trình ngay lập tức.
Hầu hết các ngôn ngữ không phân biết giữa 2 kiểu lỗi và xử lý chúng trong cùng một cách, sử dụng nguyên lý ngoại lệ (exceptions). Rust không có exceptions. Thay vào đó, nó có kiểu Result<T, E>
cho lỗi có thể phục hồi và macro panic!
cho lỗi dừng xử lý khi chương tình trạm chán lỗi không thể phục hồi. Chương này sẽ bao quát panic!
trước và sau đó sẽ
nói về giá trị trở `Result<T, E>. Thêm vào đó, chúng ta sẽ khám phá cân nhắc khi quyết định liệu cố để phục hồi lại từ
một lỗi hay là dừng xử lý lại.
Lỗi không thể phục hồi với panic!
Thỉnh thoảng, một lỗi xảy ra trong code của bạn và không thể làm gì với nó. Trong những case này, Rust
có panic!
macro để xử lý. Khi macro panic!
xử lý, chương trình sẽ in ra thông điệp lỗi, unwind và dọn dẹp
lại stack, và sau đó thoạt. Chúng ta sẽ gọi một panic khi một bug của kiểu này được tìm thấy và chúng ta không
rõ ràng cách để xử lý vấn đề lúc đó.
Phục hồi (Unwinding) stack hoặc huỷ bỏ phản hồi dùng Panic
Bởi mặc định, khi một panic xảy ra, chương trình sẽ bắt đầu unwinding, nghĩa là Rust sẽ phục hồi stack và dọn dẹp dữ liệu từ mỗi hàm nó chạm trán. Tuy nhiên, phục hồi và dọn dẹp này là nhiều thứ. Rust, do đó, cho phép bạn để chọn sử thay đổi của huỷ ngay lập tức (aborting), và kết thúc chương trình ngoài sự dọn dẹp. Bộ nhớ mà chương trình là đang Memory that the program was using sử dụng và cần được don dẹp bởi hệ điều hành. Nếu trong dự án bạn cần để tạo binary kết quả nhỏ nhất có thể, bạn có thể chuyển từ unwinding to huỷ bo (aborting) trong panic bởi thêm
panic = 'abort'
tới mục t[profile]
trong file Cargo.toml. Ví dụ, nếu như bạn muốn huỷ (abort) trong panic trong chết độ release, thêm điều này:[profile.release] panic = 'abort'
Cố gắng gọi panic!
trong một chương trình đơn giản sau:
Filename: src/main.rs
fn main() { panic!("crash and burn"); }
Khi bạn chạy chương trình, bạn sẽ nhìn thấy như sau:
$ cargo run
Compiling panic v0.1.0 (file:///projects/panic)
Finished dev [unoptimized + debuginfo] target(s) in 0.25s
Running `target/debug/panic`
thread 'main' panicked at 'crash and burn', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Lời gọi tới panic!
có một thông điệp lỗi ở 2 dòng cuối. Dòng đầu tiên chỉ ra
thông điệp lỗi panic của chúng ta và thay thế code chúng ta nới panic xảy ra
src/main.rs:2:5 và dòng 2, ký tự thứ 5 của file src/main.rs
Trong trường hợp này,những đoạn thống báo trên đã tiết lộ vấn đề của chúng ta và nếu chúng ta viết như vậy, macro panic!
sẽ được gọi, Trong một số trường hợp khác, panic!
có thể trong code mà chúng ta gọi, tên file và tên dòng được thông báo trong thông điệp lỗi là code của một ai đó (ví dụ sử dụng thư viện - mà trong code đó có panic!
được gọi) - không phải là dòng của code chúng ta gây nên panic, nhưng code trong thư viện gây panic. Chúng ta có thể sử dụng backtrace (thông tin các hàm được gọi cho đến vị trí code này) để biết phần nào của code
chúng ta đang gây nên lỗi. Chúng ta sẽ thảo luận nhiều về backtrace trong phần tiếp theo
Sử dụng backtrace của một panic!
Cùng xem xét một ví dụ khác để nhìn thấy khi một panic!
được gọi từ một thư viện bởi một bug
trong code của chúng ta thay vì từ việc chúng ta trực tiếp gọi macro panic!
. Listing 9-1 có một số đoạn code mà cố gắng để truy xuất tại một chỉ số trong một vector mà vượt quá dãy các
chỉ số hợp lệ.
Filename: src/main.rs
fn main() { let v = vec![1, 2, 3]; v[99]; }
Listing 9-1: Attempting to access an element beyond the
end of a vector, which will cause a call to panic!
Ở đây, chúng ta cố gắng truy xuất tới phần tử thứ 100 của vector(chỉ số là 99 vì chỉ số bắt đầu bởi 0), nhưng một vector của chúng ta chỉ có 3 phần tử. Trong trường hợp này, Rust sẽ panic. Sử dụng []
sẽ trở về một phần tử, nhưng nếu bạn truyền vào một chỉ số không hợp lệ,
không có phần tử nào, Rust có thể không trả về.
Trong C, cố gắng để đọc vượt quá cấu trúc dữ liệu là hành vi không xác định (undefined
). Bạn có thể nhận bất kỳ tại vị trí trong bộ nhớ tương ứng phần tử trong cấu trúc dữ liệu, dù bộ nhớ không thuộc structure. Điều này gọi là buffer overread và có thể dẫn tới lỗ hổng bao mật
nếu một người tấn công là có thể thao túng chỉ số trong cách để đọc dữ liêu mà họ không được cho phép.
Để bảo vệ chương trình của bạn từ lỗ hỗng này, nếu bạn cố đọc một phần tử tại một chỉ số mà không tồn tại, Rust sẽ dừng execution (xử lý) và từ chối để tiếp tục. Cùng thử và nhìn đoạn code sau:
$ cargo run
Compiling panic v0.1.0 (file:///projects/panic)
Finished dev [unoptimized + debuginfo] target(s) in 0.27s
Running `target/debug/panic`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Lỗi này chỉ ra tại dòng 4 của main.rs
nới chúng ta cố gắng để truy xuất chỉ số 99. Dòng tiếp theo nói với chúng ta rằng chúng ta có thể thiết lập biến môi trường RUST_BACKTRACE đẻ nhận một thông tin backtrace của gì đang xảy ra và gây nên lỗi. Một backtrace là môt danh sách của tất cả các mà được gọi cho đến điểm này. Backtrace trong Rust làm việc giống như chúng làm trong các ngôn ngữ khác: Chìa khóa để đọc một backtrace là bắt tại trên cùng và đọc đến khi bạn nhìn thấy files bạn viết. Đó là điểm nơi vấn đề khởi nguồn. Những dòng code nằm trên tại điểm mà code của bạn được gọi; hoặc những dòng code ở dưới điểm mà bạn được gọi đều tiết lộ nhiều thông tin. Những dòng trước và sau này có thể bao gồm code Rust core, code của thư viện chuẩn, hoặc crates mà bạn đang sử dụng. Cùng cố để lấy thông tin backtrace bởi thiết lập biên môi trường tới bất kỳ giá trị nào trừ 0. Listing 9-21 chỉ ra đầu ra tương tự những gì chúng ta nhìn thấy.
$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
stack backtrace:
0: rust_begin_unwind
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:483
1: core::panicking::panic_fmt
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/panicking.rs:85
2: core::panicking::panic_bounds_check
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/panicking.rs:62
3: <usize as core::slice::index::SliceIndex<[T]>>::index
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/slice/index.rs:255
4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/slice/index.rs:15
5: <alloc::vec::Vec<T> as core::ops::index::Index<I>>::index
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/alloc/src/vec.rs:1982
6: panic::main
at ./src/main.rs:4
7: core::ops::function::FnOnce::call_once
at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/ops/function.rs:227
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
Listing 9-2: The backtrace generated by a call to
panic!
displayed when the environment variable RUST_BACKTRACE
is set
Nhiều dòng được in ra hơn. Thông điệp chính xác bạn nhìn thấy có thể khác phụ thuộc vào hệ điều hành của bạn và phiên bản Rust bạn đang dùng. Để lấy thông tin backtrace, chế độ debug phải được cho phép. Chế độ debug được cho phép bởi mặc định khi bạn sử dụng cargo build
hoặc cargo run
ngoài trừ cờ --release
Trong thông điệp ở Listing 9-2, dòng 6 của backtrace chỉ tới dòng của project của chúng ta mà đang gây nên lỗi: Dòng 4 của src/main.rs. Nếu chúng ta không muốn chương trình panic, chúng ta nên bắt đầu tìm hiểu tại dòng được chỉ ra bởi dòng đầu tiên đề cập một file chúng ta đã viết. Trong Listing 9-1, nơi chúng viết code mà có panic, cách để sửa một panic là không truy xuất thành phần mà vượt quá dãy của chỉ số vector. Khi code của bạn panic trong tương lại, bạn sẽ cần để tìm hiểu code bạn là đang làm gì với giá trị gây nên panic và code nên làm thế nào để không bị.
Chúng ta sẽ quay trở lại panic!
và khi bàn về việc nên hay không không sử dụng panic!
để xử lý một số điều kiện lỗi trong phần "To panic!
or Not to
panic!
" phần sau của chương này.
Tiếp theo, chúng ta sẽ nhìn lại cách để khôi phục từ một lỗi sử dụng Result
Lỗi có thể khôi phục với Result
Hầu hết các lỗi không nghiêm trọng lắm thường không yêu cầu chương trình chúng ta dừng lại.
Thỉnh thoảng, khi một hàm nào đó gặp lỗi vì một vài lý do nào đó mà bạn có thể dễ dàng giải thích và xử lý nó. Ví dụ, nếu bạn cố gắng mở một file và điều khiển đó bị lỗi bởi vì file không tồn tại, bạn có thể muốn tạo file thay vì kết thúc.
Nhắc lại từ “Handling Potential Failure with the Result
Type” trong chương 2 mà Result
enum là được định nghĩa như có 2 biến thể : Ok
hoặc Err
như sau:
#![allow(unused)] fn main() { enum Result<T, E> { Ok(T), Err(E), } }
T
và E
là các tham số với kiểu dữ liệu tổng quát (generic), chúng ta sẽ thảo luận về generic
chi tiết hơn trong chương 10. Gì chúng ta biết về nó đến này là T
thể hiện kiểu của dữ liệu sẽ đuợc trả về trong trường hợp thành công trong Ok
, và E
thể hiện kiểu của lỗi mà được trở về trong trường hợp lỗi với biến thể Err
. Bởi vì Result
có các tham số kiểu generic này, chúng ta có thể sử dụng kiểu Result
và các hàm của nó định nghĩa trong nhiều trường hợp khác nhau nơi giá trị thành công hoặc giá trị lỗi có thể nhận các kiểu khác nhau.
Cùng xem xét việc gọi một hàm mà trở về một kiểu Result
bởi vì hàm có thể lỗi. Trong Listing 9-3 chúng ta cố gắng mở một file
Filename: src/main.rs
use std::fs::File; fn main() { let f = File::open("hello.txt"); }
Listing 9-3:Mở một file
Cách mà chúng ta biết File::open
trở về một kiểu Result
?. Chúng có thể xem standard
library API documentation, hoặc chúng có thể yêu cầu trình biên dịch (compiler). Nếu chúng đưa f
một ký annotation
mà chúng ta biết là không phải là giá trị trở kiểu hàm và sau đó cố gắng để biên dịch, trình biên dịch sẽ nói với chúng ta thằng kiểu này sẽ không phù hợp (match). Thông điệpj lỗi sẽ nói với chunts ta kiểu giữ liệu nào f
là phù hợp. Cùng thử ví dụ sau: Kiểu File::open
không phải là u32
, nếu thay đổi let
f` tới
use std::fs::File;
fn main() {
let f: u32 = File::open("hello.txt");
}
Cố gắng để biên dịch đưa chúng ta đầu ra như sau:
$ cargo run
Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0308]: mismatched types
--> src/main.rs:4:18
|
4 | let f: u32 = File::open("hello.txt");
| --- ^^^^^^^^^^^^^^^^^^^^^^^ expected `u32`, found enum `Result`
| |
| expected due to this
|
= note: expected type `u32`
found enum `Result<File, std::io::Error>`
For more information about this error, try `rustc --explain E0308`.
error: could not compile `error-handling` due to previous error
Điều này nói với chúng ta kiểu trả về của hàm File::open
là Result<T,E>
Tham số generic T
đã được chỉ ra ở đây với kiểu giá trị thành công là std::fs::File
, mà là một handle của 1 file (Dạng tham chiếu 1 file).
Kiểu E
được sử dụng trong giá trị lỗi là std::io::Error
.
Kiểu giá trị trả về nghĩa là gọi File::open
có thể thành công và trở về handle của file mà bạn có thể đọc hoặc ghi tới. Lời gọi hàm cũng có thể lỗi: Ví dụ, file có thể không tồn tại, hoặc chúng ta có thể không có quyền để truy xuất file. Hàm File::opne
cần để có cách để nói với chúng ta liệu nó là thành công hoặc thất bại cùng lúc đưa chúng ta hoặc handle của file hoặc thông tin lỗi. Thông tin này chính là những gì Result
enum truyền tải.
Trong trường hợp File::open
thành công, giá trị trong biến f
sẽ là thực thể của Ok
mà bao gồm một file handle. Trong trường hợp lỗi, giá trị f
là một thực thể Err
mà bao gồm nhiều thông tin về kiểu lỗi đã xảy ra.
Chúng ta có thể thêm code trong Listing 9-3 để xử lý kiểu File::open
trả về. Trong Listing 9-4 chỉ ra một cách để xử lý Result
cơ bản, cú pháp match
chúng ta đã thảo luận trong Chương 6.
Filename: src/main.rs
use std::fs::File; fn main() { let f = File::open("hello.txt"); let f = match f { Ok(file) => file, Err(error) => panic!("Problem opening the file: {:?}", error), }; }
Listing 9-4: Sử dụng match
để xử lý Result
Chú ý rằng, giống Option
enum, kiểu Result
enum và biến thể của nó có thể khai báo khi import, do đó chúng ta không cần chi tiết Result::
trước Ok
và Err
trong cú pháp match
.
Khi kết quả là Ok
, code sẽ trở giá trị file
và sau đó chúng gán file handle tới biến f
. Sau hàm match
, chúng ta có thể sử dụng file handle cho việc đọc hoặc ghi.
Một nhánh khác của match
xử lý trường hợp chúng ta nhận một giá trị Err
từ
File::open
. Trong trường hợp này, chúng ta gọi macro panic!
. Nếu không có file nào tên hello.txt trong đường dẫn hiện tại. Nếu chúng ta chạy code sau , chúng ta sẽ nhìn thấy đầu ra như sau nơi mà macro panic!
được gọi
$ cargo run
Compiling error-handling v0.1.0 (file:///projects/error-handling)
Finished dev [unoptimized + debuginfo] target(s) in 0.73s
Running `target/debug/error-handling`
thread 'main' panicked at 'Problem opening the file: Os { code: 2, kind: NotFound, message: "No such file or directory" }', src/main.rs:8:23
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Thông thường, đàu ra nói với chúng ta chính xác lỗi gì.
Xử lý các lỗi khác nhau
Đoạn code trong Listing 9-4 sẽ panic!
không quan trọng là File::open
lỗi gì. Tuy nhiên, nếu chúng ta muốn xử lý khác nhau cho mỗi kiểu lý do lỗi. Nếu File::opem
lỗi bởi vì file không tồn tại, chúng ta muốn tạo file và trở về một handle của một file mới. Nếu File::open
lỗi cho bất kỳ lý do nào khác, ví như chúng ta không có quyền để mở một file chúng ta vẫn muốn code panic
như chúng ta đã làm trong Listing 9-4. Ví dụ 9-5 sau thêm nhánh của match
:
Filename: src/main.rs
use std::fs::File;
use std::io::ErrorKind;
fn main() {
let f = File::open("hello.txt");
let f = match f {
Ok(file) => file,
Err(error) => match error.kind() {
ErrorKind::NotFound => match File::create("hello.txt") {
Ok(fc) => fc,
Err(e) => panic!("Problem creating the file: {:?}", e),
},
other_error => {
panic!("Problem opening the file: {:?}", other_error)
}
},
};
}
Listing 9-5: Handling different kinds of errors in different ways
Kiểu của giá trị trả về File::open
trong Err
là io::Error
, nới là một cấu được cung cấp bởi thư viện chuẩn. Cấu trúc này có một phương thức kind
mà chúng ta có thể gọi để nhận giá trị io::ErrorKind
.
Enum io::ErrorKind
được cung cấp bởi thư viện chuẩn và có biến thể thể hiện kiểu khác nhau của lỗi mà có thể trả về từ điều khiển io
. BIến thể chúng ta muốn sử dụng ở đây là ErrorKind::NotFound
, mà chỉ file chúng ta đang cố gắng để mở nhưng không tồn tại. Do đó Chúng ta, xử lý f
, nhúng chúng cũng có kiểu trong error.kind()
Điều kiện chúng ta muốn kiểm tra trong cú pháp match
là liệu giá trị trở bởi error.kind()
là NotFound
- một biến thể của ErrorKind
enum. Nếu đúng như vậy, chúng ta cố để tạo một file với File::create
. Tuy nhiên, bởi vì File::create
cũng có thể lỗi, chúng cần nhánh kiểm tra thứ 2 của match
. Khi file không được tạo, một thông điệp lỗi khác sẽ được in ra. Nhánh thứ 2 của match
sẽ được gọi nếu bất kỳ lỗi bên lỗi mising file
(không tìm thấy file).
Thay đổi sử dụng cú pháp
match
vớiResult<T, E>
Biểu thức
match
khá không những hữu dụng mà còn khá làprimitive
(dạng nguyên bản). Trong chương 13, bạn sẽ học vềclosures
, nơi được sử dụng với nhiều phương thức được định nghĩa trongResult<T,E>
. Những phướng thức này có thể ngắn gọn hơn sử dụngmatch
khi xử lý giá trịResult<T, E>
trong code của bạn 9-5 but using closures and theunwrap_or_else
method: Eg, đây là một cách khác để viết cùng một logic như vị dụ trong Listing 9-5 nhưng sử dụng closure và phương thứcunwrap_or_else
:use std::fs::File; use std::io::ErrorKind; fn main() { let f = File::open("hello.txt").unwrap_or_else(|error| { if error.kind() == ErrorKind::NotFound { File::create("hello.txt").unwrap_or_else(|error| { panic!("Problem creating the file: {:?}", error); }) } else { panic!("Problem opening the file: {:?}", error); } }); }
Mặc dù đoạn code này có cùng hành vi như Listing 9-5, nó không bao gồm biểu thức
match
và dễ dàng để đọc hơn. Quay lại ví dụ này sau khi bạn đã học Chương 13, và tìm kiếm phương thứcunwrap_or_else
trong tài liệu thư viện chuẩn. Nhiều phương thức khác có thể được sử dụng vớimatch
bên trong khi bạn xử lý với lỗi.
Xử lý panic của lỗi với: unwrap
and expect
Sử dụng match
cho các trường hợp này khá tốt, nhưng nó có thể dài dòng và không phải lúc nào hiểu ý định nó truyền tải. Kiểu Result<T,E>
có nhiều phương thức trợ giúp được định nghĩa để làm cho nhiều dạng mục đích khác nhau. Phương thức unwrap
là một phương thức thực hiện cú pháp dạng match
chúng ta đã viết trong Listing 9-4. Nếu giá trị Result
là Ok
, unwrap
sẽ trở về gía trị
nằm trong Ok
. Nếu Result
là kiểu Err
, unwrap
sẽ gọi macro panic!
cho chúng ta. Đây là một ví dụ sử dụng unwrap
Filename: src/main.rs
use std::fs::File; fn main() { let f = File::open("hello.txt").unwrap(); }
Nếu chúng ta chạy đoạn code này ngoài một file hello.txt, chúng ta sẽ nhìn thấy một thông điệp lỗi từ panic!
được gọi do phương thức unwrap
thực hiện.
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error {
repr: Os { code: 2, message: "No such file or directory" } }',
src/libcore/result.rs:906:4
Một cách tương tự, phương thức expect
để chúng ta lựa chọn thông điệp cho panic!
.
Sử dụng expect
thay unwrap
và cung cấp một thông điệp lỗi rõ ràng có thể truyền tải ý định
và làm cho dễ dò lỗi đến từ đâu. Cú pháp cho expect
như sau:
Filename: src/main.rs
use std::fs::File; fn main() { let f = File::open("hello.txt").expect("Failed to open hello.txt"); }
Chúng ta sử dụng expect
trong cùng một cách với unwrap
: trở về một file handle hoặc gọi
macro panic!
. Thông điệp lỗi được sử dụng bởi expect
trong lời gọi hàm tới panic!
sẽ là tham
số truyền vào expect
, thay thế thông điệp panic!
mặc định mà unwrap
sử dụng.
thread 'main' panicked at 'Failed to open hello.txt: Error { repr: Os { code:
2, message: "No such file or directory" } }', src/libcore/result.rs:906:4
Bởi vì thông điệp lỗi này bắt đầu đoạn text mà chúng ta truyền vào Failed to open hello.txt
, nó sẽ dễ dàng để tìm kiếm nơi thông điệp lỗi in ra. Nếu chúng ta sử dụng unwrap
trong nhiều nơi, sẽ tốn nhiều thời gian để xác định chính xác unwrap
nào gây ra lỗi panic bởi
tất cả lời gọi unwrap
in ra cùng một thông điệp giống nhau.
Lan Truyền Lỗi - Propagating Errors
Khi thực hiện của một hàm gọi một điều gì đó mà có lỗi, thay vì xử lý lỗi trong hàm này, bạn có thể trả về lỗi tới hàm gọi để hàm này có thể quyết định nên làm gì. Đó được gọi là propagating (lan truyền) lỗi và đưa nhiều điều khiển tới lời gọi hàm nơi có thể có nhiều thông tin hoặc logic để ra lệnh lỗi nên được xử lý hơn là gì trong ngữ cảnh code hiện tại.
Ví du, Listing 9-6 chỉ ra một hàm mà đọc một username từ một file. Nếu như file không tồn tài hoặc không thể đọc, hàm này sẽ trở về những lỗi này tới code mà gọi hàm.
Filename: src/main.rs
#![allow(unused)] fn main() { use std::fs::File; use std::io::{self, Read}; fn read_username_from_file() -> Result<String, io::Error> { let f = File::open("hello.txt"); let mut f = match f { Ok(file) => file, Err(e) => return Err(e), }; let mut s = String::new(); match f.read_to_string(&mut s) { Ok(_) => Ok(s), Err(e) => Err(e), } } }
Listing 9-6: Một hàm mà trả về lỗi tới nơi gọi nó sử dụng match
Hàm này có thể được viết trong nhiều cách ngắn gọn hơn, nhưng chúng ta hãy cứ bắt đầu làm vậy để có thể khám phá cách xử lý lỗi; cuối cùng, chúng ta sẽ chỉ cách làm nó ngắn gọn. Hãy nhìn và kiểu trả về của hàm: Result<String, io::Error>
. Điều này nghĩa rằng hàm là đang trả về giá trị của kiểu Result<T, E>
, nơi mà T
là String
và kiểu tổng quát E
là io::Error
.
Nếu hàm này thành công ngoại trừ bất kỳ lỗi nào, đoạn code mà gọi hàm này sẽ nhận giá trị Ok
mà giữ giá trị String
- một username mà hàm này đọc được. Nếu hàm này chạm trán lỗi bất kỳ, lời gọi hàm sẽ nhậ giá trị Err
mà giữ một instance của io::Error
mà bao gồm nhiều thông tin về lỗi gì. Chúng ta chọn io::Error
như kiểu trả về của hàm này bởi vì kiểu xảy ra với điều khiển File::open
với điều khiển gọi hàm này read_to_string
cùng trả về kiểu này trong khi lỗi.
Thân hàm bắt đầu bởi gọi File::open
. Sau đó, chúng ta xử lý Result
với cú pháp match
tương tự với ví dụ Listing 9-4.
Nếu File::open
thành công, file handle lưu giữ trong biến f
và hàm tiếp tục chạy. Trong trường hợp Err
lỗi, thay vì gọi panic!
, chúng ta sử dụng từ khóa return
để thoát khỏi hàm sớm và trả lỗi từ File::open
ra ngoài,, nơi mà đoạn code gọi hàm của chúng ta.
Do đó, nếu chúng ta có file handle trong f
, hàm sau đó sẽ tạo một String
mới trong biến s
và gọi tới phương thức read_to_string
từ f để đọc nội dùng của file vào s
. Phương thức
read_to_string
cũng trả về Result
bởi vì nó có thể lỗi, mặc dù File::open
thành công.
Do đó chúng ta cần match
khác để xử lý Result
: Nếu read_to_string
thành công, hàm của chúng đã thành công, và chúng ta trả về username từ một file được bọc trong Ok
enum. Nếu read_to_string
lỗi, chúng ta trả về giá trị lỗi trong cách giống chúng ta trả về giá trị lỗi khi xử lý File::open
. Tuy nhiên, chúng ta không cần viết chính xác return
, bởi đó là biểu thức cuối cùng của hàm rồi.
Đoạn code mà gọi hàm này sẽ xử lý hoặc Ok
mà bao gồm username, hoặc là Err
mà bao gồm
io::Error
. Nó phụ thuộc đoạn code gọi hàm quyết định sẽ làm gì với các giá trị này. Nếu đoạn code nhận một giá trị Err
, nó có thể gọi panic!
và crash chương trình, sử dụng username mặc định, hoặc tìm kiềm username trong một file khác chẳng hạn. Chúng ta không đủ thông tin về đoạn code gọi là thực sự đang cố gắng làm, do đó chúng lan truyền tất cả thông tin thành hoặc lỗi tới chúng để xử lý một cách chính xác.
Mẫu cho lan truyền lỗi là khá thông dụng trong Rust và Rust cũng cung cấp một toán tử ?
để làm điều này dễ dàng hơn
Cú pháp làn truyền lỗi : Toán tử ?
Listing 9-7 là thực hiện của hàm read_username_from_file
mà có cùng chức năng với Listing 9-6, nhưng nó sử dụng toán tử ?
Filename: src/main.rs
#![allow(unused)] fn main() { use std::fs::File; use std::io; use std::io::Read; fn read_username_from_file() -> Result<String, io::Error> { let mut f = File::open("hello.txt")?; let mut s = String::new(); f.read_to_string(&mut s)?; Ok(s) } }
Listing 9-7: Một hàm trả về lỗi tới lời gọi hàm sử dụng toán tử ?
?
được đặc sau giá trị Result
được định nghĩa để làm hầu như giống cách trong match
mà chúng ta đã xử lý giá trị Result
trong Listing 9-6. Nếu giá trị Result
là Ok
, giá trị trong Ok
sẽ trả về từ biểu thức này và chương trình sẽ tiếp tục. Nếu giá trị trả về là Err
,
Err
sẽ trả về khỏi hàm giống như đã sử dụng từ khóa return
,
Có một sử khác nhau giữa match
từ ví dụ Listing 9-6 làm và toán tử ?
thực hiện: giá trị lỗi mà ?
đã gọi chạy qua hàm from
, được định nghĩa trong trait From
trong thư viện chuẩn, mà sử dụng để biến đổi lỗi từ kiểu này sang kiểu khác. Khi toán tử ? gọi hàm
from, kiểu lỗi nhận được là biến thành lỗi định trong kiểu dữ liệu trả về hàm của chúng ta. Điều này là hữu ích khi một hàm trở về một lỗi mà thể hiện tất cả cách có thể lỗi, ngay cả một phần của nó lỗi cho nhiều lý do nào đó. Miễn là có thực hiện
impl From for ReturnError
để định nghĩa sự biến đổi trong hàm from
, toán tử ?
lo việc gọi hàm from
một cách tự động cho bạn.
Trong ngữ cảnh Listing 9-7, ?
gọi tại cuối File::open
sẽ trở về giá trị trong Ok
tới biến f
. Nếu một lỗi xảy ra, toán tử ?
sẽ trả trả về sớm và đưa Err
tới lời gọi hàm. Hành vi giống nhau áp dụng tới ?
tại nơi gọi hàm read_to_string
.
Toán tử ?
vứt bỏ nhiều thủ tục (boilerplate) và làm cho thực hiện hàm trở nên đơn giản. Chúng thậm chí có thể gọi liên tiếp ?
cho đoạn code ngắn gọn hơn như chỉ ra trong Listing 9-8.
Filename: src/main.rs
#![allow(unused)] fn main() { use std::fs::File; use std::io; use std::io::Read; fn read_username_from_file() -> Result<String, io::Error> { let mut s = String::new(); File::open("hello.txt")?.read_to_string(&mut s)?; Ok(s) } }
Listing 9-8: Chaining method calls after the ?
operator
Chúng ta tạo một String
mới tới s
như bắt đầu hàm. Thay vì tạo biến f
, chúng ta chain (nối) lời gọi tới read_to_string
trực tiếp kết quả của File::open("hello.txt")?
. Chúng ta vẫn có ? tại cuối của
read_to_string, và chúng ta vẫn trả về giá trị
Ok`` bao gồm username trong s
khi cả File::open
và read_to_string
thành công. Hàm này làm cùng cách với Listing 9-=6 và Listing 9-7; nhưng viết theo một cách khá hữu hiệu.
Listing 9-9 chỉ ra một cách để làm ngắn gọn hàm fs::read_to_string
.
Filename: src/main.rs
#![allow(unused)] fn main() { use std::fs; use std::io; fn read_username_from_file() -> Result<String, io::Error> { fs::read_to_string("hello.txt") } }
Listing 9-9: Using fs::read_to_string
instead of
opening and then reading the file
Reading a file into a string is a fairly common operation, so the standard
library provides the convenient fs::read_to_string
function that opens the
file, creates a new String
, reads the contents of the file, puts the contents
into that String
, and returns it. Of course, using fs::read_to_string
doesn’t give us the opportunity to explain all the error handling, so we did it
the longer way first.
Where The ?
Operator Can Be Used
The ?
operator can only be used in functions whose return type is compatible
with the value the ?
is used on. This is because the ?
operator is defined
to perform an early return of a value out of the function, in the same manner
as the match
expression we defined in Listing 9-6. In Listing 9-6, the
match
was using a Result
value, and the early return arm returned an
Err(e)
value. The return type of the function has to be a Result
so that
it’s compatible with this return
.
In Listing 9-10, let’s look at the error we’ll get if we use the ?
operator
in a main
function with a return type incompatible with the type of the value
we use ?
on:
use std::fs::File;
fn main() {
let f = File::open("hello.txt")?;
}
Listing 9-10: Attempting to use the ?
in the main
function that returns ()
won’t compile
This code opens a file, which might fail. The ?
operator follows the Result
value returned by File::open
, but this main
function has the return type of
()
, not Result
. When we compile this code, we get the following error
message:
$ cargo run
Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> src/main.rs:4:36
|
3 | / fn main() {
4 | | let f = File::open("hello.txt")?;
| | ^ cannot use the `?` operator in a function that returns `()`
5 | | }
| |_- this function should return `Result` or `Option` to accept `?`
|
= help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `error-handling` due to previous error
This error points out that we’re only allowed to use the ?
operator in a
function that returns Result
, Option
, or another type that implements
FromResidual
. To fix the error, you have two choices. One choice is to change
the return type of your function to be compatible with the value you’re using
the ?
operator on as long as you have no restrictions preventing that. The
other technique is to use a match
or one of the Result<T, E>
methods to
handle the Result<T, E>
in whatever way is appropriate.
The error message also mentioned that ?
can be used with Option<T>
values
as well. As with using ?
on Result
, you can only use ?
on Option
in a
function that returns an Option
. The behavior of the ?
operator when called
on an Option<T>
is similar to its behavior when called on a Result<T, E>
:
if the value is None
, the None
will be returned early from the function at
that point. If the value is Some
, the value inside the Some
is the
resulting value of the expression and the function continues. Listing 9-11 has
an example of a function that finds the last character of the first line in the
given text:
fn last_char_of_first_line(text: &str) -> Option<char> { text.lines().next()?.chars().last() } fn main() { assert_eq!( last_char_of_first_line("Hello, world\nHow are you today?"), Some('d') ); assert_eq!(last_char_of_first_line(""), None); assert_eq!(last_char_of_first_line("\nhi"), None); }
Listing 9-11: Using the ?
operator on an Option<T>
value
This function returns Option<char>
because it’s possible that there is a
character there, but it’s also possible that there isn’t. This code takes the
text
string slice argument and calls the lines
method on it, which returns
an iterator over the lines in the string. Because this function wants to
examine the first line, it calls next
on the iterator to get the first value
from the iterator. If text
is the empty string, this call to next
will
return None
, in which case we use ?
to stop and return None
from
last_char_of_first_line
. If text
is not the empty string, next
will
return a Some
value containing a string slice of the first line in text
.
The ?
extracts the string slice, and we can call chars
on that string slice
to get an iterator of its characters. We’re interested in the last character in
this first line, so we call last
to return the last item in the iterator.
This is an Option
because it’s possible that the first line is the empty
string, for example if text
starts with a blank line but has characters on
other lines, as in "\nhi"
. However, if there is a last character on the first
line, it will be returned in the Some
variant. The ?
operator in the middle
gives us a concise way to express this logic, allowing us to implement the
function in one line. If we couldn’t use the ?
operator on Option
, we’d
have to implement this logic using more method calls or a match
expression.
Note that you can use the ?
operator on a Result
in a function that returns
Result
, and you can use the ?
operator on an Option
in a function that
returns Option
, but you can’t mix and match. The ?
operator won’t
automatically convert a Result
to an Option
or vice versa; in those cases,
you can use methods like the ok
method on Result
or the ok_or
method on
Option
to do the conversion explicitly.
So far, all the main
functions we’ve used return ()
. The main
function is
special because it’s the entry and exit point of executable programs, and there
are restrictions on what its return type can be for the programs to behave as
expected.
Luckily, main
can also return a Result<(), E>
. Listing 9-12 has the
code from Listing 9-10 but we’ve changed the return type of main
to be
Result<(), Box<dyn Error>>
and added a return value Ok(())
to the end. This
code will now compile:
use std::error::Error;
use std::fs::File;
fn main() -> Result<(), Box<dyn Error>> {
let f = File::open("hello.txt")?;
Ok(())
}
Listing 9-12: Changing main
to return Result<(), E>
allows the use of the ?
operator on Result
values
The Box<dyn Error>
type is a trait object, which we’ll talk about in the
“Using Trait Objects that Allow for Values of Different
Types” section in Chapter 17. For now, you can
read Box<dyn Error>
to mean “any kind of error.” Using ?
on a Result
value in a main
function with the error type Box<dyn Error>
is allowed,
because it allows any Err
value to be returned early.
When a main
function returns a Result<(), E>
, the executable will
exit with a value of 0
if main
returns Ok(())
and will exit with a
nonzero value if main
returns an Err
value. Executables written in C return
integers when they exit: programs that exit successfully return the integer
0
, and programs that error return some integer other than 0
. Rust also
returns integers from executables to be compatible with this convention.
The main
function may return any types that implement the
std::process::Termination
trait. As of this
writing, the Termination
trait is an unstable feature only available in
Nightly Rust, so you can’t yet implement it for your own types in Stable Rust,
but you might be able to someday!
Now that we’ve discussed the details of calling panic!
or returning Result
,
let’s return to the topic of how to decide which is appropriate to use in which
cases.
To panic!
or Not to panic!
So how do you decide when you should call panic!
and when you should return
Result
? When code panics, there’s no way to recover. You could call panic!
for any error situation, whether there’s a possible way to recover or not, but
then you’re making the decision that a situation is unrecoverable on behalf of
the calling code. When you choose to return a Result
value, you give the
calling code options. The calling code could choose to attempt to recover in a
way that’s appropriate for its situation, or it could decide that an Err
value in this case is unrecoverable, so it can call panic!
and turn your
recoverable error into an unrecoverable one. Therefore, returning Result
is a
good default choice when you’re defining a function that might fail.
In situations such as examples, prototype code, and tests, it’s more
appropriate to write code that panics instead of returning a Result
. Let’s
explore why, then discuss situations in which the compiler can’t tell that
failure is impossible, but you as a human can. The chapter will conclude with
some general guidelines on how to decide whether to panic in library code.
Examples, Prototype Code, and Tests
When you’re writing an example to illustrate some concept, also including robust
error-handling code can make the example less clear. In
examples, it’s understood that a call to a method like unwrap
that could
panic is meant as a placeholder for the way you’d want your application to
handle errors, which can differ based on what the rest of your code is doing.
Similarly, the unwrap
and expect
methods are very handy when prototyping,
before you’re ready to decide how to handle errors. They leave clear markers in
your code for when you’re ready to make your program more robust.
If a method call fails in a test, you’d want the whole test to fail, even if
that method isn’t the functionality under test. Because panic!
is how a test
is marked as a failure, calling unwrap
or expect
is exactly what should
happen.
Cases in Which You Have More Information Than the Compiler
It would also be appropriate to call unwrap
when you have some other logic
that ensures the Result
will have an Ok
value, but the logic isn’t
something the compiler understands. You’ll still have a Result
value that you
need to handle: whatever operation you’re calling still has the possibility of
failing in general, even though it’s logically impossible in your particular
situation. If you can ensure by manually inspecting the code that you’ll never
have an Err
variant, it’s perfectly acceptable to call unwrap
. Here’s an
example:
fn main() { use std::net::IpAddr; let home: IpAddr = "127.0.0.1".parse().unwrap(); }
We’re creating an IpAddr
instance by parsing a hardcoded string. We can see
that 127.0.0.1
is a valid IP address, so it’s acceptable to use unwrap
here. However, having a hardcoded, valid string doesn’t change the return type
of the parse
method: we still get a Result
value, and the compiler will
still make us handle the Result
as if the Err
variant is a possibility
because the compiler isn’t smart enough to see that this string is always a
valid IP address. If the IP address string came from a user rather than being
hardcoded into the program and therefore did have a possibility of failure,
we’d definitely want to handle the Result
in a more robust way instead.
Guidelines for Error Handling
It’s advisable to have your code panic when it’s possible that your code could end up in a bad state. In this context, a bad state is when some assumption, guarantee, contract, or invariant has been broken, such as when invalid values, contradictory values, or missing values are passed to your code—plus one or more of the following:
- The bad state is something that is unexpected, as opposed to something that will likely happen occasionally, like a user entering data in the wrong format.
- Your code after this point needs to rely on not being in this bad state, rather than checking for the problem at every step.
- There’s not a good way to encode this information in the types you use. We’ll work through an example of what we mean in the “Encoding States and Behavior as Types” section of Chapter 17.
If someone calls your code and passes in values that don’t make sense, the best
choice might be to call panic!
and alert the person using your library to the
bug in their code so they can fix it during development. Similarly, panic!
is
often appropriate if you’re calling external code that is out of your control
and it returns an invalid state that you have no way of fixing.
However, when failure is expected, it’s more appropriate to return a Result
than to make a panic!
call. Examples include a parser being given malformed
data or an HTTP request returning a status that indicates you have hit a rate
limit. In these cases, returning a Result
indicates that failure is an
expected possibility that the calling code must decide how to handle.
When your code performs operations on values, your code should verify the
values are valid first and panic if the values aren’t valid. This is mostly for
safety reasons: attempting to operate on invalid data can expose your code to
vulnerabilities. This is the main reason the standard library will call
panic!
if you attempt an out-of-bounds memory access: trying to access memory
that doesn’t belong to the current data structure is a common security problem.
Functions often have contracts: their behavior is only guaranteed if the
inputs meet particular requirements. Panicking when the contract is violated
makes sense because a contract violation always indicates a caller-side bug and
it’s not a kind of error you want the calling code to have to explicitly
handle. In fact, there’s no reasonable way for calling code to recover; the
calling programmers need to fix the code. Contracts for a function,
especially when a violation will cause a panic, should be explained in the API
documentation for the function.
However, having lots of error checks in all of your functions would be verbose
and annoying. Fortunately, you can use Rust’s type system (and thus the type
checking done by the compiler) to do many of the checks for you. If your
function has a particular type as a parameter, you can proceed with your code’s
logic knowing that the compiler has already ensured you have a valid value. For
example, if you have a type rather than an Option
, your program expects to
have something rather than nothing. Your code then doesn’t have to handle
two cases for the Some
and None
variants: it will only have one case for
definitely having a value. Code trying to pass nothing to your function won’t
even compile, so your function doesn’t have to check for that case at runtime.
Another example is using an unsigned integer type such as u32
, which ensures
the parameter is never negative.
Creating Custom Types for Validation
Let’s take the idea of using Rust’s type system to ensure we have a valid value one step further and look at creating a custom type for validation. Recall the guessing game in Chapter 2 in which our code asked the user to guess a number between 1 and 100. We never validated that the user’s guess was between those numbers before checking it against our secret number; we only validated that the guess was positive. In this case, the consequences were not very dire: our output of “Too high” or “Too low” would still be correct. But it would be a useful enhancement to guide the user toward valid guesses and have different behavior when a user guesses a number that’s out of range versus when a user types, for example, letters instead.
One way to do this would be to parse the guess as an i32
instead of only a
u32
to allow potentially negative numbers, and then add a check for the
number being in range, like so:
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
loop {
// --snip--
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: i32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
if guess < 1 || guess > 100 {
println!("The secret number will be between 1 and 100.");
continue;
}
match guess.cmp(&secret_number) {
// --snip--
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
The if
expression checks whether our value is out of range, tells the user
about the problem, and calls continue
to start the next iteration of the loop
and ask for another guess. After the if
expression, we can proceed with the
comparisons between guess
and the secret number knowing that guess
is
between 1 and 100.
However, this is not an ideal solution: if it was absolutely critical that the program only operated on values between 1 and 100, and it had many functions with this requirement, having a check like this in every function would be tedious (and might impact performance).
Instead, we can make a new type and put the validations in a function to create
an instance of the type rather than repeating the validations everywhere. That
way, it’s safe for functions to use the new type in their signatures and
confidently use the values they receive. Listing 9-13 shows one way to define a
Guess
type that will only create an instance of Guess
if the new
function
receives a value between 1 and 100.
#![allow(unused)] fn main() { pub struct Guess { value: i32, } impl Guess { pub fn new(value: i32) -> Guess { if value < 1 || value > 100 { panic!("Guess value must be between 1 and 100, got {}.", value); } Guess { value } } pub fn value(&self) -> i32 { self.value } } }
Listing 9-13: A Guess
type that will only continue with
values between 1 and 100
First, we define a struct named Guess
that has a field named value
that
holds an i32
. This is where the number will be stored.
Then we implement an associated function named new
on Guess
that creates
instances of Guess
values. The new
function is defined to have one
parameter named value
of type i32
and to return a Guess
. The code in the
body of the new
function tests value
to make sure it’s between 1 and 100.
If value
doesn’t pass this test, we make a panic!
call, which will alert
the programmer who is writing the calling code that they have a bug they need
to fix, because creating a Guess
with a value
outside this range would
violate the contract that Guess::new
is relying on. The conditions in which
Guess::new
might panic should be discussed in its public-facing API
documentation; we’ll cover documentation conventions indicating the possibility
of a panic!
in the API documentation that you create in Chapter 14. If
value
does pass the test, we create a new Guess
with its value
field set
to the value
parameter and return the Guess
.
Next, we implement a method named value
that borrows self
, doesn’t have any
other parameters, and returns an i32
. This kind of method is sometimes called
a getter, because its purpose is to get some data from its fields and return
it. This public method is necessary because the value
field of the Guess
struct is private. It’s important that the value
field be private so code
using the Guess
struct is not allowed to set value
directly: code outside
the module must use the Guess::new
function to create an instance of
Guess
, thereby ensuring there’s no way for a Guess
to have a value
that
hasn’t been checked by the conditions in the Guess::new
function.
A function that has a parameter or returns only numbers between 1 and 100 could
then declare in its signature that it takes or returns a Guess
rather than an
i32
and wouldn’t need to do any additional checks in its body.
Summary
Rust’s error handling features are designed to help you write more robust code.
The panic!
macro signals that your program is in a state it can’t handle and
lets you tell the process to stop instead of trying to proceed with invalid or
incorrect values. The Result
enum uses Rust’s type system to indicate that
operations might fail in a way that your code could recover from. You can use
Result
to tell code that calls your code that it needs to handle potential
success or failure as well. Using panic!
and Result
in the appropriate
situations will make your code more reliable in the face of inevitable problems.
Now that you’ve seen useful ways that the standard library uses generics with
the Option
and Result
enums, we’ll talk about how generics work and how you
can use them in your code.
Generic, Traits và Lifetimes
Hầu hết các ngôn ngữ lập trình hiện nay đều có các công cụ để giảm thiểu việc trùng lặp code. Đối với Rust, ta có generics: có thể coi là một kiểu dữ liệu dạng tổng quát thay thế cho các kiểu dữ liệu thông thường.
Các tham số truyền vào trong hàm hoàn toàn có thể là các generic, khi đó ta sẽ không cần phải suy nghĩ quá nhiều về kiểu dữ liệu của tham số nữa (vd: i32
hay String
). Nếu bạn để ý, Option<T>
trong chương 6, Vec<T>
và HashMap<K,V>
ở chương 8 hay Result<T,E>
ở chương 9 đều sử dụng generic.
Trong chương này, ta sẽ học cách định nghĩa kiểu dữ liệu, hàm và phương thức sử dụng generic!
Đầu tiên, ta sẽ tìm hiểu cách giảm trùng lặp code khi sử dụng generic function cho các hàm chỉ có sự khác biệt về kiểu dữ liệu truyền vào. Đồng thời tìm hiểu thêm về generic trong struct và enum.
Tiếp theo, traits sẽ là công cụ giúp tạo ra các phương thức tổng quát và trừu tượng (rất giống interface trong Java).
Trong Rust, generic type là một kiểu dữ liệu có thể chấp nhận nhiều kiểu dữ liệu khác nhau. Ví dụ, một generic type như Vec<T>
có thể chứa bất kỳ kiểu dữ liệu nào, từ số nguyên đến chuỗi hay các struct. Tuy nhiên, đôi khi chúng ta muốn giới hạn kiểu dữ liệu được chấp nhận bởi generic type này để chỉ chấp nhận những kiểu dữ liệu có hành vi cụ thể.
Điều này có thể được đạt được bằng cách kết hợp traits và generic types. Trong Rust, traits là một cách để mô tả các hành vi của một kiểu dữ liệu. Bằng cách kết hợp một trait với một generic type, chúng ta có thể giới hạn generic type đó chỉ chấp nhận các kiểu dữ liệu có hành vi tương ứng với trait đó.
Ví dụ, nếu chúng ta muốn tạo một generic type chỉ chấp nhận các kiểu dữ liệu có thể sắp xếp được, chúng ta có thể sử dụng trait Ord của Rust để giới hạn kiểu dữ liệu được chấp nhận bởi generic type này. Bằng cách này, chúng ta sẽ không thể sử dụng generic type này với các kiểu dữ liệu không thể sắp xếp được như chuỗi hay struct không hỗ trợ tính năng sắp xếp.
Cuối cùng, ta sẽ bàn về lifetimes: Lifetime trong Rust là một khái niệm được sử dụng để quản lý việc sử dụng bộ nhớ động trong khi lập trình. Khi một biến được tạo ra, nó được lưu trữ trong bộ nhớ động của máy tính. Tuy nhiên, khi biến đó không còn được sử dụng, bộ nhớ đó cần được giải phóng để sử dụng cho các mục đích khác.
Trong Rust, các biến và các giá trị của chúng có thể có các lifetime khác nhau. Lifetime đại diện cho thời gian mà một giá trị được lưu trữ trong bộ nhớ. Khi một biến được tạo ra, nó được gắn kèm với một lifetime, được biểu thị bằng ký tự 'a
(với 'a
có thể được thay bằng bất kỳ ký tự nào khác).
Lifetime cho phép Rust xác định thời điểm mà một biến cần được giải phóng khỏi bộ nhớ động. Điều này giúp tránh các lỗi liên quan đến việc sử dụng bộ nhớ không hợp lý, chẳng hạn như truy cập đến vùng bộ nhớ đã được giải phóng hoặc truy cập đến vùng bộ nhớ không hợp lý.
Sử dụng hàm để tránh lặp code
Cùng bắt đầu với đoạn code sau:
Filename: src/main.rs
fn main() { let number_list = vec![34, 50, 25, 100, 65]; let mut largest = number_list[0]; for number in number_list { if number > largest { largest = number; } } println!("The largest number is {}", largest); assert_eq!(largest, 100); }
Listing 10-1: Tìm số lớn nhất trong chuỗi số
Mảng các số được lưu bởi biến number_list
và gán phần tử đầu tiên vào biến largest
. Sau đó duyệt qua toàn bộ mảng, nếu số hiện tại lớn hơn số được lưu ở largest
, tiến hành cập nhật giá trị lớn hơn đó vào largest
. Trong bài này kết quả nhận được sẽ là 100.
Giả sử có thêm một chuỗi số thứ 2, nhiệm vụ bây giờ là tìm số lớn nhất trong chuối số thứ 2 này. Vì vậy, ta có thể copy đoạn logic vừa làm phía trên xuống để áp dụng cho chuỗi thứ 2. Filename: src/main.rs
fn main() { let number_list = vec![34, 50, 25, 100, 65]; let mut largest = number_list[0]; for number in number_list { if number > largest { largest = number; } } println!("The largest number is {}", largest); let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8]; let mut largest = number_list[0]; for number in number_list { if number > largest { largest = number; } } println!("The largest number is {}", largest); }
Listing 10-2: Tìm số lớn nhất trong từng chuỗi số
Mặc dù nó hoạt động ổn, nhưng đây là một cách viết code tồi khi đoạn logic trên bị lặp lại, ta sẽ cần đưa chúng vào trong một hàm.
Tạo một hàm có tên largest
. Gọi hàm này mỗi khi cần tìm số lơn nhất của chuỗi số.
Filename: src/main.rs
fn largest(list: &[i32]) -> i32 { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest } fn main() { let number_list = vec![34, 50, 25, 100, 65]; let result = largest(&number_list); println!("The largest number is {}", result); assert_eq!(result, 100); let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8]; let result = largest(&number_list); println!("The largest number is {}", result); assert_eq!(result, 6000); }
Listing 10-3: Sử dụng hàm để tránh lặp code
Cách làm trên giúp giảm thiểu việc lặp code, tuy nhiên nó chỉ tốt khi các chuỗi mà ta làm việc có kiểu i32
. Khi kiểu dữ liệu khác đi, (giả sử char
hoặc float
) hàm này sẽ không thể sử dụng, lúc này generic sẽ phát huy hiệu quả.
Generic Data Types
We use generics to create definitions for items like function signatures or structs, which we can then use with many different concrete data types. Let’s first look at how to define functions, structs, enums, and methods using generics. Then we’ll discuss how generics affect code performance.
In Function Definitions
When defining a function that uses generics, we place the generics in the signature of the function where we would usually specify the data types of the parameters and return value. Doing so makes our code more flexible and provides more functionality to callers of our function while preventing code duplication.
Continuing with our largest
function, Listing 10-4 shows two functions that
both find the largest value in a slice. We'll then combine these into a single
function that uses generics.
Filename: src/main.rs
fn largest_i32(list: &[i32]) -> i32 { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest } fn largest_char(list: &[char]) -> char { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest } fn main() { let number_list = vec![34, 50, 25, 100, 65]; let result = largest_i32(&number_list); println!("The largest number is {}", result); assert_eq!(result, 100); let char_list = vec!['y', 'm', 'a', 'q']; let result = largest_char(&char_list); println!("The largest char is {}", result); assert_eq!(result, 'y'); }
Listing 10-4: Two functions that differ only in their names and the types in their signatures
The largest_i32
function is the one we extracted in Listing 10-3 that finds
the largest i32
in a slice. The largest_char
function finds the largest
char
in a slice. The function bodies have the same code, so let’s eliminate
the duplication by introducing a generic type parameter in a single function.
To parameterize the types in a new single function, we need to name the type
parameter, just as we do for the value parameters to a function. You can use
any identifier as a type parameter name. But we’ll use T
because, by
convention, parameter names in Rust are short, often just a letter, and Rust’s
type-naming convention is CamelCase. Short for “type,” T
is the default
choice of most Rust programmers.
When we use a parameter in the body of the function, we have to declare the
parameter name in the signature so the compiler knows what that name means.
Similarly, when we use a type parameter name in a function signature, we have
to declare the type parameter name before we use it. To define the generic
largest
function, place type name declarations inside angle brackets, <>
,
between the name of the function and the parameter list, like this:
fn largest<T>(list: &[T]) -> T {
We read this definition as: the function largest
is generic over some type
T
. This function has one parameter named list
, which is a slice of values
of type T
. The largest
function will return a value of the
same type T
.
Listing 10-5 shows the combined largest
function definition using the generic
data type in its signature. The listing also shows how we can call the function
with either a slice of i32
values or char
values. Note that this code won’t
compile yet, but we’ll fix it later in this chapter.
Filename: src/main.rs
fn largest<T>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest(&number_list);
println!("The largest number is {}", result);
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest(&char_list);
println!("The largest char is {}", result);
}
Listing 10-5: The largest
function using generic type
parameters; this doesn’t yet compile
If we compile this code right now, we’ll get this error:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `T`
--> src/main.rs:5:17
|
5 | if item > largest {
| ---- ^ ------- T
| |
| T
|
help: consider restricting type parameter `T`
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
| ++++++++++++++++++++++
For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` due to previous error
The note mentions std::cmp::PartialOrd
, which is a trait. We’ll talk about
traits in the next section. For now, know that this error states that the body
of largest
won’t work for all possible types that T
could be. Because we
want to compare values of type T
in the body, we can only use types whose
values can be ordered. To enable comparisons, the standard library has the
std::cmp::PartialOrd
trait that you can implement on types (see Appendix C
for more on this trait). You’ll learn how to specify that a generic type has a
particular trait in the “Traits as Parameters” section. Before we fix this code (in the section “Fixing the
largest
Function with Trait Bounds”), let’s first
explore other ways of using generic type parameters.
In Struct Definitions
We can also define structs to use a generic type parameter in one or more
fields using the <>
syntax. Listing 10-6 defines a Point<T>
struct to hold
x
and y
coordinate values of any type.
Filename: src/main.rs
struct Point<T> { x: T, y: T, } fn main() { let integer = Point { x: 5, y: 10 }; let float = Point { x: 1.0, y: 4.0 }; }
Listing 10-6: A Point<T>
struct that holds x
and y
values of type T
The syntax for using generics in struct definitions is similar to that used in function definitions. First, we declare the name of the type parameter inside angle brackets just after the name of the struct. Then we use the generic type in the struct definition where we would otherwise specify concrete data types.
Note that because we’ve used only one generic type to define Point<T>
, this
definition says that the Point<T>
struct is generic over some type T
, and
the fields x
and y
are both that same type, whatever that type may be. If
we create an instance of a Point<T>
that has values of different types, as in
Listing 10-7, our code won’t compile.
Filename: src/main.rs
struct Point<T> {
x: T,
y: T,
}
fn main() {
let wont_work = Point { x: 5, y: 4.0 };
}
Listing 10-7: The fields x
and y
must be the same
type because both have the same generic data type T
.
Listing 10-7: The fields x
and y
must be the same type because both have
the same generic data type T
.
In this example, when we assign the integer value 5 to x
, we let the compiler
know that the generic type T
will be an integer for this instance of
Point<T>
. Then when we specify 4.0 for y
, which we’ve defined to have the
same type as x
, we’ll get a type mismatch error like this:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
--> src/main.rs:7:38
|
7 | let wont_work = Point { x: 5, y: 4.0 };
| ^^^ expected integer, found floating-point number
For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` due to previous error
To define a Point
struct where x
and y
are both generics but could have
different types, we can use multiple generic type parameters. For example, in
Listing 10-8, we change the definition of Point
to be generic over types T
and U
where x
is of type T
and y
is of type U
.
Filename: src/main.rs
struct Point<T, U> { x: T, y: U, } fn main() { let both_integer = Point { x: 5, y: 10 }; let both_float = Point { x: 1.0, y: 4.0 }; let integer_and_float = Point { x: 5, y: 4.0 }; }
Listing 10-8: A Point<T, U>
generic over two types so
that x
and y
can be values of different types
Now all the instances of Point
shown are allowed! You can use as many generic
type parameters in a definition as you want, but using more than a few makes
your code hard to read. If you're finding you need lots of generic types in
your code, it could indicate that your code needs restructuring into smaller
pieces.
In Enum Definitions
As we did with structs, we can define enums to hold generic data types in their
variants. Let’s take another look at the Option<T>
enum that the standard
library provides, which we used in Chapter 6:
#![allow(unused)] fn main() { enum Option<T> { Some(T), None, } }
This definition should now make more sense to you. As you can see, the
Option<T>
enum is generic over type T
and has two variants: Some
, which
holds one value of type T
, and a None
variant that doesn’t hold any value.
By using the Option<T>
enum, we can express the abstract concept of an
optional value, and because Option<T>
is generic, we can use this abstraction
no matter what the type of the optional value is.
Enums can use multiple generic types as well. The definition of the Result
enum that we used in Chapter 9 is one example:
#![allow(unused)] fn main() { enum Result<T, E> { Ok(T), Err(E), } }
The Result
enum is generic over two types, T
and E
, and has two variants:
Ok
, which holds a value of type T
, and Err
, which holds a value of type
E
. This definition makes it convenient to use the Result
enum anywhere we
have an operation that might succeed (return a value of some type T
) or fail
(return an error of some type E
). In fact, this is what we used to open a
file in Listing 9-3, where T
was filled in with the type std::fs::File
when
the file was opened successfully and E
was filled in with the type
std::io::Error
when there were problems opening the file.
When you recognize situations in your code with multiple struct or enum definitions that differ only in the types of the values they hold, you can avoid duplication by using generic types instead.
In Method Definitions
We can implement methods on structs and enums (as we did in Chapter 5) and use
generic types in their definitions, too. Listing 10-9 shows the Point<T>
struct we defined in Listing 10-6 with a method named x
implemented on it.
Filename: src/main.rs
struct Point<T> { x: T, y: T, } impl<T> Point<T> { fn x(&self) -> &T { &self.x } } fn main() { let p = Point { x: 5, y: 10 }; println!("p.x = {}", p.x()); }
Listing 10-9: Implementing a method named x
on the
Point<T>
struct that will return a reference to the x
field of type
T
Here, we’ve defined a method named x
on Point<T>
that returns a reference
to the data in the field x
.
Note that we have to declare T
just after impl
so we can use T
to specify
that we’re implementing methods on the type Point<T>
. By declaring T
as a
generic type after impl
, Rust can identify that the type in the angle
brackets in Point
is a generic type rather than a concrete type. We could
have chosen a different name for this generic parameter than the generic
parameter declared in the struct definition, but using the same name is
conventional. Methods written within an impl
that declares the generic type
will be defined on any instance of the type, no matter what concrete type ends
up substituting for the generic type.
We can also specify constraints on generic types when defining methods on the
type. We could, for example, implement methods only on Point<f32>
instances
rather than on Point<T>
instances with any generic type. In Listing 10-10 we
use the concrete type f32
, meaning we don’t declare any types after impl
.
Filename: src/main.rs
struct Point<T> { x: T, y: T, } impl<T> Point<T> { fn x(&self) -> &T { &self.x } } impl Point<f32> { fn distance_from_origin(&self) -> f32 { (self.x.powi(2) + self.y.powi(2)).sqrt() } } fn main() { let p = Point { x: 5, y: 10 }; println!("p.x = {}", p.x()); }
Listing 10-10: An impl
block that only applies to a
struct with a particular concrete type for the generic type parameter T
This code means the type Point<f32>
will have a distance_from_origin
method; other instances of Point<T>
where T
is not of type f32
will not
have this method defined. The method measures how far our point is from the
point at coordinates (0.0, 0.0) and uses mathematical operations that are
available only for floating point types.
Generic type parameters in a struct definition aren’t always the same as those
you use in that same struct’s method signatures. Listing 10-11 uses the generic
types X1
and Y1
for the Point
struct and X2
Y2
for the mixup
method
signature to make the example clearer. The method creates a new Point
instance with the x
value from the self
Point
(of type X1
) and the y
value from the passed-in Point
(of type Y2
).
Filename: src/main.rs
struct Point<X1, Y1> { x: X1, y: Y1, } impl<X1, Y1> Point<X1, Y1> { fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> { Point { x: self.x, y: other.y, } } } fn main() { let p1 = Point { x: 5, y: 10.4 }; let p2 = Point { x: "Hello", y: 'c' }; let p3 = p1.mixup(p2); println!("p3.x = {}, p3.y = {}", p3.x, p3.y); }
Listing 10-11: A method that uses generic types different from its struct’s definition
In main
, we’ve defined a Point
that has an i32
for x
(with value 5
)
and an f64
for y
(with value 10.4
). The p2
variable is a Point
struct
that has a string slice for x
(with value "Hello"
) and a char
for y
(with value c
). Calling mixup
on p1
with the argument p2
gives us p3
,
which will have an i32
for x
, because x
came from p1
. The p3
variable
will have a char
for y
, because y
came from p2
. The println!
macro
call will print p3.x = 5, p3.y = c
.
The purpose of this example is to demonstrate a situation in which some generic
parameters are declared with impl
and some are declared with the method
definition. Here, the generic parameters X1
and Y1
are declared after
impl
because they go with the struct definition. The generic parameters X2
and Y2
are declared after fn mixup
, because they’re only relevant to the
method.
Performance of Code Using Generics
You might be wondering whether there is a runtime cost when using generic type parameters. The good news is that using generic types won't make your run any slower than it would with concrete types.
Rust accomplishes this by performing monomorphization of the code using generics at compile time. Monomorphization is the process of turning generic code into specific code by filling in the concrete types that are used when compiled. In this process, the compiler does the opposite of the steps we used to create the generic function in Listing 10-5: the compiler looks at all the places where generic code is called and generates code for the concrete types the generic code is called with.
Let’s look at how this works by using the standard library’s generic
Option<T>
enum:
#![allow(unused)] fn main() { let integer = Some(5); let float = Some(5.0); }
When Rust compiles this code, it performs monomorphization. During that
process, the compiler reads the values that have been used in Option<T>
instances and identifies two kinds of Option<T>
: one is i32
and the other
is f64
. As such, it expands the generic definition of Option<T>
into
Option_i32
and Option_f64
, thereby replacing the generic definition with
the specific ones.
The monomorphized version of the code looks like the following:
Filename: src/main.rs
enum Option_i32 { Some(i32), None, } enum Option_f64 { Some(f64), None, } fn main() { let integer = Option_i32::Some(5); let float = Option_f64::Some(5.0); }
The generic Option<T>
is replaced with the specific definitions created by
the compiler. Because Rust compiles generic code into code that specifies the
type in each instance, we pay no runtime cost for using generics. When the code
runs, it performs just as it would if we had duplicated each definition by
hand. The process of monomorphization makes Rust’s generics extremely efficient
at runtime.
Traits: Defining Shared Behavior
A trait defines functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic type can be any type that has certain behavior.
Note: Traits are similar to a feature often called interfaces in other languages, although with some differences.
Defining a Trait
A type’s behavior consists of the methods we can call on that type. Different types share the same behavior if we can call the same methods on all of those types. Trait definitions are a way to group method signatures together to define a set of behaviors necessary to accomplish some purpose.
For example, let’s say we have multiple structs that hold various kinds and
amounts of text: a NewsArticle
struct that holds a news story filed in a
particular location and a Tweet
that can have at most 280 characters along
with metadata that indicates whether it was a new tweet, a retweet, or a reply
to another tweet.
We want to make a media aggregator library crate named aggregator
that can
display summaries of data that might be stored in a NewsArticle
or Tweet
instance. To do this, we need a summary from each type, and we’ll request
that summary by calling a summarize
method on an instance. Listing 10-12
shows the definition of a public Summary
trait that expresses this behavior.
Filename: src/lib.rs
pub trait Summary {
fn summarize(&self) -> String;
}
Listing 10-12: A Summary
trait that consists of the
behavior provided by a summarize
method
Here, we declare a trait using the trait
keyword and then the trait’s name,
which is Summary
in this case. We’ve also declared the trait as pub
so that
crates depending on this crate can make use of this trait too, as we’ll see in
a few examples. Inside the curly brackets, we declare the method signatures
that describe the behaviors of the types that implement this trait, which in
this case is fn summarize(&self) -> String
.
After the method signature, instead of providing an implementation within curly
brackets, we use a semicolon. Each type implementing this trait must provide
its own custom behavior for the body of the method. The compiler will enforce
that any type that has the Summary
trait will have the method summarize
defined with this signature exactly.
A trait can have multiple methods in its body: the method signatures are listed one per line and each line ends in a semicolon.
Implementing a Trait on a Type
Now that we’ve defined the desired signatures of the Summary
trait’s methods,
we can implement it on the types in our media aggregator. Listing 10-13 shows
an implementation of the Summary
trait on the NewsArticle
struct that uses
the headline, the author, and the location to create the return value of
summarize
. For the Tweet
struct, we define summarize
as the username
followed by the entire text of the tweet, assuming that tweet content is
already limited to 280 characters.
Filename: src/lib.rs
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
Listing 10-13: Implementing the Summary
trait on the
NewsArticle
and Tweet
types
Implementing a trait on a type is similar to implementing regular methods. The
difference is that after impl
, we put the trait name we want to implement,
then use the for
keyword, and then specify the name of the type we want to
implement the trait for. Within the impl
block, we put the method signatures
that the trait definition has defined. Instead of adding a semicolon after each
signature, we use curly brackets and fill in the method body with the specific
behavior that we want the methods of the trait to have for the particular type.
Now that the library has implemented the Summary
trait on NewsArticle
and
Tweet
, users of the crate can call the trait methods on instances of
NewsArticle
and Tweet
in the same way we call regular methods. The only
difference is that the user must bring the trait into scope as well as the
types. Here’s an example of how a binary crate could use our aggregator
library crate:
use aggregator::{Summary, Tweet};
fn main() {
let tweet = Tweet {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
retweet: false,
};
println!("1 new tweet: {}", tweet.summarize());
}
This code prints 1 new tweet: horse_ebooks: of course, as you probably already know, people
.
Other crates that depend on the aggregator
crate can also bring the Summary
trait into scope to implement Summary
on their own types. One restriction to
note is that we can implement a trait on a type only if at least one of the
trait or the type is local to our crate. For example, we can implement standard
library traits like Display
on a custom type like Tweet
as part of our
aggregator
crate functionality, because the type Tweet
is local to our
aggregator
crate. We can also implement Summary
on Vec<T>
in our
aggregator
crate, because the trait Summary
is local to our aggregator
crate.
But we can’t implement external traits on external types. For example, we can’t
implement the Display
trait on Vec<T>
within our aggregator
crate,
because Display
and Vec<T>
are both defined in the standard library and
aren’t local to our aggregator
crate. This restriction is part of a property
called coherence, and more specifically the orphan rule, so named because
the parent type is not present. This rule ensures that other people’s code
can’t break your code and vice versa. Without the rule, two crates could
implement the same trait for the same type, and Rust wouldn’t know which
implementation to use.
Default Implementations
Sometimes it’s useful to have default behavior for some or all of the methods in a trait instead of requiring implementations for all methods on every type. Then, as we implement the trait on a particular type, we can keep or override each method’s default behavior.
In Listing 10-14 we specify a default string for the summarize
method of the
Summary
trait instead of only defining the method signature, as we did in
Listing 10-12.
Filename: src/lib.rs
pub trait Summary {
fn summarize(&self) -> String {
String::from("(Read more...)")
}
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
Listing 10-14: Defining a Summary
trait with a default
implementation of the summarize
method
To use a default implementation to summarize instances of NewsArticle
, we
specify an empty impl
block with impl Summary for NewsArticle {}
.
Even though we’re no longer defining the summarize
method on NewsArticle
directly, we’ve provided a default implementation and specified that
NewsArticle
implements the Summary
trait. As a result, we can still call
the summarize
method on an instance of NewsArticle
, like this:
use chapter10::{self, NewsArticle, Summary};
fn main() {
let article = NewsArticle {
headline: String::from("Penguins win the Stanley Cup Championship!"),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
};
println!("New article available! {}", article.summarize());
}
This code prints New article available! (Read more...)
.
Creating a default implementation doesn’t require us to change anything about
the implementation of Summary
on Tweet
in Listing 10-13. The reason is that
the syntax for overriding a default implementation is the same as the syntax
for implementing a trait method that doesn’t have a default implementation.
Default implementations can call other methods in the same trait, even if those
other methods don’t have a default implementation. In this way, a trait can
provide a lot of useful functionality and only require implementors to specify
a small part of it. For example, we could define the Summary
trait to have a
summarize_author
method whose implementation is required, and then define a
summarize
method that has a default implementation that calls the
summarize_author
method:
pub trait Summary {
fn summarize_author(&self) -> String;
fn summarize(&self) -> String {
format!("(Read more from {}...)", self.summarize_author())
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize_author(&self) -> String {
format!("@{}", self.username)
}
}
To use this version of Summary
, we only need to define summarize_author
when we implement the trait on a type:
pub trait Summary {
fn summarize_author(&self) -> String;
fn summarize(&self) -> String {
format!("(Read more from {}...)", self.summarize_author())
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize_author(&self) -> String {
format!("@{}", self.username)
}
}
After we define summarize_author
, we can call summarize
on instances of the
Tweet
struct, and the default implementation of summarize
will call the
definition of summarize_author
that we’ve provided. Because we’ve implemented
summarize_author
, the Summary
trait has given us the behavior of the
summarize
method without requiring us to write any more code.
use chapter10::{self, Summary, Tweet};
fn main() {
let tweet = Tweet {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
retweet: false,
};
println!("1 new tweet: {}", tweet.summarize());
}
This code prints 1 new tweet: (Read more from @horse_ebooks...)
.
Note that it isn’t possible to call the default implementation from an overriding implementation of that same method.
Traits as Parameters
Now that you know how to define and implement traits, we can explore how to use
traits to define functions that accept many different types. We'll use the
Summary
trait we implemented on the NewsArticle
and Tweet
types in
Listing 10-13 to define a notify
function that calls the summarize
method
on its item
parameter, which is of some type that implements the Summary
trait. To do this, we use the impl Trait
syntax, like this:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
pub fn notify(item: &impl Summary) {
println!("Breaking news! {}", item.summarize());
}
Instead of a concrete type for the item
parameter, we specify the impl
keyword and the trait name. This parameter accepts any type that implements the
specified trait. In the body of notify
, we can call any methods on item
that come from the Summary
trait, such as summarize
. We can call notify
and pass in any instance of NewsArticle
or Tweet
. Code that calls the
function with any other type, such as a String
or an i32
, won’t compile
because those types don’t implement Summary
.
Trait Bound Syntax
The impl Trait
syntax works for straightforward cases but is actually syntax
sugar for a longer form known as a trait bound; it looks like this:
pub fn notify<T: Summary>(item: &T) {
println!("Breaking news! {}", item.summarize());
}
This longer form is equivalent to the example in the previous section but is more verbose. We place trait bounds with the declaration of the generic type parameter after a colon and inside angle brackets.
The impl Trait
syntax is convenient and makes for more concise code in simple
cases, while the fuller trait bound syntax can express more complexity in other
cases. For example, we can have two parameters that implement Summary
. Doing
so with the impl Trait
syntax looks like this:
pub fn notify(item1: &impl Summary, item2: &impl Summary) {
Using impl Trait
is appropriate if we want this function to allow item1
and
item2
to have different types (as long as both types implement Summary
). If
we want to force both parameters to have the same type, however, we must use a
trait bound, like this:
pub fn notify<T: Summary>(item1: &T, item2: &T) {
The generic type T
specified as the type of the item1
and item2
parameters constrains the function such that the concrete type of the value
passed as an argument for item1
and item2
must be the same.
Specifying Multiple Trait Bounds with the +
Syntax
We can also specify more than one trait bound. Say we wanted notify
to use
display formatting as well as summarize
on item
: we specify in the notify
definition that item
must implement both Display
and Summary
. We can do
so using the +
syntax:
pub fn notify(item: &(impl Summary + Display)) {
The +
syntax is also valid with trait bounds on generic types:
pub fn notify<T: Summary + Display>(item: &T) {
With the two trait bounds specified, the body of notify
can call summarize
and use {}
to format item
.
Clearer Trait Bounds with where
Clauses
Using too many trait bounds has its downsides. Each generic has its own trait
bounds, so functions with multiple generic type parameters can contain lots of
trait bound information between the function’s name and its parameter list,
making the function signature hard to read. For this reason, Rust has alternate
syntax for specifying trait bounds inside a where
clause after the function
signature. So instead of writing this:
fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {
we can use a where
clause, like this:
fn some_function<T, U>(t: &T, u: &U) -> i32
where T: Display + Clone,
U: Clone + Debug
{
This function’s signature is less cluttered: the function name, parameter list, and return type are close together, similar to a function without lots of trait bounds.
Returning Types that Implement Traits
We can also use the impl Trait
syntax in the return position to return a
value of some type that implements a trait, as shown here:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
fn returns_summarizable() -> impl Summary {
Tweet {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
retweet: false,
}
}
By using impl Summary
for the return type, we specify that the
returns_summarizable
function returns some type that implements the Summary
trait without naming the concrete type. In this case, returns_summarizable
returns a Tweet
, but the code calling this function doesn’t need to know that.
The ability to specify a return type only by the trait it implements is
especially useful in the context of closures and iterators, which we cover in
Chapter 13. Closures and iterators create types that only the compiler knows or
types that are very long to specify. The impl Trait
syntax lets you concisely
specify that a function returns some type that implements the Iterator
trait
without needing to write out a very long type.
However, you can only use impl Trait
if you’re returning a single type. For
example, this code that returns either a NewsArticle
or a Tweet
with the
return type specified as impl Summary
wouldn’t work:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
fn returns_summarizable(switch: bool) -> impl Summary {
if switch {
NewsArticle {
headline: String::from(
"Penguins win the Stanley Cup Championship!",
),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
}
} else {
Tweet {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
retweet: false,
}
}
}
Returning either a NewsArticle
or a Tweet
isn’t allowed due to restrictions
around how the impl Trait
syntax is implemented in the compiler. We’ll cover
how to write a function with this behavior in the “Using Trait Objects That
Allow for Values of Different
Types” section of Chapter 17.
Fixing the largest
Function with Trait Bounds
Now that you know how to specify the behavior you want using the generic type
parameter’s bounds, let’s return to Listing 10-5 to fix the definition of the
largest
function that uses a generic type parameter! Last time we tried to
run that code, we received this error:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `T`
--> src/main.rs:5:17
|
5 | if item > largest {
| ---- ^ ------- T
| |
| T
|
help: consider restricting type parameter `T`
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
| ++++++++++++++++++++++
For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` due to previous error
In the body of largest
we wanted to compare two values of type T
using the
greater than (>
) operator. Because that operator is defined as a default
method on the standard library trait std::cmp::PartialOrd
, we need to specify
PartialOrd
in the trait bounds for T
so the largest
function can work on
slices of any type that we can compare. We don’t need to bring PartialOrd
into scope because it’s in the prelude. Change the signature of largest
to
look like this:
fn largest<T: PartialOrd>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest(&number_list);
println!("The largest number is {}", result);
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest(&char_list);
println!("The largest char is {}", result);
}
This time when we compile the code, we get a different set of errors:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0508]: cannot move out of type `[T]`, a non-copy slice
--> src/main.rs:2:23
|
2 | let mut largest = list[0];
| ^^^^^^^
| |
| cannot move out of here
| move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
| help: consider borrowing here: `&list[0]`
error[E0507]: cannot move out of a shared reference
--> src/main.rs:4:18
|
4 | for &item in list {
| ----- ^^^^
| ||
| |data moved here
| |move occurs because `item` has type `T`, which does not implement the `Copy` trait
| help: consider removing the `&`: `item`
Some errors have detailed explanations: E0507, E0508.
For more information about an error, try `rustc --explain E0507`.
error: could not compile `chapter10` due to 2 previous errors
The key line in this error is cannot move out of type [T], a non-copy slice
.
With our non-generic versions of the largest
function, we were only trying to
find the largest i32
or char
. As discussed in the “Stack-Only Data:
Copy” section in Chapter 4, types like
i32
and char
that have a known size can be stored on the stack, so they
implement the Copy
trait. But when we made the largest
function generic, it
became possible for the list
parameter to have types in it that don’t
implement the Copy
trait. Consequently, we wouldn’t be able to move the value
out of list[0]
and into the largest
variable, resulting in this error.
To call this code with only those types that implement the Copy
trait, we can
add Copy
to the trait bounds of T
! Listing 10-15 shows the complete code of
a generic largest
function that will compile as long as the types of the
values in the slice that we pass into the function implement the PartialOrd
and Copy
traits, like i32
and char
do.
Filename: src/main.rs
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest } fn main() { let number_list = vec![34, 50, 25, 100, 65]; let result = largest(&number_list); println!("The largest number is {}", result); let char_list = vec!['y', 'm', 'a', 'q']; let result = largest(&char_list); println!("The largest char is {}", result); }
Listing 10-15: A working definition of the largest
function that works on any generic type that implements the PartialOrd
and
Copy
traits
If we don’t want to restrict the largest
function to the types that implement
the Copy
trait, we could specify that T
has the trait bound Clone
instead
of Copy
. Then we could clone each value in the slice when we want the
largest
function to have ownership. Using the clone
function means we’re
potentially making more heap allocations in the case of types that own heap
data like String
, and heap allocations can be slow if we’re working with
large amounts of data.
We could also implement largest
by having the function return a reference to
a T
value in the slice. If we change the return type to &T
instead of T
,
thereby changing the body of the function to return a reference, we wouldn’t
need the Clone
or Copy
trait bounds and we could avoid heap allocations.
Try implementing these alternate solutions on your own! If you get stuck with
errors having to do with lifetimes, keep reading: the “Validating References
with Lifetimes” section coming up will explain, but lifetimes aren’t required
to solve these challenges.
Using Trait Bounds to Conditionally Implement Methods
By using a trait bound with an impl
block that uses generic type parameters,
we can implement methods conditionally for types that implement the specified
traits. For example, the type Pair<T>
in Listing 10-16 always implements the
new
function to return a new instance of Pair<T>
(recall from the
“Defining Methods” section of Chapter 5 that Self
is a type alias for the type of the impl
block, which in this case is
Pair<T>
). But in the next impl
block, Pair<T>
only implements the
cmp_display
method if its inner type T
implements the PartialOrd
trait
that enables comparison and the Display
trait that enables printing.
Filename: src/lib.rs
use std::fmt::Display;
struct Pair<T> {
x: T,
y: T,
}
impl<T> Pair<T> {
fn new(x: T, y: T) -> Self {
Self { x, y }
}
}
impl<T: Display + PartialOrd> Pair<T> {
fn cmp_display(&self) {
if self.x >= self.y {
println!("The largest member is x = {}", self.x);
} else {
println!("The largest member is y = {}", self.y);
}
}
}
Listing 10-16: Conditionally implement methods on a generic type depending on trait bounds
We can also conditionally implement a trait for any type that implements
another trait. Implementations of a trait on any type that satisfies the trait
bounds are called blanket implementations and are extensively used in the
Rust standard library. For example, the standard library implements the
ToString
trait on any type that implements the Display
trait. The impl
block in the standard library looks similar to this code:
impl<T: Display> ToString for T {
// --snip--
}
Because the standard library has this blanket implementation, we can call the
to_string
method defined by the ToString
trait on any type that implements
the Display
trait. For example, we can turn integers into their corresponding
String
values like this because integers implement Display
:
#![allow(unused)] fn main() { let s = 3.to_string(); }
Blanket implementations appear in the documentation for the trait in the “Implementors” section.
Traits and trait bounds let us write code that uses generic type parameters to reduce duplication but also specify to the compiler that we want the generic type to have particular behavior. The compiler can then use the trait bound information to check that all the concrete types used with our code provide the correct behavior. In dynamically typed languages, we would get an error at runtime if we called a method on a type which didn’t define the method. But Rust moves these errors to compile time so we’re forced to fix the problems before our code is even able to run. Additionally, we don’t have to write code that checks for behavior at runtime because we’ve already checked at compile time. Doing so improves performance without having to give up the flexibility of generics.
Validating References with Lifetimes
Lifetimes are another kind of generic that we’ve already been using. Rather than ensuring that a type has the behavior we want, lifetimes ensure that references are valid as long as we need them to be.
One detail we didn’t discuss in the “References and Borrowing” section in Chapter 4 is that every reference in Rust has a lifetime, which is the scope for which that reference is valid. Most of the time, lifetimes are implicit and inferred, just like most of the time, types are inferred. We only must annotate types when multiple types are possible. In a similar way, we must annotate lifetimes when the lifetimes of references could be related in a few different ways. Rust requires us to annotate the relationships using generic lifetime parameters to ensure the actual references used at runtime will definitely be valid.
Annotating lifetimes is not even a concept most other programming languages have, so this is going to feel unfamiliar. Although we won’t cover lifetimes in their entirety in this chapter, we’ll discuss common ways you might encounter lifetime syntax so you can get comfortable with the concept.
Preventing Dangling References with Lifetimes
The main aim of lifetimes is to prevent dangling references, which cause a program to reference data other than the data it’s intended to reference. Consider the program in Listing 10-17, which has an outer scope and an inner scope.
fn main() {
{
let r;
{
let x = 5;
r = &x;
}
println!("r: {}", r);
}
}
Listing 10-17: An attempt to use a reference whose value has gone out of scope
Note: The examples in Listings 10-17, 10-18, and 10-24 declare variables without giving them an initial value, so the variable name exists in the outer scope. At first glance, this might appear to be in conflict with Rust’s having no null values. However, if we try to use a variable before giving it a value, we’ll get a compile-time error, which shows that Rust indeed does not allow null values.
The outer scope declares a variable named r
with no initial value, and the
inner scope declares a variable named x
with the initial value of 5. Inside
the inner scope, we attempt to set the value of r
as a reference to x
. Then
the inner scope ends, and we attempt to print the value in r
. This code won’t
compile because the value r
is referring to has gone out of scope before we
try to use it. Here is the error message:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
--> src/main.rs:7:17
|
7 | r = &x;
| ^^ borrowed value does not live long enough
8 | }
| - `x` dropped here while still borrowed
9 |
10 | println!("r: {}", r);
| - borrow later used here
For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` due to previous error
The variable x
doesn’t “live long enough.” The reason is that x
will be out
of scope when the inner scope ends on line 7. But r
is still valid for the
outer scope; because its scope is larger, we say that it “lives longer.” If
Rust allowed this code to work, r
would be referencing memory that was
deallocated when x
went out of scope, and anything we tried to do with r
wouldn’t work correctly. So how does Rust determine that this code is invalid?
It uses a borrow checker.
The Borrow Checker
The Rust compiler has a borrow checker that compares scopes to determine whether all borrows are valid. Listing 10-18 shows the same code as Listing 10-17 but with annotations showing the lifetimes of the variables.
fn main() {
{
let r; // ---------+-- 'a
// |
{ // |
let x = 5; // -+-- 'b |
r = &x; // | |
} // -+ |
// |
println!("r: {}", r); // |
} // ---------+
}
Listing 10-18: Annotations of the lifetimes of r
and
x
, named 'a
and 'b
, respectively
Here, we’ve annotated the lifetime of r
with 'a
and the lifetime of x
with 'b
. As you can see, the inner 'b
block is much smaller than the outer
'a
lifetime block. At compile time, Rust compares the size of the two
lifetimes and sees that r
has a lifetime of 'a
but that it refers to memory
with a lifetime of 'b
. The program is rejected because 'b
is shorter than
'a
: the subject of the reference doesn’t live as long as the reference.
Listing 10-19 fixes the code so it doesn’t have a dangling reference and compiles without any errors.
fn main() { { let x = 5; // ----------+-- 'b // | let r = &x; // --+-- 'a | // | | println!("r: {}", r); // | | // --+ | } // ----------+ }
Listing 10-19: A valid reference because the data has a longer lifetime than the reference
Here, x
has the lifetime 'b
, which in this case is larger than 'a
. This
means r
can reference x
because Rust knows that the reference in r
will
always be valid while x
is valid.
Now that you know where the lifetimes of references are and how Rust analyzes lifetimes to ensure references will always be valid, let’s explore generic lifetimes of parameters and return values in the context of functions.
Generic Lifetimes in Functions
We’ll write a function that returns the longer of two string slices. This
function will take two string slices and return a single string slice. After
we’ve implemented the longest
function, the code in Listing 10-20 should
print The longest string is abcd
.
Filename: src/main.rs
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {}", result);
}
Listing 10-20: A main
function that calls the longest
function to find the longer of two string slices
Note that we want the function to take string slices, which are references,
rather than strings, because we don’t want the longest
function to take
ownership of its parameters. Refer to the “String Slices as
Parameters” section in Chapter 4
for more discussion about why the parameters we use in Listing 10-20 are the
ones we want.
If we try to implement the longest
function as shown in Listing 10-21, it
won’t compile.
Filename: src/main.rs
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {}", result);
}
fn longest(x: &str, y: &str) -> &str {
if x.len() > y.len() {
x
} else {
y
}
}
Listing 10-21: An implementation of the longest
function that returns the longer of two string slices but does not yet
compile
Instead, we get the following error that talks about lifetimes:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0106]: missing lifetime specifier
--> src/main.rs:9:33
|
9 | fn longest(x: &str, y: &str) -> &str {
| ---- ---- ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
|
9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
| ++++ ++ ++ ++
For more information about this error, try `rustc --explain E0106`.
error: could not compile `chapter10` due to previous error
The help text reveals that the return type needs a generic lifetime parameter
on it because Rust can’t tell whether the reference being returned refers to
x
or y
. Actually, we don’t know either, because the if
block in the body
of this function returns a reference to x
and the else
block returns a
reference to y
!
When we’re defining this function, we don’t know the concrete values that will
be passed into this function, so we don’t know whether the if
case or the
else
case will execute. We also don’t know the concrete lifetimes of the
references that will be passed in, so we can’t look at the scopes as we did in
Listings 10-18 and 10-19 to determine whether the reference we return will
always be valid. The borrow checker can’t determine this either, because it
doesn’t know how the lifetimes of x
and y
relate to the lifetime of the
return value. To fix this error, we’ll add generic lifetime parameters that
define the relationship between the references so the borrow checker can
perform its analysis.
Lifetime Annotation Syntax
Lifetime annotations don’t change how long any of the references live. Rather, they describe the relationships of the lifetimes of multiple references to each other without affecting the lifetimes. Just as functions can accept any type when the signature specifies a generic type parameter, functions can accept references with any lifetime by specifying a generic lifetime parameter.
Lifetime annotations have a slightly unusual syntax: the names of lifetime
parameters must start with an apostrophe ('
) and are usually all lowercase
and very short, like generic types. Most people use the name 'a
for the first
lifetime annotation. We place lifetime parameter annotations after the &
of a
reference, using a space to separate the annotation from the reference’s type.
Here are some examples: a reference to an i32
without a lifetime parameter, a
reference to an i32
that has a lifetime parameter named 'a
, and a mutable
reference to an i32
that also has the lifetime 'a
.
&i32 // a reference
&'a i32 // a reference with an explicit lifetime
&'a mut i32 // a mutable reference with an explicit lifetime
One lifetime annotation by itself doesn’t have much meaning, because the
annotations are meant to tell Rust how generic lifetime parameters of multiple
references relate to each other. For example, let’s say we have a function with
the parameter first
that is a reference to an i32
with lifetime 'a
. The
function also has another parameter named second
that is another reference to
an i32
that also has the lifetime 'a
. The lifetime annotations indicate
that the references first
and second
must both live as long as that generic
lifetime.
Lifetime Annotations in Function Signatures
Now let’s examine lifetime annotations in the context of the longest
function. As with generic type parameters, we need to declare generic lifetime
parameters inside angle brackets between the function name and the parameter
list. We want the signature to express the following constraint: the returned
reference will be valid as long as both the parameters are valid. This is the
relationship between lifetimes of the parameters and the return value. We’ll
name the lifetime 'a
and then add it to each reference, as shown in Listing
10-22.
Filename: src/main.rs
fn main() { let string1 = String::from("abcd"); let string2 = "xyz"; let result = longest(string1.as_str(), string2); println!("The longest string is {}", result); } fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }
Listing 10-22: The longest
function definition
specifying that all the references in the signature must have the same lifetime
'a
This code should compile and produce the result we want when we use it with the
main
function in Listing 10-20.
The function signature now tells Rust that for some lifetime 'a
, the function
takes two parameters, both of which are string slices that live at least as
long as lifetime 'a
. The function signature also tells Rust that the string
slice returned from the function will live at least as long as lifetime 'a
.
In practice, it means that the lifetime of the reference returned by the
longest
function is the same as the smaller of the lifetimes of the
references passed in. These relationships are what we want Rust to use when
analyzing this code.
Remember, when we specify the lifetime parameters in this function signature,
we’re not changing the lifetimes of any values passed in or returned. Rather,
we’re specifying that the borrow checker should reject any values that don’t
adhere to these constraints. Note that the longest
function doesn’t need to
know exactly how long x
and y
will live, only that some scope can be
substituted for 'a
that will satisfy this signature.
When annotating lifetimes in functions, the annotations go in the function signature, not in the function body. The lifetime annotations become part of the contract of the function, much like the types in the signature. Having function signatures contain the lifetime contract means the analysis the Rust compiler does can be simpler. If there’s a problem with the way a function is annotated or the way it is called, the compiler errors can point to the part of our code and the constraints more precisely. If, instead, the Rust compiler made more inferences about what we intended the relationships of the lifetimes to be, the compiler might only be able to point to a use of our code many steps away from the cause of the problem.
When we pass concrete references to longest
, the concrete lifetime that is
substituted for 'a
is the part of the scope of x
that overlaps with the
scope of y
. In other words, the generic lifetime 'a
will get the concrete
lifetime that is equal to the smaller of the lifetimes of x
and y
. Because
we’ve annotated the returned reference with the same lifetime parameter 'a
,
the returned reference will also be valid for the length of the smaller of the
lifetimes of x
and y
.
Let’s look at how the lifetime annotations restrict the longest
function by
passing in references that have different concrete lifetimes. Listing 10-23 is
a straightforward example.
Filename: src/main.rs
fn main() { let string1 = String::from("long string is long"); { let string2 = String::from("xyz"); let result = longest(string1.as_str(), string2.as_str()); println!("The longest string is {}", result); } } fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }
Listing 10-23: Using the longest
function with
references to String
values that have different concrete lifetimes
In this example, string1
is valid until the end of the outer scope, string2
is valid until the end of the inner scope, and result
references something
that is valid until the end of the inner scope. Run this code, and you’ll see
that the borrow checker approves; it will compile and print The longest string is long string is long
.
Next, let’s try an example that shows that the lifetime of the reference in
result
must be the smaller lifetime of the two arguments. We’ll move the
declaration of the result
variable outside the inner scope but leave the
assignment of the value to the result
variable inside the scope with
string2
. Then we’ll move the println!
that uses result
to outside the
inner scope, after the inner scope has ended. The code in Listing 10-24 will
not compile.
Filename: src/main.rs
fn main() {
let string1 = String::from("long string is long");
let result;
{
let string2 = String::from("xyz");
result = longest(string1.as_str(), string2.as_str());
}
println!("The longest string is {}", result);
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
Listing 10-24: Attempting to use result
after string2
has gone out of scope
When we try to compile this code, we get this error:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `string2` does not live long enough
--> src/main.rs:6:44
|
6 | result = longest(string1.as_str(), string2.as_str());
| ^^^^^^^^^^^^^^^^ borrowed value does not live long enough
7 | }
| - `string2` dropped here while still borrowed
8 | println!("The longest string is {}", result);
| ------ borrow later used here
For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` due to previous error
The error shows that for result
to be valid for the println!
statement,
string2
would need to be valid until the end of the outer scope. Rust knows
this because we annotated the lifetimes of the function parameters and return
values using the same lifetime parameter 'a
.
As humans, we can look at this code and see that string1
is longer than
string2
and therefore result
will contain a reference to string1
.
Because string1
has not gone out of scope yet, a reference to string1
will
still be valid for the println!
statement. However, the compiler can’t see
that the reference is valid in this case. We’ve told Rust that the lifetime of
the reference returned by the longest
function is the same as the smaller of
the lifetimes of the references passed in. Therefore, the borrow checker
disallows the code in Listing 10-24 as possibly having an invalid reference.
Try designing more experiments that vary the values and lifetimes of the
references passed in to the longest
function and how the returned reference
is used. Make hypotheses about whether or not your experiments will pass the
borrow checker before you compile; then check to see if you’re right!
Thinking in Terms of Lifetimes
The way in which you need to specify lifetime parameters depends on what your
function is doing. For example, if we changed the implementation of the
longest
function to always return the first parameter rather than the longest
string slice, we wouldn’t need to specify a lifetime on the y
parameter. The
following code will compile:
Filename: src/main.rs
fn main() { let string1 = String::from("abcd"); let string2 = "efghijklmnopqrstuvwxyz"; let result = longest(string1.as_str(), string2); println!("The longest string is {}", result); } fn longest<'a>(x: &'a str, y: &str) -> &'a str { x }
We’ve specified a lifetime parameter 'a
for the parameter x
and the return
type, but not for the parameter y
, because the lifetime of y
does not have
any relationship with the lifetime of x
or the return value.
When returning a reference from a function, the lifetime parameter for the
return type needs to match the lifetime parameter for one of the parameters. If
the reference returned does not refer to one of the parameters, it must refer
to a value created within this function. However, this would be a dangling
reference because the value will go out of scope at the end of the function.
Consider this attempted implementation of the longest
function that won’t
compile:
Filename: src/main.rs
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {}", result);
}
fn longest<'a>(x: &str, y: &str) -> &'a str {
let result = String::from("really long string");
result.as_str()
}
Here, even though we’ve specified a lifetime parameter 'a
for the return
type, this implementation will fail to compile because the return value
lifetime is not related to the lifetime of the parameters at all. Here is the
error message we get:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0515]: cannot return reference to local variable `result`
--> src/main.rs:11:5
|
11 | result.as_str()
| ^^^^^^^^^^^^^^^ returns a reference to data owned by the current function
For more information about this error, try `rustc --explain E0515`.
error: could not compile `chapter10` due to previous error
The problem is that result
goes out of scope and gets cleaned up at the end
of the longest
function. We’re also trying to return a reference to result
from the function. There is no way we can specify lifetime parameters that
would change the dangling reference, and Rust won’t let us create a dangling
reference. In this case, the best fix would be to return an owned data type
rather than a reference so the calling function is then responsible for
cleaning up the value.
Ultimately, lifetime syntax is about connecting the lifetimes of various parameters and return values of functions. Once they’re connected, Rust has enough information to allow memory-safe operations and disallow operations that would create dangling pointers or otherwise violate memory safety.
Lifetime Annotations in Struct Definitions
So far, the structs we've define all hold owned types. We can define structs to
hold references, but in that case we would need to add a lifetime annotation on
every reference in the struct’s definition. Listing 10-25 has a struct named
ImportantExcerpt
that holds a string slice.
Filename: src/main.rs
struct ImportantExcerpt<'a> { part: &'a str, } fn main() { let novel = String::from("Call me Ishmael. Some years ago..."); let first_sentence = novel.split('.').next().expect("Could not find a '.'"); let i = ImportantExcerpt { part: first_sentence, }; }
Listing 10-25: A struct that holds a reference, so its definition needs a lifetime annotation
This struct has one field, part
, that holds a string slice, which is a
reference. As with generic data types, we declare the name of the generic
lifetime parameter inside angle brackets after the name of the struct so we can
use the lifetime parameter in the body of the struct definition. This
annotation means an instance of ImportantExcerpt
can’t outlive the reference
it holds in its part
field.
The main
function here creates an instance of the ImportantExcerpt
struct
that holds a reference to the first sentence of the String
owned by the
variable novel
. The data in novel
exists before the ImportantExcerpt
instance is created. In addition, novel
doesn’t go out of scope until after
the ImportantExcerpt
goes out of scope, so the reference in the
ImportantExcerpt
instance is valid.
Lifetime Elision
You’ve learned that every reference has a lifetime and that you need to specify lifetime parameters for functions or structs that use references. However, in Chapter 4 we had a function in Listing 4-9, shown again in Listing 10-26, that compiled without lifetime annotations.
Filename: src/lib.rs
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 my_string = String::from("hello world"); // first_word works on slices of `String`s let word = first_word(&my_string[..]); let my_string_literal = "hello world"; // first_word works on slices of string literals let word = first_word(&my_string_literal[..]); // Because string literals *are* string slices already, // this works too, without the slice syntax! let word = first_word(my_string_literal); }
Listing 10-26: A function we defined in Listing 4-9 that compiled without lifetime annotations, even though the parameter and return type are references
The reason this function compiles without lifetime annotations is historical: in early versions (pre-1.0) of Rust, this code wouldn’t have compiled because every reference needed an explicit lifetime. At that time, the function signature would have been written like this:
fn first_word<'a>(s: &'a str) -> &'a str {
After writing a lot of Rust code, the Rust team found that Rust programmers were entering the same lifetime annotations over and over in particular situations. These situations were predictable and followed a few deterministic patterns. The developers programmed these patterns into the compiler’s code so the borrow checker could infer the lifetimes in these situations and wouldn’t need explicit annotations.
This piece of Rust history is relevant because it’s possible that more deterministic patterns will emerge and be added to the compiler. In the future, even fewer lifetime annotations might be required.
The patterns programmed into Rust’s analysis of references are called the lifetime elision rules. These aren’t rules for programmers to follow; they’re a set of particular cases that the compiler will consider, and if your code fits these cases, you don’t need to write the lifetimes explicitly.
The elision rules don’t provide full inference. If Rust deterministically applies the rules but there is still ambiguity as to what lifetimes the references have, the compiler won’t guess what the lifetime of the remaining references should be. Instead of guessing, the compiler will give you an error that you can resolve by adding the lifetime annotations.
Lifetimes on function or method parameters are called input lifetimes, and lifetimes on return values are called output lifetimes.
The compiler uses three rules to figure out the lifetimes of the references
when there aren’t explicit annotations. The first rule applies to input
lifetimes, and the second and third rules apply to output lifetimes. If the
compiler gets to the end of the three rules and there are still references for
which it can’t figure out lifetimes, the compiler will stop with an error.
These rules apply to fn
definitions as well as impl
blocks.
The first rule is that the compiler assigns a lifetime parameter to each
parameter that’s a reference. In other words, a function with one parameter
gets one lifetime parameter: fn foo<'a>(x: &'a i32)
; a function with two
parameters gets two separate lifetime parameters: fn foo<'a, 'b>(x: &'a i32, y: &'b i32)
; and so on.
The second rule is that, if there is exactly one input lifetime parameter, that
lifetime is assigned to all output lifetime parameters: fn foo<'a>(x: &'a i32) -> &'a i32
.
The third rule is that, if there are multiple input lifetime parameters, but
one of them is &self
or &mut self
because this is a method, the lifetime of
self
is assigned to all output lifetime parameters. This third rule makes
methods much nicer to read and write because fewer symbols are necessary.
Let’s pretend we’re the compiler. We’ll apply these rules to figure out the
lifetimes of the references in the signature of the first_word
function in
Listing 10-26. The signature starts without any lifetimes associated with the
references:
fn first_word(s: &str) -> &str {
Then the compiler applies the first rule, which specifies that each parameter
gets its own lifetime. We’ll call it 'a
as usual, so now the signature is
this:
fn first_word<'a>(s: &'a str) -> &str {
The second rule applies because there is exactly one input lifetime. The second rule specifies that the lifetime of the one input parameter gets assigned to the output lifetime, so the signature is now this:
fn first_word<'a>(s: &'a str) -> &'a str {
Now all the references in this function signature have lifetimes, and the compiler can continue its analysis without needing the programmer to annotate the lifetimes in this function signature.
Let’s look at another example, this time using the longest
function that had
no lifetime parameters when we started working with it in Listing 10-21:
fn longest(x: &str, y: &str) -> &str {
Let’s apply the first rule: each parameter gets its own lifetime. This time we have two parameters instead of one, so we have two lifetimes:
fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {
You can see that the second rule doesn’t apply because there is more than one
input lifetime. The third rule doesn’t apply either, because longest
is a
function rather than a method, so none of the parameters are self
. After
working through all three rules, we still haven’t figured out what the return
type’s lifetime is. This is why we got an error trying to compile the code in
Listing 10-21: the compiler worked through the lifetime elision rules but still
couldn’t figure out all the lifetimes of the references in the signature.
Because the third rule really only applies in method signatures, we’ll look at lifetimes in that context next to see why the third rule means we don’t have to annotate lifetimes in method signatures very often.
Lifetime Annotations in Method Definitions
When we implement methods on a struct with lifetimes, we use the same syntax as that of generic type parameters shown in Listing 10-11. Where we declare and use the lifetime parameters depends on whether they’re related to the struct fields or the method parameters and return values.
Lifetime names for struct fields always need to be declared after the impl
keyword and then used after the struct’s name, because those lifetimes are part
of the struct’s type.
In method signatures inside the impl
block, references might be tied to the
lifetime of references in the struct’s fields, or they might be independent. In
addition, the lifetime elision rules often make it so that lifetime annotations
aren’t necessary in method signatures. Let’s look at some examples using the
struct named ImportantExcerpt
that we defined in Listing 10-25.
First, we’ll use a method named level
whose only parameter is a reference to
self
and whose return value is an i32
, which is not a reference to anything:
struct ImportantExcerpt<'a> { part: &'a str, } impl<'a> ImportantExcerpt<'a> { fn level(&self) -> i32 { 3 } } impl<'a> ImportantExcerpt<'a> { fn announce_and_return_part(&self, announcement: &str) -> &str { println!("Attention please: {}", announcement); self.part } } fn main() { let novel = String::from("Call me Ishmael. Some years ago..."); let first_sentence = novel.split('.').next().expect("Could not find a '.'"); let i = ImportantExcerpt { part: first_sentence, }; }
The lifetime parameter declaration after impl
and its use after the type name
are required, but we’re not required to annotate the lifetime of the reference
to self
because of the first elision rule.
Here is an example where the third lifetime elision rule applies:
struct ImportantExcerpt<'a> { part: &'a str, } impl<'a> ImportantExcerpt<'a> { fn level(&self) -> i32 { 3 } } impl<'a> ImportantExcerpt<'a> { fn announce_and_return_part(&self, announcement: &str) -> &str { println!("Attention please: {}", announcement); self.part } } fn main() { let novel = String::from("Call me Ishmael. Some years ago..."); let first_sentence = novel.split('.').next().expect("Could not find a '.'"); let i = ImportantExcerpt { part: first_sentence, }; }
There are two input lifetimes, so Rust applies the first lifetime elision rule
and gives both &self
and announcement
their own lifetimes. Then, because
one of the parameters is &self
, the return type gets the lifetime of &self
,
and all lifetimes have been accounted for.
The Static Lifetime
One special lifetime we need to discuss is 'static
, which denotes that the
affected reference can live for the entire duration of the program. All
string literals have the 'static
lifetime, which we can annotate as follows:
#![allow(unused)] fn main() { let s: &'static str = "I have a static lifetime."; }
The text of this string is stored directly in the program’s binary, which
is always available. Therefore, the lifetime of all string literals is
'static
.
You might see suggestions to use the 'static
lifetime in error messages. But
before specifying 'static
as the lifetime for a reference, think about
whether the reference you have actually lives the entire lifetime of your
program or not, and whether you want it to. Most of the time, an error message
suggesting the 'static
lifetime results from attempting to create a dangling
reference or a mismatch of the available lifetimes. In such cases, the solution
is fixing those problems, not specifying the 'static
lifetime.
Generic Type Parameters, Trait Bounds, and Lifetimes Together
Let’s briefly look at the syntax of specifying generic type parameters, trait bounds, and lifetimes all in one function!
fn main() { let string1 = String::from("abcd"); let string2 = "xyz"; let result = longest_with_an_announcement( string1.as_str(), string2, "Today is someone's birthday!", ); println!("The longest string is {}", result); } use std::fmt::Display; fn longest_with_an_announcement<'a, T>( x: &'a str, y: &'a str, ann: T, ) -> &'a str where T: Display, { println!("Announcement! {}", ann); if x.len() > y.len() { x } else { y } }
This is the longest
function from Listing 10-22 that returns the longer of
two string slices. But now it has an extra parameter named ann
of the generic
type T
, which can be filled in by any type that implements the Display
trait as specified by the where
clause. This extra parameter will be printed
using {}
, which is why the Display
trait bound is necessary. Because
lifetimes are a type of generic, the declarations of the lifetime parameter
'a
and the generic type parameter T
go in the same list inside the angle
brackets after the function name.
Summary
We covered a lot in this chapter! Now that you know about generic type parameters, traits and trait bounds, and generic lifetime parameters, you’re ready to write code without repetition that works in many different situations. Generic type parameters let you apply the code to different types. Traits and trait bounds ensure that even though the types are generic, they’ll have the behavior the code needs. You learned how to use lifetime annotations to ensure that this flexible code won’t have any dangling references. And all of this analysis happens at compile time, which doesn’t affect runtime performance!
Believe it or not, there is much more to learn on the topics we discussed in this chapter: Chapter 17 discusses trait objects, which are another way to use traits. There are also more complex scenarios involving lifetime annotations that you will only need in very advanced scenarios; for those, you should read the Rust Reference. But next, you’ll learn how to write tests in Rust so you can make sure your code is working the way it should.
Viết kiểm thử tự động
Trong bài tiểu luận “The Humble Programmer” năm 1972, Edsger W. Dijkstra nói rằng “Kiểm thử chương trình có thể là một cách rất hiệu quả để chỉ ra sự tồn tại của các lỗi, nhưng nó không đủ để khẳng định sự vắng mặt của chúng.” Điều đó không có nghĩa là chúng ta không nên thử kiểm tra càng nhiều càng tốt!
Tính chính xác trong các chương trình là mức độ mà code thực hiện những gì chúng ta muốn nó thực hiện. Rust được thiết kế với mức độ quan tâm cao về tính chính xác của các chương trình, nhưng tính chính xác thì rất phức tạp và không dễ để chứng minh. Hệ thống type của Rust gánh một phần lớn gánh nặng này, nhưng hệ thống type không thể kiểm tra được mọi thứ. Vì lý do đó, Rust hỗ trợ viết kiểm thử phần mềm tự động.
Giả sử chúng ta viết một hàm add_two thực hiện cộng 2 vào bất kỳ số nào được truyền cho nó. Hàm này chấp nhận một tham số là số nguyên và kết quả trả về cũng là một số nguyên. Khi chúng ta triển khai và biên dịch hàm đó, Rust sẽ thực hiện tất cả việc kiểm tra kiểu dữ liệu và kiểm tra borrow để đảm bảo tham số được truyền vào đúng, chẳng hạn, chúng ta sẽ không truyền một giá trị String hoặc một tham chiếu không hợp lệ vào hàm này. Nhưng Rust không thể kiểm tra xem hàm này có thực hiện chính xác như những gì chúng ta dự tính hay không, đó là trả về tham số cộng thêm 2 thay vì tham số cộng 10 hoặc tham số trừ 50! Đó là vai trò của kiểm thử.
Ví dụ, chúng ta có thể viết kiểm thử để khẳng định rằng khi chúng ta truyền giá trị 3 vào hàm add_two, giá trị được trả về là 5. Chúng ta có thể chạy lại kiểm thử này bất cứ khi nào chúng ta thực hiện các thay đổi trên code để đảm bảo các hành vi đúng hiện có không bị thay đổi.
Kiểm thử là một kỹ năng phức tạp: chúng ta không thể trình bày chi tiết làm sao để viết kiểm thử tốt trong một chương, nhưng chúng ta sẽ thảo luận về cơ chế hoạt động của kiểm thử trong Rust. Chúng ta sẽ nói về các annotation và macro được hỗ trợ khi viết kiểm thử, hành vi mặc định và các tùy chọn được cung cấp để chạy kiểm thử, cũng như cách sắp xếp các đoạn mã kiểm thử thành đơn vị kiểm thử và kiểm thử tích hợp.
Cách để viết kiểm thử
Kiểm thử là các hàm trong Rust xử dụng để kiểm tra các đoạn code hoạt động đúng như mong đợi. Phần thân của các hàm kiểm thử thường thực hiện những hành động sau:
- Thiết đặt dữ liệu và các trạng thái cần thiết.
- Chạy đoạn mã cần kiểm thử.
- Đối chiếu các kết quả được mong đợi.
Hãy xem các tính năng cụ thể mà Rust cung cấp để viết kiểm thử thể hiện các hành động này,
bao gồm thuộc tính test
, một số macro và thuộc tính should_panic
.
Phân tích một hàm kiểm thử
Hiểu đơn giản nhất, kiểm thử trong Rust là một hàm được chú thích bằng thuộc tính test
.
Các thuộc tính là metadata trong các thành phần của mã Rust; một ví dụ là thuộc tính derive
mà chúng
ta đã sử dụng với struct trong Chương 5. Để biến một hàm thành một hàm kiểm thử,
chỉ cần thêm #[test]
vào dòng bên trên của fn
. Khi bạn chạy kiểm thử bằng lệnh cargo test
,
Rust sẽ xây dựng tệp nhị phân kiểm thử chạy các hàm được chú thích và báo các cáo hàm
kiểm thử pass hay fail.
Bất cứ khi nào chúng ta tạo mới một project dạng thư viện với Cargo, module kiểm thử bao gồm hàm kiểm thử trong đó sẽ được tạo tự động. Module này cung cấp sẵn template để viết kiểm thử vì vậy bạn không phải tìm kiếm cấu trúc và cú pháp chính xác mỗi lần bạn bắt đầu một project mới. Bạn có thể bổ xung thêm bao nhiêu hàm và module kiểm thử tùy ý!
Chúng ta sẽ cùng xem xét một vài khía cạnh xem kiểm thử hoạt động như thế nào thông qua việc thử nghiệm với template trước khi chúng ta thực sự thực hiện kiểm thử bất kỳ đoạn code nào đó.
Hãy tạo một project mới dạng thư viện tên là adder
với mục đích cộng hai số:
$ cargo new adder --lib
Created library `adder` project
$ cd adder
Nội dung của file src/lib.rs trong thư viện adder
sẽ trông như Listing 11-1.
Tên file: src/lib.rs
#[cfg(test)]
mod tests {
#[test]
fn it_works() {
let result = 2 + 2;
assert_eq!(result, 4);
}
}
Listing 11-1: Module kiểm thử và hàm tạo tự động bởi cargo new
Tạm thời hãy bỏ qua hai dòng đầu tiên và tập trung vào hàm kiểm thử. Chú ý
phần chú thích #[test]
: thuộc tính này chỉ ra rằng đây là một hàm kiểm thử,
vì vậy runner sẽ nhận ra để xử lý hàm này như một hàm kiểm thử. Chúng ta có thể
có hàm không phải là kiểm thử trong tests
module để hỗ trợ thiết lập các kịch
bản hoặc thực hiện các tác vụ chung, vì vậy luôn phải chỉ rõ hàm nào là
hàm kiểm thử.
Phần thân của hàm ví dụ bên trên sử dụng assert_eq!
macro để khẳng định rằng
result
là kết quả của phép cộng 2 với 2, bằng 4. Sự xác nhận kết quả đó là ví dụ điển
hình cho định dạng của một kiểm thử. Hãy chạy thử để thấy được là kiểm thử này pass.
Câu lệnh cargo test
chạy tất cả các kiểm thử trong project, như thể hiện trong Listing
11-2.
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.57s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test tests::it_works ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Listing 11-2: Đầu ra từ việc chạy hàm kiểm thử được tự động tạo ra trước đó
Cargo được biên dịch và chạy kiểm thử. Chúng ta thấy dòng running 1 test
.
Dòng tiếp theo hiển thị tên của hàm kiểm thử được tạo ra, tên là it_works
,
và kết quả của việc chạy kiểm thử là ok
. Kết quả được tổng hợp tóm tắt
test result: ok.
có nghĩa là tất cả các kiểm thử đã pass, và phần 1 passed; 0 failed
là tổng số kiểm thử pass hoặc fail.
Có thể đánh dấu bỏ qua một kiểm thử để nó không chạy trong một số trường hợp
cụ thể; chúng ta sẽ nói đến điều đó sau trong phần “Bỏ qua một số kiểm thử trừ khi được
yêu cầu cụ thể” ở chương này. Bởi vì chúng ta không thực hiện
điều đó ở đây nên phần tổng hợp hiển thị 0 ignored
. Chúng ta cũng có thể truyền một tham
số vào câu lệnh cargo test
để chỉ chạy các kiểm thử có tên khớp với một chuỗi; cách làm
này được gọi là chức năng lọc và chúng ta sẽ nói đến điều đó trong phần “Chạy một tập hợp
con các kiểm thử theo tên”. Chúng ta chưa lọc các kiểm thử được chạy, vì vậy
phần cuối của phần tổng hợp hiển thị 0 filtered out
.
The 0 measured
statistic is for benchmark tests that measure performance.
Benchmark tests are, as of this writing, only available in nightly Rust. See
the documentation about benchmark tests to learn more.
The next part of the test output starting at Doc-tests adder
is for the
results of any documentation tests. We don’t have any documentation tests yet,
but Rust can compile any code examples that appear in our API documentation.
This feature helps keep your docs and your code in sync! We’ll discuss how to
write documentation tests in the “Documentation Comments as
Tests” section of Chapter 14. For now, we’ll
ignore the Doc-tests
output.
Let’s start to customize the test to our own needs. First change the name of
the it_works
function to a different name, such as exploration
, like so:
Filename: src/lib.rs
#[cfg(test)]
mod tests {
#[test]
fn exploration() {
assert_eq!(2 + 2, 4);
}
}
Then run cargo test
again. The output now shows exploration
instead of
it_works
:
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.59s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test tests::exploration ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Now we'll add another test, but this time we’ll make a test that fails! Tests
fail when something in the test function panics. Each test is run in a new
thread, and when the main thread sees that a test thread has died, the test is
marked as failed. In Chapter 9, we talked about how the simplest way to panic
is to call the panic!
macro. Enter the new test as a function named
another
, so your src/lib.rs file looks like Listing 11-3.
Filename: src/lib.rs
#[cfg(test)]
mod tests {
#[test]
fn exploration() {
assert_eq!(2 + 2, 4);
}
#[test]
fn another() {
panic!("Make this test fail");
}
}
Listing 11-3: Adding a second test that will fail because
we call the panic!
macro
Run the tests again using cargo test
. The output should look like Listing
11-4, which shows that our exploration
test passed and another
failed.
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.72s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 2 tests
test tests::another ... FAILED
test tests::exploration ... ok
failures:
---- tests::another stdout ----
thread 'main' panicked at 'Make this test fail', src/lib.rs:10:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::another
test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Listing 11-4: Test results when one test passes and one test fails
Instead of ok
, the line test tests::another
shows FAILED
. Two new
sections appear between the individual results and the summary: the first
displays the detailed reason for each test failure. In this case, we get the
details that another
failed because it panicked at 'Make this test fail'
on
line 10 in the src/lib.rs file. The next section lists just the names of all
the failing tests, which is useful when there are lots of tests and lots of
detailed failing test output. We can use the name of a failing test to run just
that test to more easily debug it; we’ll talk more about ways to run tests in
the “Controlling How Tests Are Run” section.
The summary line displays at the end: overall, our test result is FAILED
. We
had one test pass and one test fail.
Now that you’ve seen what the test results look like in different scenarios,
let’s look at some macros other than panic!
that are useful in tests.
Checking Results with the assert!
Macro
The assert!
macro, provided by the standard library, is useful when you want
to ensure that some condition in a test evaluates to true
. We give the
assert!
macro an argument that evaluates to a Boolean. If the value is
true
, nothing happens and the test passes. If the value is false
, the
assert!
macro calls panic!
to cause the test to fail. Using the assert!
macro helps us check that our code is functioning in the way we intend.
In Chapter 5, Listing 5-15, we used a Rectangle
struct and a can_hold
method, which are repeated here in Listing 11-5. Let’s put this code in the
src/lib.rs file, then write some tests for it using the assert!
macro.
Filename: src/lib.rs
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
Listing 11-5: Using the Rectangle
struct and its
can_hold
method from Chapter 5
The can_hold
method returns a Boolean, which means it’s a perfect use case
for the assert!
macro. In Listing 11-6, we write a test that exercises the
can_hold
method by creating a Rectangle
instance that has a width of 8 and
a height of 7 and asserting that it can hold another Rectangle
instance that
has a width of 5 and a height of 1.
Filename: src/lib.rs
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn larger_can_hold_smaller() {
let larger = Rectangle {
width: 8,
height: 7,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(larger.can_hold(&smaller));
}
}
Listing 11-6: A test for can_hold
that checks whether a
larger rectangle can indeed hold a smaller rectangle
Note that we’ve added a new line inside the tests
module: use super::*;
.
The tests
module is a regular module that follows the usual visibility rules
we covered in Chapter 7 in the “Paths for Referring to an Item in the Module
Tree”
section. Because the tests
module is an inner module, we need to bring the
code under test in the outer module into the scope of the inner module. We use
a glob here so anything we define in the outer module is available to this
tests
module.
We’ve named our test larger_can_hold_smaller
, and we’ve created the two
Rectangle
instances that we need. Then we called the assert!
macro and
passed it the result of calling larger.can_hold(&smaller)
. This expression is
supposed to return true
, so our test should pass. Let’s find out!
$ cargo test
Compiling rectangle v0.1.0 (file:///projects/rectangle)
Finished test [unoptimized + debuginfo] target(s) in 0.66s
Running unittests (target/debug/deps/rectangle-6584c4561e48942e)
running 1 test
test tests::larger_can_hold_smaller ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests rectangle
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
It does pass! Let’s add another test, this time asserting that a smaller rectangle cannot hold a larger rectangle:
Filename: src/lib.rs
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn larger_can_hold_smaller() {
// --snip--
let larger = Rectangle {
width: 8,
height: 7,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(larger.can_hold(&smaller));
}
#[test]
fn smaller_cannot_hold_larger() {
let larger = Rectangle {
width: 8,
height: 7,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(!smaller.can_hold(&larger));
}
}
Because the correct result of the can_hold
function in this case is false
,
we need to negate that result before we pass it to the assert!
macro. As a
result, our test will pass if can_hold
returns false
:
$ cargo test
Compiling rectangle v0.1.0 (file:///projects/rectangle)
Finished test [unoptimized + debuginfo] target(s) in 0.66s
Running unittests (target/debug/deps/rectangle-6584c4561e48942e)
running 2 tests
test tests::larger_can_hold_smaller ... ok
test tests::smaller_cannot_hold_larger ... ok
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests rectangle
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Two tests that pass! Now let’s see what happens to our test results when we
introduce a bug in our code. We’ll change the implementation of the can_hold
method by replacing the greater-than sign with a less-than sign when it
compares the widths:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
// --snip--
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width < other.width && self.height > other.height
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn larger_can_hold_smaller() {
let larger = Rectangle {
width: 8,
height: 7,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(larger.can_hold(&smaller));
}
#[test]
fn smaller_cannot_hold_larger() {
let larger = Rectangle {
width: 8,
height: 7,
};
let smaller = Rectangle {
width: 5,
height: 1,
};
assert!(!smaller.can_hold(&larger));
}
}
Running the tests now produces the following:
$ cargo test
Compiling rectangle v0.1.0 (file:///projects/rectangle)
Finished test [unoptimized + debuginfo] target(s) in 0.66s
Running unittests (target/debug/deps/rectangle-6584c4561e48942e)
running 2 tests
test tests::larger_can_hold_smaller ... FAILED
test tests::smaller_cannot_hold_larger ... ok
failures:
---- tests::larger_can_hold_smaller stdout ----
thread 'main' panicked at 'assertion failed: larger.can_hold(&smaller)', src/lib.rs:28:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::larger_can_hold_smaller
test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Our tests caught the bug! Because larger.width
is 8 and smaller.width
is
5, the comparison of the widths in can_hold
now returns false
: 8 is not
less than 5.
Testing Equality with the assert_eq!
and assert_ne!
Macros
A common way to verify functionality is to test for equality between the result
of the code under test and the value you expect the code to return. You could
do this using the assert!
macro and passing it an expression using the ==
operator. However, this is such a common test that the standard library
provides a pair of macros—assert_eq!
and assert_ne!
—to perform this test
more conveniently. These macros compare two arguments for equality or
inequality, respectively. They’ll also print the two values if the assertion
fails, which makes it easier to see why the test failed; conversely, the
assert!
macro only indicates that it got a false
value for the ==
expression, without printing the values that led to the false
value.
In Listing 11-7, we write a function named add_two
that adds 2
to its
parameter, then we test this function using the assert_eq!
macro.
Filename: src/lib.rs
pub fn add_two(a: i32) -> i32 {
a + 2
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_adds_two() {
assert_eq!(4, add_two(2));
}
}
Listing 11-7: Testing the function add_two
using the
assert_eq!
macro
Let’s check that it passes!
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.58s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test tests::it_adds_two ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
We pass 4
as the argument to assert_eq!
, which is equal to the result of
calling add_two(2)
. The line for this test is test tests::it_adds_two ... ok
, and the ok
text indicates that our test passed!
Let’s introduce a bug into our code to see what assert_eq!
looks like when it
fails. Change the implementation of the add_two
function to instead add 3
:
pub fn add_two(a: i32) -> i32 {
a + 3
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_adds_two() {
assert_eq!(4, add_two(2));
}
}
Run the tests again:
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.61s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test tests::it_adds_two ... FAILED
failures:
---- tests::it_adds_two stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
left: `4`,
right: `5`', src/lib.rs:11:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::it_adds_two
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Our test caught the bug! The it_adds_two
test failed, and the message tells
us that the assertion that fails was assertion failed: `(left == right)`
and what the left
and right
values are. This message helps us start
debugging: the left
argument was 4
but the right
argument, where we had
add_two(2)
, was 5
. You can imagine that this would be especially helpful
when we have a lot of tests going on.
Note that in some languages and test frameworks, the parameters to equality
assertion functions are called expected
and actual
, and the order in which
we specify the arguments matters. However, in Rust, they’re called left
and
right
, and the order in which we specify the value we expect and the value
the code produces doesn’t matter. We could write the assertion in this test as
assert_eq!(add_two(2), 4)
, which would result in the same failure message
that displays assertion failed: `(left == right)`
.
The assert_ne!
macro will pass if the two values we give it are not equal and
fail if they’re equal. This macro is most useful for cases when we’re not sure
what a value will be, but we know what the value definitely shouldn’t be.
For example, if we’re testing a function that is guaranteed to change its input
in some way, but the way in which the input is changed depends on the day of
the week that we run our tests, the best thing to assert might be that the
output of the function is not equal to the input.
Under the surface, the assert_eq!
and assert_ne!
macros use the operators
==
and !=
, respectively. When the assertions fail, these macros print their
arguments using debug formatting, which means the values being compared must
implement the PartialEq
and Debug
traits. All primitive types and most of
the standard library types implement these traits. For structs and enums that
you define yourself, you’ll need to implement PartialEq
to assert equality of
those types. You’ll also need to implement Debug
to print the values when the
assertion fails. Because both traits are derivable traits, as mentioned in
Listing 5-12 in Chapter 5, this is usually as straightforward as adding the
#[derive(PartialEq, Debug)]
annotation to your struct or enum definition. See
Appendix C, “Derivable Traits,” for more
details about these and other derivable traits.
Adding Custom Failure Messages
You can also add a custom message to be printed with the failure message as
optional arguments to the assert!
, assert_eq!
, and assert_ne!
macros. Any
arguments specified after the required arguments are passed along to the
format!
macro (discussed in Chapter 8 in the “Concatenation with the +
Operator or the format!
Macro”
section), so you can pass a format string that contains {}
placeholders and
values to go in those placeholders. Custom messages are useful for documenting
what an assertion means; when a test fails, you’ll have a better idea of what
the problem is with the code.
For example, let’s say we have a function that greets people by name and we want to test that the name we pass into the function appears in the output:
Filename: src/lib.rs
pub fn greeting(name: &str) -> String {
format!("Hello {}!", name)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn greeting_contains_name() {
let result = greeting("Carol");
assert!(result.contains("Carol"));
}
}
The requirements for this program haven’t been agreed upon yet, and we’re
pretty sure the Hello
text at the beginning of the greeting will change. We
decided we don’t want to have to update the test when the requirements change,
so instead of checking for exact equality to the value returned from the
greeting
function, we’ll just assert that the output contains the text of the
input parameter.
Now let’s introduce a bug into this code by changing greeting
to exclude
name
to see what the default test failure looks like:
pub fn greeting(name: &str) -> String {
String::from("Hello!")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn greeting_contains_name() {
let result = greeting("Carol");
assert!(result.contains("Carol"));
}
}
Running this test produces the following:
$ cargo test
Compiling greeter v0.1.0 (file:///projects/greeter)
Finished test [unoptimized + debuginfo] target(s) in 0.91s
Running unittests (target/debug/deps/greeter-170b942eb5bf5e3a)
running 1 test
test tests::greeting_contains_name ... FAILED
failures:
---- tests::greeting_contains_name stdout ----
thread 'main' panicked at 'assertion failed: result.contains(\"Carol\")', src/lib.rs:12:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::greeting_contains_name
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
This result just indicates that the assertion failed and which line the
assertion is on. A more useful failure message would print the value from the
greeting
function. Let’s add a custom failure message composed of a format
string with a placeholder filled in with the actual value we got from the
greeting
function:
pub fn greeting(name: &str) -> String {
String::from("Hello!")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn greeting_contains_name() {
let result = greeting("Carol");
assert!(
result.contains("Carol"),
"Greeting did not contain name, value was `{}`",
result
);
}
}
Now when we run the test, we’ll get a more informative error message:
$ cargo test
Compiling greeter v0.1.0 (file:///projects/greeter)
Finished test [unoptimized + debuginfo] target(s) in 0.93s
Running unittests (target/debug/deps/greeter-170b942eb5bf5e3a)
running 1 test
test tests::greeting_contains_name ... FAILED
failures:
---- tests::greeting_contains_name stdout ----
thread 'main' panicked at 'Greeting did not contain name, value was `Hello!`', src/lib.rs:12:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::greeting_contains_name
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
We can see the value we actually got in the test output, which would help us debug what happened instead of what we were expecting to happen.
Checking for Panics with should_panic
In addition to checking return values, it’s important to check that our code
handles error conditions as we expect. For example, consider the Guess
type
that we created in Chapter 9, Listing 9-13. Other code that uses Guess
depends on the guarantee that Guess
instances will contain only values
between 1 and 100. We can write a test that ensures that attempting to create a
Guess
instance with a value outside that range panics.
We do this by adding the attribute should_panic
to our test function. The
test passes if the code inside the function panics; the test fails if the code
inside the function doesn’t panic.
Listing 11-8 shows a test that checks that the error conditions of Guess::new
happen when we expect them to.
Filename: src/lib.rs
pub struct Guess {
value: i32,
}
impl Guess {
pub fn new(value: i32) -> Guess {
if value < 1 || value > 100 {
panic!("Guess value must be between 1 and 100, got {}.", value);
}
Guess { value }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic]
fn greater_than_100() {
Guess::new(200);
}
}
Listing 11-8: Testing that a condition will cause a
panic!
We place the #[should_panic]
attribute after the #[test]
attribute and
before the test function it applies to. Let’s look at the result when this test
passes:
$ cargo test
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished test [unoptimized + debuginfo] target(s) in 0.58s
Running unittests (target/debug/deps/guessing_game-57d70c3acb738f4d)
running 1 test
test tests::greater_than_100 - should panic ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests guessing_game
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Looks good! Now let’s introduce a bug in our code by removing the condition
that the new
function will panic if the value is greater than 100:
pub struct Guess {
value: i32,
}
// --snip--
impl Guess {
pub fn new(value: i32) -> Guess {
if value < 1 {
panic!("Guess value must be between 1 and 100, got {}.", value);
}
Guess { value }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic]
fn greater_than_100() {
Guess::new(200);
}
}
When we run the test in Listing 11-8, it will fail:
$ cargo test
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished test [unoptimized + debuginfo] target(s) in 0.62s
Running unittests (target/debug/deps/guessing_game-57d70c3acb738f4d)
running 1 test
test tests::greater_than_100 - should panic ... FAILED
failures:
---- tests::greater_than_100 stdout ----
note: test did not panic as expected
failures:
tests::greater_than_100
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
We don’t get a very helpful message in this case, but when we look at the test
function, we see that it’s annotated with #[should_panic]
. The failure we got
means that the code in the test function did not cause a panic.
Tests that use should_panic
can be imprecise. A should_panic
test would
pass even if the test panics for a different reason from the one we were
expecting. To make should_panic
tests more precise, we can add an optional
expected
parameter to the should_panic
attribute. The test harness will
make sure that the failure message contains the provided text. For example,
consider the modified code for Guess
in Listing 11-9 where the new
function
panics with different messages depending on whether the value is too small or
too large.
Filename: src/lib.rs
pub struct Guess {
value: i32,
}
// --snip--
impl Guess {
pub fn new(value: i32) -> Guess {
if value < 1 {
panic!(
"Guess value must be greater than or equal to 1, got {}.",
value
);
} else if value > 100 {
panic!(
"Guess value must be less than or equal to 100, got {}.",
value
);
}
Guess { value }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic(expected = "Guess value must be less than or equal to 100")]
fn greater_than_100() {
Guess::new(200);
}
}
Listing 11-9: Testing for a panic!
with a particular
panic message
This test will pass because the value we put in the should_panic
attribute’s
expected
parameter is a substring of the message that the Guess::new
function panics with. We could have specified the entire panic message that we
expect, which in this case would be Guess value must be less than or equal to 100, got 200.
What you choose to specify depends on how much of the panic
message is unique or dynamic and how precise you want your test to be. In this
case, a substring of the panic message is enough to ensure that the code in the
test function executes the else if value > 100
case.
To see what happens when a should_panic
test with an expected
message
fails, let’s again introduce a bug into our code by swapping the bodies of the
if value < 1
and the else if value > 100
blocks:
pub struct Guess {
value: i32,
}
impl Guess {
pub fn new(value: i32) -> Guess {
if value < 1 {
panic!(
"Guess value must be less than or equal to 100, got {}.",
value
);
} else if value > 100 {
panic!(
"Guess value must be greater than or equal to 1, got {}.",
value
);
}
Guess { value }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic(expected = "Guess value must be less than or equal to 100")]
fn greater_than_100() {
Guess::new(200);
}
}
This time when we run the should_panic
test, it will fail:
$ cargo test
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished test [unoptimized + debuginfo] target(s) in 0.66s
Running unittests (target/debug/deps/guessing_game-57d70c3acb738f4d)
running 1 test
test tests::greater_than_100 - should panic ... FAILED
failures:
---- tests::greater_than_100 stdout ----
thread 'main' panicked at 'Guess value must be greater than or equal to 1, got 200.', src/lib.rs:13:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: panic did not contain expected string
panic message: `"Guess value must be greater than or equal to 1, got 200."`,
expected substring: `"Guess value must be less than or equal to 100"`
failures:
tests::greater_than_100
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
The failure message indicates that this test did indeed panic as we expected,
but the panic message did not include the expected string 'Guess value must be less than or equal to 100'
. The panic message that we did get in this case was
Guess value must be greater than or equal to 1, got 200.
Now we can start
figuring out where our bug is!
Using Result<T, E>
in Tests
Our tests so far all panic when they fail. We can also write tests that use
Result<T, E>
! Here’s the test from Listing 11-1, rewritten to use Result<T, E>
and return an Err
instead of panicking:
#[cfg(test)]
mod tests {
#[test]
fn it_works() -> Result<(), String> {
if 2 + 2 == 4 {
Ok(())
} else {
Err(String::from("two plus two does not equal four"))
}
}
}
The it_works
function now has the Result<(), String>
return type. In the
body of the function, rather than calling the assert_eq!
macro, we return
Ok(())
when the test passes and an Err
with a String
inside when the test
fails.
Writing tests so they return a Result<T, E>
enables you to use the question
mark operator in the body of tests, which can be a convenient way to write
tests that should fail if any operation within them returns an Err
variant.
You can’t use the #[should_panic]
annotation on tests that use Result<T, E>
. To assert that an operation returns an Err
variant, don’t use the
question mark operator on the Result<T, E>
value. Instead, use
assert!(value.is_err())
.
Now that you know several ways to write tests, let’s look at what is happening
when we run our tests and explore the different options we can use with cargo test
.
Controlling How Tests Are Run
Just as cargo run
compiles your code and then runs the resulting binary,
cargo test
compiles your code in test mode and runs the resulting test
binary. The default behavior of the binary produced by cargo test
is to run
all the tests in parallel and capture output generated during test runs,
preventing the output from being displayed and making it easier to read the
output related to the test results. You can, however, specify command line
options to change this default behavior.
Some command line options go to cargo test
, and some go to the resulting test
binary. To separate these two types of arguments, you list the arguments that
go to cargo test
followed by the separator --
and then the ones that go to
the test binary. Running cargo test --help
displays the options you can use
with cargo test
, and running cargo test -- --help
displays the options you
can use after the separator.
Running Tests in Parallel or Consecutively
When you run multiple tests, by default they run in parallel using threads, meaning they finish running faster and you get feedback quicker. Because the tests are running at the same time, you must make sure your tests don’t depend on each other or on any shared state, including a shared environment, such as the current working directory or environment variables.
For example, say each of your tests runs some code that creates a file on disk named test-output.txt and writes some data to that file. Then each test reads the data in that file and asserts that the file contains a particular value, which is different in each test. Because the tests run at the same time, one test might overwrite the file in the time between another test writing and reading the file. The second test will then fail, not because the code is incorrect but because the tests have interfered with each other while running in parallel. One solution is to make sure each test writes to a different file; another solution is to run the tests one at a time.
If you don’t want to run the tests in parallel or if you want more fine-grained
control over the number of threads used, you can send the --test-threads
flag
and the number of threads you want to use to the test binary. Take a look at
the following example:
$ cargo test -- --test-threads=1
We set the number of test threads to 1
, telling the program not to use any
parallelism. Running the tests using one thread will take longer than running
them in parallel, but the tests won’t interfere with each other if they share
state.
Showing Function Output
By default, if a test passes, Rust’s test library captures anything printed to
standard output. For example, if we call println!
in a test and the test
passes, we won’t see the println!
output in the terminal; we’ll see only the
line that indicates the test passed. If a test fails, we’ll see whatever was
printed to standard output with the rest of the failure message.
As an example, Listing 11-10 has a silly function that prints the value of its parameter and returns 10, as well as a test that passes and a test that fails.
Filename: src/lib.rs
fn prints_and_returns_10(a: i32) -> i32 {
println!("I got the value {}", a);
10
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn this_test_will_pass() {
let value = prints_and_returns_10(4);
assert_eq!(10, value);
}
#[test]
fn this_test_will_fail() {
let value = prints_and_returns_10(8);
assert_eq!(5, value);
}
}
Listing 11-10: Tests for a function that calls
println!
When we run these tests with cargo test
, we’ll see the following output:
$ cargo test
Compiling silly-function v0.1.0 (file:///projects/silly-function)
Finished test [unoptimized + debuginfo] target(s) in 0.58s
Running unittests (target/debug/deps/silly_function-160869f38cff9166)
running 2 tests
test tests::this_test_will_fail ... FAILED
test tests::this_test_will_pass ... ok
failures:
---- tests::this_test_will_fail stdout ----
I got the value 8
thread 'main' panicked at 'assertion failed: `(left == right)`
left: `5`,
right: `10`', src/lib.rs:19:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::this_test_will_fail
test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Note that nowhere in this output do we see I got the value 4
, which is what
is printed when the test that passes runs. That output has been captured. The
output from the test that failed, I got the value 8
, appears in the section
of the test summary output, which also shows the cause of the test failure.
If we want to see printed values for passing tests as well, we can tell Rust
to also show the output of successful tests at the end with --show-output
.
$ cargo test -- --show-output
When we run the tests in Listing 11-10 again with the --show-output
flag, we
see the following output:
$ cargo test -- --show-output
Compiling silly-function v0.1.0 (file:///projects/silly-function)
Finished test [unoptimized + debuginfo] target(s) in 0.60s
Running unittests (target/debug/deps/silly_function-160869f38cff9166)
running 2 tests
test tests::this_test_will_fail ... FAILED
test tests::this_test_will_pass ... ok
successes:
---- tests::this_test_will_pass stdout ----
I got the value 4
successes:
tests::this_test_will_pass
failures:
---- tests::this_test_will_fail stdout ----
I got the value 8
thread 'main' panicked at 'assertion failed: `(left == right)`
left: `5`,
right: `10`', src/lib.rs:19:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::this_test_will_fail
test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Running a Subset of Tests by Name
Sometimes, running a full test suite can take a long time. If you’re working on
code in a particular area, you might want to run only the tests pertaining to
that code. You can choose which tests to run by passing cargo test
the name
or names of the test(s) you want to run as an argument.
To demonstrate how to run a subset of tests, we’ll first create three tests for
our add_two
function, as shown in Listing 11-11, and choose which ones to run.
Filename: src/lib.rs
pub fn add_two(a: i32) -> i32 {
a + 2
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn add_two_and_two() {
assert_eq!(4, add_two(2));
}
#[test]
fn add_three_and_two() {
assert_eq!(5, add_two(3));
}
#[test]
fn one_hundred() {
assert_eq!(102, add_two(100));
}
}
Listing 11-11: Three tests with three different names
If we run the tests without passing any arguments, as we saw earlier, all the tests will run in parallel:
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.62s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 3 tests
test tests::add_three_and_two ... ok
test tests::add_two_and_two ... ok
test tests::one_hundred ... ok
test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running Single Tests
We can pass the name of any test function to cargo test
to run only that test:
$ cargo test one_hundred
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.69s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test tests::one_hundred ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s
Only the test with the name one_hundred
ran; the other two tests didn’t match
that name. The test output lets us know we had more tests that didn't run by
displaying 2 filtered out
at the end.
We can’t specify the names of multiple tests in this way; only the first value
given to cargo test
will be used. But there is a way to run multiple tests.
Filtering to Run Multiple Tests
We can specify part of a test name, and any test whose name matches that value
will be run. For example, because two of our tests’ names contain add
, we can
run those two by running cargo test add
:
$ cargo test add
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.61s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 2 tests
test tests::add_three_and_two ... ok
test tests::add_two_and_two ... ok
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s
This command ran all tests with add
in the name and filtered out the test
named one_hundred
. Also note that the module in which a test appears becomes
part of the test’s name, so we can run all the tests in a module by filtering
on the module’s name.
Ignoring Some Tests Unless Specifically Requested
Sometimes a few specific tests can be very time-consuming to execute, so you
might want to exclude them during most runs of cargo test
. Rather than
listing as arguments all tests you do want to run, you can instead annotate the
time-consuming tests using the ignore
attribute to exclude them, as shown
here:
Filename: src/lib.rs
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
#[test]
#[ignore]
fn expensive_test() {
// code that takes an hour to run
}
After #[test]
we add the #[ignore]
line to the test we want to exclude. Now
when we run our tests, it_works
runs, but expensive_test
doesn’t:
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.60s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 2 tests
test expensive_test ... ignored
test it_works ... ok
test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
The expensive_test
function is listed as ignored
. If we want to run only
the ignored tests, we can use cargo test -- --ignored
:
$ cargo test -- --ignored
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.61s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test expensive_test ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
By controlling which tests run, you can make sure your cargo test
results
will be fast. When you’re at a point where it makes sense to check the results
of the ignored
tests and you have time to wait for the results, you can run
cargo test -- --ignored
instead. If you want to run all tests whether they’re
ignored or not, you can run cargo test -- --include-ignored
.
Test Organization
As mentioned at the start of the chapter, testing is a complex discipline, and different people use different terminology and organization. The Rust community thinks about tests in terms of two main categories: unit tests and integration tests. Unit tests are small and more focused, testing one module in isolation at a time, and can test private interfaces. Integration tests are entirely external to your library and use your code in the same way any other external code would, using only the public interface and potentially exercising multiple modules per test.
Writing both kinds of tests is important to ensure that the pieces of your library are doing what you expect them to, separately and together.
Unit Tests
The purpose of unit tests is to test each unit of code in isolation from the
rest of the code to quickly pinpoint where code is and isn’t working as
expected. You’ll put unit tests in the src directory in each file with the
code that they’re testing. The convention is to create a module named tests
in each file to contain the test functions and to annotate the module with
cfg(test)
.
The Tests Module and #[cfg(test)]
The #[cfg(test)]
annotation on the tests module tells Rust to compile and run
the test code only when you run cargo test
, not when you run cargo build
.
This saves compile time when you only want to build the library and saves space
in the resulting compiled artifact because the tests are not included. You’ll
see that because integration tests go in a different directory, they don’t need
the #[cfg(test)]
annotation. However, because unit tests go in the same files
as the code, you’ll use #[cfg(test)]
to specify that they shouldn’t be
included in the compiled result.
Recall that when we generated the new adder
project in the first section of
this chapter, Cargo generated this code for us:
Filename: src/lib.rs
#[cfg(test)]
mod tests {
#[test]
fn it_works() {
let result = 2 + 2;
assert_eq!(result, 4);
}
}
This code is the automatically generated test module. The attribute cfg
stands for configuration and tells Rust that the following item should only
be included given a certain configuration option. In this case, the
configuration option is test
, which is provided by Rust for compiling and
running tests. By using the cfg
attribute, Cargo compiles our test code only
if we actively run the tests with cargo test
. This includes any helper
functions that might be within this module, in addition to the functions
annotated with #[test]
.
Testing Private Functions
There’s debate within the testing community about whether or not private
functions should be tested directly, and other languages make it difficult or
impossible to test private functions. Regardless of which testing ideology you
adhere to, Rust’s privacy rules do allow you to test private functions.
Consider the code in Listing 11-12 with the private function internal_adder
.
Filename: src/lib.rs
pub fn add_two(a: i32) -> i32 {
internal_adder(a, 2)
}
fn internal_adder(a: i32, b: i32) -> i32 {
a + b
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn internal() {
assert_eq!(4, internal_adder(2, 2));
}
}
Listing 11-12: Testing a private function
Note that the internal_adder
function is not marked as pub
. Tests are just
Rust code, and the tests
module is just another module. As we discussed in
the “Paths for Referring to an Item in the Module Tree”
section, items in child modules can use the items in their ancestor modules. In
this test, we bring all of the test
module’s parent’s items into scope with
use super::*
, and then the test can call internal_adder
. If you don’t think
private functions should be tested, there’s nothing in Rust that will compel
you to do so.
Integration Tests
In Rust, integration tests are entirely external to your library. They use your library in the same way any other code would, which means they can only call functions that are part of your library’s public API. Their purpose is to test whether many parts of your library work together correctly. Units of code that work correctly on their own could have problems when integrated, so test coverage of the integrated code is important as well. To create integration tests, you first need a tests directory.
The tests Directory
We create a tests directory at the top level of our project directory, next to src. Cargo knows to look for integration test files in this directory. We can then make as many test files as we want, and Cargo will compile each of the files as an individual crate.
Let’s create an integration test. With the code in Listing 11-12 still in the src/lib.rs file, make a tests directory, create a new file named tests/integration_test.rs, and enter the code in Listing 11-13.
Filename: tests/integration_test.rs
use adder;
#[test]
fn it_adds_two() {
assert_eq!(4, adder::add_two(2));
}
Listing 11-13: An integration test of a function in the
adder
crate
Each file in the tests
directory is a separate crate, so we need to bring our
library into each test crate’s scope. For that reason we add use adder
at the
top of the code, which we didn’t need in the unit tests.
We don’t need to annotate any code in tests/integration_test.rs with
#[cfg(test)]
. Cargo treats the tests
directory specially and compiles files
in this directory only when we run cargo test
. Run cargo test
now:
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 1.31s
Running unittests (target/debug/deps/adder-1082c4b063a8fbe6)
running 1 test
test tests::internal ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running tests/integration_test.rs (target/debug/deps/integration_test-1082c4b063a8fbe6)
running 1 test
test it_adds_two ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
The three sections of output include the unit tests, the integration test, and
the doc tests. The first section for the unit tests is the same as we’ve been
seeing: one line for each unit test (one named internal
that we added in
Listing 11-12) and then a summary line for the unit tests.
The integration tests section starts with the line Running tests/integration_test.rs
. Next, there is a line for each test function in
that integration test and a summary line for the results of the integration
test just before the Doc-tests adder
section starts.
Each integration test file has its own section, so if we add more files in the tests directory, there will be more integration test sections.
We can still run a particular integration test function by specifying the test
function’s name as an argument to cargo test
. To run all the tests in a
particular integration test file, use the --test
argument of cargo test
followed by the name of the file:
$ cargo test --test integration_test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.64s
Running tests/integration_test.rs (target/debug/deps/integration_test-82e7799c1bc62298)
running 1 test
test it_adds_two ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
This command runs only the tests in the tests/integration_test.rs file.
Submodules in Integration Tests
As you add more integration tests, you might want to make more files in the tests directory to help organize them; for example, you can group the test functions by the functionality they’re testing. As mentioned earlier, each file in the tests directory is compiled as its own separate crate, which is useful for creating separate scopes to more closely imitate the way end users will be using your crate. However, this means files in the tests directory don’t share the same behavior as files in src do, as you learned in Chapter 7 regarding how to separate code into modules and files.
The different behavior of tests directory files is most noticeable when you
have a set of helper functions to use in multiple integration test files and
you try to follow the steps in the “Separating Modules into Different
Files” section of Chapter 7 to
extract them into a common module. For example, if we create tests/common.rs
and place a function named setup
in it, we can add some code to setup
that
we want to call from multiple test functions in multiple test files:
Filename: tests/common.rs
#![allow(unused)] fn main() { pub fn setup() { // setup code specific to your library's tests would go here } }
When we run the tests again, we’ll see a new section in the test output for the
common.rs file, even though this file doesn’t contain any test functions nor
did we call the setup
function from anywhere:
$ cargo test
Compiling adder v0.1.0 (file:///projects/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.89s
Running unittests (target/debug/deps/adder-92948b65e88960b4)
running 1 test
test tests::internal ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running tests/common.rs (target/debug/deps/common-92948b65e88960b4)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running tests/integration_test.rs (target/debug/deps/integration_test-92948b65e88960b4)
running 1 test
test it_adds_two ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests adder
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Having common
appear in the test results with running 0 tests
displayed for
it is not what we wanted. We just wanted to share some code with the other
integration test files.
To avoid having common
appear in the test output, instead of creating
tests/common.rs, we’ll create tests/common/mod.rs. This is an alternate
naming convention that Rust also understands. Naming the file this way tells
Rust not to treat the common
module as an integration test file. When we move
the setup
function code into tests/common/mod.rs and delete the
tests/common.rs file, the section in the test output will no longer appear.
Files in subdirectories of the tests directory don’t get compiled as separate
crates or have sections in the test output.
After we’ve created tests/common/mod.rs, we can use it from any of the
integration test files as a module. Here’s an example of calling the setup
function from the it_adds_two
test in tests/integration_test.rs:
Filename: tests/integration_test.rs
use adder;
mod common;
#[test]
fn it_adds_two() {
common::setup();
assert_eq!(4, adder::add_two(2));
}
Note that the mod common;
declaration is the same as the module declaration
we demonstrated in Listing 7-21. Then in the test function, we can call the
common::setup()
function.
Integration Tests for Binary Crates
If our project is a binary crate that only contains a src/main.rs file and
doesn’t have a src/lib.rs file, we can’t create integration tests in the
tests directory and bring functions defined in the src/main.rs file into
scope with a use
statement. Only library crates expose functions that other
crates can use; binary crates are meant to be run on their own.
This is one of the reasons Rust projects that provide a binary have a
straightforward src/main.rs file that calls logic that lives in the
src/lib.rs file. Using that structure, integration tests can test the
library crate with use
to make the important functionality available.
If the important functionality works, the small amount of code in the
src/main.rs file will work as well, and that small amount of code doesn’t
need to be tested.
Summary
Rust’s testing features provide a way to specify how code should function to ensure it continues to work as you expect, even as you make changes. Unit tests exercise different parts of a library separately and can test private implementation details. Integration tests check that many parts of the library work together correctly, and they use the library’s public API to test the code in the same way external code will use it. Even though Rust’s type system and ownership rules help prevent some kinds of bugs, tests are still important to reduce logic bugs having to do with how your code is expected to behave.
Let’s combine the knowledge you learned in this chapter and in previous chapters to work on a project!
An I/O Project: Building a Command Line Program
This chapter is a recap of the many skills you’ve learned so far and an exploration of a few more standard library features. We’ll build a command line tool that interacts with file and command line input/output to practice some of the Rust concepts you now have under your belt.
Rust’s speed, safety, single binary output, and cross-platform support make it
an ideal language for creating command line tools, so for our project, we’ll
make our own version of the classic command line tool grep
(globally
search a regular expression and print). In the simplest use case,
grep
searches a specified file for a specified string. To do so, grep
takes
as its arguments a filename and a string. Then it reads the file, finds lines
in that file that contain the string argument, and prints those lines.
Along the way, we’ll show how to make our command line tool use features of the
terminal that many command line tools use. We’ll read the value of an
environment variable to allow the user to configure the behavior of our tool.
We’ll also print error messages to the standard error console stream (stderr
)
instead of standard output (stdout
), so, for example, the user can redirect
successful output to a file while still seeing error messages onscreen.
One Rust community member, Andrew Gallant, has already created a fully
featured, very fast version of grep
, called ripgrep
. By comparison, our
version of grep
will be fairly simple, but this chapter will give you some of
the background knowledge you need to understand a real-world project such as
ripgrep
.
Our grep
project will combine a number of concepts you’ve learned so far:
- Organizing code (using what you learned about modules in Chapter 7)
- Using vectors and strings (collections, Chapter 8)
- Handling errors (Chapter 9)
- Using traits and lifetimes where appropriate (Chapter 10)
- Writing tests (Chapter 11)
We’ll also briefly introduce closures, iterators, and trait objects, which Chapters 13 and 17 will cover in detail.
Accepting Command Line Arguments
Let’s create a new project with, as always, cargo new
. We’ll call our project
minigrep
to distinguish it from the grep
tool that you might already have
on your system.
$ cargo new minigrep
Created binary (application) `minigrep` project
$ cd minigrep
The first task is to make minigrep
accept its two command line arguments: the
filename and a string to search for. That is, we want to be able to run our
program with cargo run
, a string to search for, and a path to a file to
search in, like so:
$ cargo run searchstring example-filename.txt
Right now, the program generated by cargo new
cannot process arguments we
give it. Some existing libraries on crates.io can help
with writing a program that accepts command line arguments, but because you’re
just learning this concept, let’s implement this capability ourselves.
Reading the Argument Values
To enable minigrep
to read the values of command line arguments we pass to
it, we’ll need a function provided in Rust’s standard library, which is
std::env::args
. This function returns an iterator of the command line
arguments that were given to minigrep
. We’ll cover iterators fully in
Chapter 13. For now, you only need to know two details
about iterators: iterators produce a series of values, and we can call the
collect
method on an iterator to turn it into a collection, such as a vector,
containing all the elements the iterator produces.
Use the code in Listing 12-1 to allow your minigrep
program to read any
command line arguments passed to it and then collect the values into a vector.
Filename: src/main.rs
use std::env; fn main() { let args: Vec<String> = env::args().collect(); println!("{:?}", args); }
Listing 12-1: Collecting the command line arguments into a vector and printing them
First, we bring the std::env
module into scope with a use
statement so we
can use its args
function. Notice that the std::env::args
function is
nested in two levels of modules. As we discussed in Chapter
7, in cases where the desired function is
nested in more than one module, it’s conventional to bring the parent module
into scope rather than the function. By doing so, we can easily use other
functions from std::env
. It’s also less ambiguous than adding use std::env::args
and then calling the function with just args
, because args
might easily be mistaken for a function that’s defined in the current module.
The
args
Function and Invalid UnicodeNote that
std::env::args
will panic if any argument contains invalid Unicode. If your program needs to accept arguments containing invalid Unicode, usestd::env::args_os
instead. That function returns an iterator that producesOsString
values instead ofString
values. We’ve chosen to usestd::env::args
here for simplicity, becauseOsString
values differ per platform and are more complex to work with thanString
values.
On the first line of main
, we call env::args
, and we immediately use
collect
to turn the iterator into a vector containing all the values produced
by the iterator. We can use the collect
function to create many kinds of
collections, so we explicitly annotate the type of args
to specify that we
want a vector of strings. Although we very rarely need to annotate types in
Rust, collect
is one function you do often need to annotate because Rust
isn’t able to infer the kind of collection you want.
Finally, we print the vector using the debug formatter, :?
. Let’s try running
the code first with no arguments and then with two arguments:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.61s
Running `target/debug/minigrep`
["target/debug/minigrep"]
$ cargo run needle haystack
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 1.57s
Running `target/debug/minigrep needle haystack`
["target/debug/minigrep", "needle", "haystack"]
Notice that the first value in the vector is "target/debug/minigrep"
, which
is the name of our binary. This matches the behavior of the arguments list in
C, letting programs use the name by which they were invoked in their execution.
It’s often convenient to have access to the program name in case you want to
print it in messages or change behavior of the program based on what command
line alias was used to invoke the program. But for the purposes of this
chapter, we’ll ignore it and save only the two arguments we need.
Saving the Argument Values in Variables
Printing the value of the vector of arguments illustrated that the program is able to access the values specified as command line arguments. Now we need to save the values of the two arguments in variables so we can use the values throughout the rest of the program. We do that in Listing 12-2.
Filename: src/main.rs
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
let query = &args[1];
let filename = &args[2];
println!("Searching for {}", query);
println!("In file {}", filename);
}
Listing 12-2: Creating variables to hold the query argument and filename argument
As we saw when we printed the vector, the program’s name takes up the first
value in the vector at args[0]
, so we’re starting at index 1
. The first
argument minigrep
takes is the string we’re searching for, so we put a
reference to the first argument in the variable query
. The second argument
will be the filename, so we put a reference to the second argument in the
variable filename
.
We temporarily print the values of these variables to prove that the code is
working as we intend. Let’s run this program again with the arguments test
and sample.txt
:
$ cargo run test sample.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep test sample.txt`
Searching for test
In file sample.txt
Great, the program is working! The values of the arguments we need are being saved into the right variables. Later we’ll add some error handling to deal with certain potential erroneous situations, such as when the user provides no arguments; for now, we’ll ignore that situation and work on adding file-reading capabilities instead.
Reading a File
Now we’ll add functionality to read the file that is specified in the
filename
command line argument. First, we need a sample file to test it with:
the best kind of file to use to make sure minigrep
is working is one with a
small amount of text over multiple lines with some repeated words. Listing 12-3
has an Emily Dickinson poem that will work well! Create a file called
poem.txt at the root level of your project, and enter the poem “I’m Nobody!
Who are you?”
Filename: poem.txt
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.
How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!
Listing 12-3: A poem by Emily Dickinson makes a good test case
With the text in place, edit src/main.rs and add code to read the file, as shown in Listing 12-4.
Filename: src/main.rs
use std::env;
use std::fs;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let query = &args[1];
let filename = &args[2];
println!("Searching for {}", query);
println!("In file {}", filename);
let contents = fs::read_to_string(filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
Listing 12-4: Reading the contents of the file specified by the second argument
First, we add another use
statement to bring in a relevant part of the
standard library: we need std::fs
to handle files.
In main
, we’ve added a new statement: fs::read_to_string
takes the
filename
, opens that file, and returns a Result<String>
of the file’s
contents.
After that statement, we’ve again added a temporary println!
statement that
prints the value of contents
after the file is read, so we can check that the
program is working so far.
Let’s run this code with any string as the first command line argument (because we haven’t implemented the searching part yet) and the poem.txt file as the second argument:
$ cargo run the poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep the poem.txt`
Searching for the
In file poem.txt
With text:
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.
How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!
Great! The code read and then printed the contents of the file. But the code
has a few flaws. The main
function has multiple responsibilities: generally,
functions are clearer and easier to maintain if each function is responsible
for only one idea. The other problem is that we’re not handling errors as well
as we could. The program is still small, so these flaws aren’t a big problem,
but as the program grows, it will be harder to fix them cleanly. It’s good
practice to begin refactoring early on when developing a program, because it’s
much easier to refactor smaller amounts of code. We’ll do that next.
Refactoring to Improve Modularity and Error Handling
To improve our program, we’ll fix four problems that have to do with the program’s structure and how it’s handling potential errors.
First, our main
function now performs two tasks: it parses arguments and
reads files. For such a small function, this isn’t a major problem. However, if
we continue to grow our program inside main
, the number of separate tasks the
main
function handles will increase. As a function gains responsibilities, it
becomes more difficult to reason about, harder to test, and harder to change
without breaking one of its parts. It’s best to separate functionality so each
function is responsible for one task.
This issue also ties into the second problem: although query
and filename
are configuration variables to our program, variables like contents
are used
to perform the program’s logic. The longer main
becomes, the more variables
we’ll need to bring into scope; the more variables we have in scope, the harder
it will be to keep track of the purpose of each. It’s best to group the
configuration variables into one structure to make their purpose clear.
The third problem is that we’ve used expect
to print an error message when
reading the file fails, but the error message just prints Something went wrong reading the file
. Reading a file can fail in a number of ways: for example,
the file could be missing, or we might not have permission to open it. Right
now, regardless of the situation, we’d print the Something went wrong reading the file
error message, which wouldn’t give the user any information!
Fourth, we use expect
repeatedly to handle different errors, and if the user
runs our program without specifying enough arguments, they’ll get an index out of bounds
error from Rust that doesn’t clearly explain the problem. It would
be best if all the error-handling code were in one place so future maintainers
had only one place to consult in the code if the error-handling logic needed to
change. Having all the error-handling code in one place will also ensure that
we’re printing messages that will be meaningful to our end users.
Let’s address these four problems by refactoring our project.
Separation of Concerns for Binary Projects
The organizational problem of allocating responsibility for multiple tasks to
the main
function is common to many binary projects. As a result, the Rust
community has developed a process to use as a guideline for splitting the
separate concerns of a binary program when main
starts getting large. The
process has the following steps:
- Split your program into a main.rs and a lib.rs and move your program’s logic to lib.rs.
- As long as your command line parsing logic is small, it can remain in main.rs.
- When the command line parsing logic starts getting complicated, extract it from main.rs and move it to lib.rs.
The responsibilities that remain in the main
function after this process
should be limited to the following:
- Calling the command line parsing logic with the argument values
- Setting up any other configuration
- Calling a
run
function in lib.rs - Handling the error if
run
returns an error
This pattern is about separating concerns: main.rs handles running the
program, and lib.rs handles all the logic of the task at hand. Because you
can’t test the main
function directly, this structure lets you test all of
your program’s logic by moving it into functions in lib.rs. The only code
that remains in main.rs will be small enough to verify its correctness by
reading it. Let’s rework our program by following this process.
Extracting the Argument Parser
We’ll extract the functionality for parsing arguments into a function that
main
will call to prepare for moving the command line parsing logic to
src/lib.rs. Listing 12-5 shows the new start of main
that calls a new
function parse_config
, which we’ll define in src/main.rs for the moment.
Filename: src/main.rs
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let (query, filename) = parse_config(&args);
// --snip--
println!("Searching for {}", query);
println!("In file {}", filename);
let contents = fs::read_to_string(filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
fn parse_config(args: &[String]) -> (&str, &str) {
let query = &args[1];
let filename = &args[2];
(query, filename)
}
Listing 12-5: Extracting a parse_config
function from
main
We’re still collecting the command line arguments into a vector, but instead of
assigning the argument value at index 1 to the variable query
and the
argument value at index 2 to the variable filename
within the main
function, we pass the whole vector to the parse_config
function. The
parse_config
function then holds the logic that determines which argument
goes in which variable and passes the values back to main
. We still create
the query
and filename
variables in main
, but main
no longer has the
responsibility of determining how the command line arguments and variables
correspond.
This rework may seem like overkill for our small program, but we’re refactoring in small, incremental steps. After making this change, run the program again to verify that the argument parsing still works. It’s good to check your progress often, to help identify the cause of problems when they occur.
Grouping Configuration Values
We can take another small step to improve the parse_config
function further.
At the moment, we’re returning a tuple, but then we immediately break that
tuple into individual parts again. This is a sign that perhaps we don’t have
the right abstraction yet.
Another indicator that shows there’s room for improvement is the config
part
of parse_config
, which implies that the two values we return are related and
are both part of one configuration value. We’re not currently conveying this
meaning in the structure of the data other than by grouping the two values into
a tuple; we could put the two values into one struct and give each of the
struct fields a meaningful name. Doing so will make it easier for future
maintainers of this code to understand how the different values relate to each
other and what their purpose is.
Listing 12-6 shows the improvements to the parse_config
function.
Filename: src/main.rs
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = parse_config(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
// --snip--
println!("With text:\n{}", contents);
}
struct Config {
query: String,
filename: String,
}
fn parse_config(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
Listing 12-6: Refactoring parse_config
to return an
instance of a Config
struct
We’ve added a struct named Config
defined to have fields named query
and
filename
. The signature of parse_config
now indicates that it returns a
Config
value. In the body of parse_config
, where we used to return string
slices that reference String
values in args
, we now define Config
to
contain owned String
values. The args
variable in main
is the owner of
the argument values and is only letting the parse_config
function borrow
them, which means we’d violate Rust’s borrowing rules if Config
tried to take
ownership of the values in args
.
We could manage the String
data in a number of different ways, but the
easiest, though somewhat inefficient, route is to call the clone
method on
the values. This will make a full copy of the data for the Config
instance to
own, which takes more time and memory than storing a reference to the string
data. However, cloning the data also makes our code very straightforward
because we don’t have to manage the lifetimes of the references; in this
circumstance, giving up a little performance to gain simplicity is a worthwhile
trade-off.
The Trade-Offs of Using
clone
There’s a tendency among many Rustaceans to avoid using
clone
to fix ownership problems because of its runtime cost. In Chapter 13, you’ll learn how to use more efficient methods in this type of situation. But for now, it’s okay to copy a few strings to continue making progress because you’ll make these copies only once and your filename and query string are very small. It’s better to have a working program that’s a bit inefficient than to try to hyperoptimize code on your first pass. As you become more experienced with Rust, it’ll be easier to start with the most efficient solution, but for now, it’s perfectly acceptable to callclone
.
We’ve updated main
so it places the instance of Config
returned by
parse_config
into a variable named config
, and we updated the code that
previously used the separate query
and filename
variables so it now uses
the fields on the Config
struct instead.
Now our code more clearly conveys that query
and filename
are related and
that their purpose is to configure how the program will work. Any code that
uses these values knows to find them in the config
instance in the fields
named for their purpose.
Creating a Constructor for Config
So far, we’ve extracted the logic responsible for parsing the command line
arguments from main
and placed it in the parse_config
function. Doing so
helped us to see that the query
and filename
values were related and that
relationship should be conveyed in our code. We then added a Config
struct to
name the related purpose of query
and filename
and to be able to return the
values’ names as struct field names from the parse_config
function.
So now that the purpose of the parse_config
function is to create a Config
instance, we can change parse_config
from a plain function to a function
named new
that is associated with the Config
struct. Making this change
will make the code more idiomatic. We can create instances of types in the
standard library, such as String
, by calling String::new
. Similarly, by
changing parse_config
into a new
function associated with Config
, we’ll
be able to create instances of Config
by calling Config::new
. Listing 12-7
shows the changes we need to make.
Filename: src/main.rs
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
// --snip--
}
// --snip--
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
}
Listing 12-7: Changing parse_config
into
Config::new
We’ve updated main
where we were calling parse_config
to instead call
Config::new
. We’ve changed the name of parse_config
to new
and moved it
within an impl
block, which associates the new
function with Config
. Try
compiling this code again to make sure it works.
Fixing the Error Handling
Now we’ll work on fixing our error handling. Recall that attempting to access
the values in the args
vector at index 1 or index 2 will cause the program to
panic if the vector contains fewer than three items. Try running the program
without any arguments; it will look like this:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep`
thread 'main' panicked at 'index out of bounds: the len is 1 but the index is 1', src/main.rs:27:21
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
The line index out of bounds: the len is 1 but the index is 1
is an error
message intended for programmers. It won’t help our end users understand what
happened and what they should do instead. Let’s fix that now.
Improving the Error Message
In Listing 12-8, we add a check in the new
function that will verify that the
slice is long enough before accessing index 1 and 2. If the slice isn’t long
enough, the program panics and displays a better error message than the index out of bounds
message.
Filename: src/main.rs
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
struct Config {
query: String,
filename: String,
}
impl Config {
// --snip--
fn new(args: &[String]) -> Config {
if args.len() < 3 {
panic!("not enough arguments");
}
// --snip--
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
}
Listing 12-8: Adding a check for the number of arguments
This code is similar to the Guess::new
function we wrote in Listing
9-13, where we called panic!
when the
value
argument was out of the range of valid values. Instead of checking for
a range of values here, we’re checking that the length of args
is at least 3
and the rest of the function can operate under the assumption that this
condition has been met. If args
has fewer than three items, this condition
will be true, and we call the panic!
macro to end the program immediately.
With these extra few lines of code in new
, let’s run the program without any
arguments again to see what the error looks like now:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep`
thread 'main' panicked at 'not enough arguments', src/main.rs:26:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
This output is better: we now have a reasonable error message. However, we also
have extraneous information we don’t want to give to our users. Perhaps using
the technique we used in Listing 9-13 isn’t the best to use here: a call to
panic!
is more appropriate for a programming problem than a usage problem,
as discussed in Chapter 9. Instead, we
can use the other technique you learned about in Chapter 9—returning a
Result
that indicates either success or an error.
Returning a Result
from new
Instead of Calling panic!
We can instead return a Result
value that will contain a Config
instance in
the successful case and will describe the problem in the error case. When
Config::new
is communicating to main
, we can use the Result
type to
signal there was a problem. Then we can change main
to convert an Err
variant into a more practical error for our users without the surrounding text
about thread 'main'
and RUST_BACKTRACE
that a call to panic!
causes.
Listing 12-9 shows the changes we need to make to the return value of
Config::new
and the body of the function needed to return a Result
. Note
that this won’t compile until we update main
as well, which we’ll do in the
next listing.
Filename: src/main.rs
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
Listing 12-9: Returning a Result
from
Config::new
Our new
function now returns a Result
with a Config
instance in the
success case and a &'static str
in the error case. Our error values will
always be string literals that have the 'static
lifetime.
We’ve made two changes in the body of the new
function: instead of calling
panic!
when the user doesn’t pass enough arguments, we now return an Err
value, and we’ve wrapped the Config
return value in an Ok
. These changes
make the function conform to its new type signature.
Returning an Err
value from Config::new
allows the main
function to
handle the Result
value returned from the new
function and exit the process
more cleanly in the error case.
Calling Config::new
and Handling Errors
To handle the error case and print a user-friendly message, we need to update
main
to handle the Result
being returned by Config::new
, as shown in
Listing 12-10. We’ll also take the responsibility of exiting the command line
tool with a nonzero error code from panic!
and implement it by hand. A
nonzero exit status is a convention to signal to the process that called our
program that the program exited with an error state.
Filename: src/main.rs
use std::env;
use std::fs;
use std::process;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
// --snip--
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
Listing 12-10: Exiting with an error code if creating a
new Config
fails
In this listing, we’ve used a method we haven’t covered in detail yet:
unwrap_or_else
, which is defined on Result<T, E>
by the standard library.
Using unwrap_or_else
allows us to define some custom, non-panic!
error
handling. If the Result
is an Ok
value, this method’s behavior is similar
to unwrap
: it returns the inner value Ok
is wrapping. However, if the value
is an Err
value, this method calls the code in the closure, which is an
anonymous function we define and pass as an argument to unwrap_or_else
. We’ll
cover closures in more detail in Chapter 13. For now,
you just need to know that unwrap_or_else
will pass the inner value of the
Err
, which in this case is the static string "not enough arguments"
that we
added in Listing 12-9, to our closure in the argument err
that appears
between the vertical pipes. The code in the closure can then use the err
value when it runs.
We’ve added a new use
line to bring process
from the standard library into
scope. The code in the closure that will be run in the error case is only two
lines: we print the err
value and then call process::exit
. The
process::exit
function will stop the program immediately and return the
number that was passed as the exit status code. This is similar to the
panic!
-based handling we used in Listing 12-8, but we no longer get all the
extra output. Let’s try it:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/minigrep`
Problem parsing arguments: not enough arguments
Great! This output is much friendlier for our users.
Extracting Logic from main
Now that we’ve finished refactoring the configuration parsing, let’s turn to
the program’s logic. As we stated in “Separation of Concerns for Binary
Projects”, we’ll
extract a function named run
that will hold all the logic currently in the
main
function that isn’t involved with setting up configuration or handling
errors. When we’re done, main
will be concise and easy to verify by
inspection, and we’ll be able to write tests for all the other logic.
Listing 12-11 shows the extracted run
function. For now, we’re just making
the small, incremental improvement of extracting the function. We’re still
defining the function in src/main.rs.
Filename: src/main.rs
use std::env;
use std::fs;
use std::process;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
run(config);
}
fn run(config: Config) {
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
// --snip--
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
Listing 12-11: Extracting a run
function containing the
rest of the program logic
The run
function now contains all the remaining logic from main
, starting
from reading the file. The run
function takes the Config
instance as an
argument.
Returning Errors from the run
Function
With the remaining program logic separated into the run
function, we can
improve the error handling, as we did with Config::new
in Listing 12-9.
Instead of allowing the program to panic by calling expect
, the run
function will return a Result<T, E>
when something goes wrong. This will let
us further consolidate into main
the logic around handling errors in a
user-friendly way. Listing 12-12 shows the changes we need to make to the
signature and body of run
.
Filename: src/main.rs
use std::env;
use std::fs;
use std::process;
use std::error::Error;
// --snip--
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
run(config);
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
println!("With text:\n{}", contents);
Ok(())
}
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
Listing 12-12: Changing the run
function to return
Result
We’ve made three significant changes here. First, we changed the return type of
the run
function to Result<(), Box<dyn Error>>
. This function previously
returned the unit type, ()
, and we keep that as the value returned in the
Ok
case.
For the error type, we used the trait object Box<dyn Error>
(and we’ve
brought std::error::Error
into scope with a use
statement at the top).
We’ll cover trait objects in Chapter 17. For now, just
know that Box<dyn Error>
means the function will return a type that
implements the Error
trait, but we don’t have to specify what particular type
the return value will be. This gives us flexibility to return error values that
may be of different types in different error cases. The dyn
keyword is short
for “dynamic.”
Second, we’ve removed the call to expect
in favor of the ?
operator, as we
talked about in Chapter 9. Rather than
panic!
on an error, ?
will return the error value from the current function
for the caller to handle.
Third, the run
function now returns an Ok
value in the success case. We’ve
declared the run
function’s success type as ()
in the signature, which
means we need to wrap the unit type value in the Ok
value. This Ok(())
syntax might look a bit strange at first, but using ()
like this is the
idiomatic way to indicate that we’re calling run
for its side effects only;
it doesn’t return a value we need.
When you run this code, it will compile but will display a warning:
$ cargo run the poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
warning: unused `Result` that must be used
--> src/main.rs:19:5
|
19 | run(config);
| ^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: this `Result` may be an `Err` variant, which should be handled
warning: `minigrep` (bin "minigrep") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 0.71s
Running `target/debug/minigrep the poem.txt`
Searching for the
In file poem.txt
With text:
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.
How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!
Rust tells us that our code ignored the Result
value and the Result
value
might indicate that an error occurred. But we’re not checking to see whether or
not there was an error, and the compiler reminds us that we probably meant to
have some error-handling code here! Let’s rectify that problem now.
Handling Errors Returned from run
in main
We’ll check for errors and handle them using a technique similar to one we used
with Config::new
in Listing 12-10, but with a slight difference:
Filename: src/main.rs
use std::env;
use std::error::Error;
use std::fs;
use std::process;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
if let Err(e) = run(config) {
println!("Application error: {}", e);
process::exit(1);
}
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
println!("With text:\n{}", contents);
Ok(())
}
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
We use if let
rather than unwrap_or_else
to check whether run
returns an
Err
value and call process::exit(1)
if it does. The run
function doesn’t
return a value that we want to unwrap
in the same way that Config::new
returns the Config
instance. Because run
returns ()
in the success case,
we only care about detecting an error, so we don’t need unwrap_or_else
to
return the unwrapped value because it would only be ()
.
The bodies of the if let
and the unwrap_or_else
functions are the same in
both cases: we print the error and exit.
Splitting Code into a Library Crate
Our minigrep
project is looking good so far! Now we’ll split the
src/main.rs file and put some code into the src/lib.rs file so we can test
it and have a src/main.rs file with fewer responsibilities.
Let’s move all the code that isn’t the main
function from src/main.rs to
src/lib.rs:
- The
run
function definition - The relevant
use
statements - The definition of
Config
- The
Config::new
function definition
The contents of src/lib.rs should have the signatures shown in Listing 12-13 (we’ve omitted the bodies of the functions for brevity). Note that this won’t compile until we modify src/main.rs in Listing 12-14.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
// --snip--
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
// --snip--
let contents = fs::read_to_string(config.filename)?;
println!("With text:\n{}", contents);
Ok(())
}
Listing 12-13: Moving Config
and run
into
src/lib.rs
We’ve made liberal use of the pub
keyword: on Config
, on its fields and its
new
method, and on the run
function. We now have a library crate that has a
public API that we can test!
Now we need to bring the code we moved to src/lib.rs into the scope of the binary crate in src/main.rs, as shown in Listing 12-14.
Filename: src/main.rs
use std::env;
use std::process;
use minigrep::Config;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
if let Err(e) = minigrep::run(config) {
// --snip--
println!("Application error: {}", e);
process::exit(1);
}
}
Listing 12-14: Using the minigrep
library crate in
src/main.rs
We add a use minigrep::Config
line to bring the Config
type from the
library crate into the binary crate’s scope, and we prefix the run
function
with our crate name. Now all the functionality should be connected and should
work. Run the program with cargo run
and make sure everything works
correctly.
Whew! That was a lot of work, but we’ve set ourselves up for success in the future. Now it’s much easier to handle errors, and we’ve made the code more modular. Almost all of our work will be done in src/lib.rs from here on out.
Let’s take advantage of this newfound modularity by doing something that would have been difficult with the old code but is easy with the new code: we’ll write some tests!
Developing the Library’s Functionality with Test-Driven Development
Now that we’ve extracted the logic into src/lib.rs and left the argument collecting and error handling in src/main.rs, it’s much easier to write tests for the core functionality of our code. We can call functions directly with various arguments and check return values without having to call our binary from the command line.
In this section, we’ll add the searching logic to the minigrep
program by
using the Test-driven development (TDD) process. This software development
technique follows these steps:
- Write a test that fails and run it to make sure it fails for the reason you expect.
- Write or modify just enough code to make the new test pass.
- Refactor the code you just added or changed and make sure the tests continue to pass.
- Repeat from step 1!
This process is just one of many ways to write software, but TDD can help drive code design as well. Writing the test before you write the code that makes the test pass helps to maintain high test coverage throughout the process.
We’ll test drive the implementation of the functionality that will actually do
the searching for the query string in the file contents and produce a list of
lines that match the query. We’ll add this functionality in a function called
search
.
Writing a Failing Test
Because we don’t need them anymore, let’s remove the println!
statements from
src/lib.rs and src/main.rs that we used to check the program’s behavior.
Then, in src/lib.rs, we’ll add a tests
module with a test function, as we
did in Chapter 11. The test function specifies
the behavior we want the search
function to have: it will take a query and
the text to search for the query in, and it will return only the lines from the
text that contain the query. Listing 12-15 shows this test, which won’t compile
yet.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
Listing 12-15: Creating a failing test for the search
function we wish we had
This test searches for the string "duct"
. The text we’re searching is three
lines, only one of which contains "duct"
(Note that the backslash after the
opening double quote tells Rust not to put a newline character at the beginning
of the contents of this string literal). We assert that the value returned from
the search
function contains only the line we expect.
We aren’t able to run this test and watch it fail because the test doesn’t even
compile: the search
function doesn’t exist yet! So now we’ll add just enough
code to get the test to compile and run by adding a definition of the search
function that always returns an empty vector, as shown in Listing 12-16. Then
the test should compile and fail because an empty vector doesn’t match a vector
containing the line "safe, fast, productive."
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
vec![]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
Listing 12-16: Defining just enough of the search
function so our test will compile
Notice that we need an explicit lifetime 'a
defined in the signature of
search
and used with the contents
argument and the return value. Recall in
Chapter 10 that the lifetime parameters
specify which argument lifetime is connected to the lifetime of the return
value. In this case, we indicate that the returned vector should contain string
slices that reference slices of the argument contents
(rather than the
argument query
).
In other words, we tell Rust that the data returned by the search
function
will live as long as the data passed into the search
function in the
contents
argument. This is important! The data referenced by a slice needs
to be valid for the reference to be valid; if the compiler assumes we’re making
string slices of query
rather than contents
, it will do its safety checking
incorrectly.
If we forget the lifetime annotations and try to compile this function, we’ll get this error:
$ cargo build
Compiling minigrep v0.1.0 (file:///projects/minigrep)
error[E0106]: missing lifetime specifier
--> src/lib.rs:28:51
|
28 | pub fn search(query: &str, contents: &str) -> Vec<&str> {
| ---- ---- ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `query` or `contents`
help: consider introducing a named lifetime parameter
|
28 | pub fn search<'a>(query: &'a str, contents: &'a str) -> Vec<&'a str> {
| ++++ ++ ++ ++
For more information about this error, try `rustc --explain E0106`.
error: could not compile `minigrep` due to previous error
Rust can’t possibly know which of the two arguments we need, so we need to tell
it. Because contents
is the argument that contains all of our text and we
want to return the parts of that text that match, we know contents
is the
argument that should be connected to the return value using the lifetime syntax.
Other programming languages don’t require you to connect arguments to return values in the signature. Although this might seem strange, it will get easier over time. You might want to compare this example with the “Validating References with Lifetimes” section in Chapter 10.
Now let’s run the test:
$ cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished test [unoptimized + debuginfo] target(s) in 0.97s
Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 1 test
test tests::one_result ... FAILED
failures:
---- tests::one_result stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
left: `["safe, fast, productive."]`,
right: `[]`', src/lib.rs:44:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::one_result
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Great, the test fails, exactly as we expected. Let’s get the test to pass!
Writing Code to Pass the Test
Currently, our test is failing because we always return an empty vector. To fix
that and implement search
, our program needs to follow these steps:
- Iterate through each line of the contents.
- Check whether the line contains our query string.
- If it does, add it to the list of values we’re returning.
- If it doesn’t, do nothing.
- Return the list of results that match.
Let’s work through each step, starting with iterating through lines.
Iterating Through Lines with the lines
Method
Rust has a helpful method to handle line-by-line iteration of strings,
conveniently named lines
, that works as shown in Listing 12-17. Note this
won’t compile yet.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
for line in contents.lines() {
// do something with line
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
Listing 12-17: Iterating through each line in contents
The lines
method returns an iterator. We’ll talk about iterators in depth in
Chapter 13, but recall that you saw this way of using an
iterator in Listing 3-5, where we used a for
loop
with an iterator to run some code on each item in a collection.
Searching Each Line for the Query
Next, we’ll check whether the current line contains our query string.
Fortunately, strings have a helpful method named contains
that does this for
us! Add a call to the contains
method in the search
function, as shown in
Listing 12-18. Note this still won’t compile yet.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
for line in contents.lines() {
if line.contains(query) {
// do something with line
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
Listing 12-18: Adding functionality to see whether the
line contains the string in query
Storing Matching Lines
We also need a way to store the lines that contain our query string. For that,
we can make a mutable vector before the for
loop and call the push
method
to store a line
in the vector. After the for
loop, we return the vector, as
shown in Listing 12-19.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
Listing 12-19: Storing the lines that match so we can return them
Now the search
function should return only the lines that contain query
,
and our test should pass. Let’s run the test:
$ cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished test [unoptimized + debuginfo] target(s) in 1.22s
Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 1 test
test tests::one_result ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests minigrep
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Our test passed, so we know it works!
At this point, we could consider opportunities for refactoring the implementation of the search function while keeping the tests passing to maintain the same functionality. The code in the search function isn’t too bad, but it doesn’t take advantage of some useful features of iterators. We’ll return to this example in Chapter 13, where we’ll explore iterators in detail, and look at how to improve it.
Using the search
Function in the run
Function
Now that the search
function is working and tested, we need to call search
from our run
function. We need to pass the config.query
value and the
contents
that run
reads from the file to the search
function. Then run
will print each line returned from search
:
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
for line in search(&config.query, &contents) {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
We’re still using a for
loop to return each line from search
and print it.
Now the entire program should work! Let’s try it out, first with a word that should return exactly one line from the Emily Dickinson poem, “frog”:
$ cargo run frog poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.38s
Running `target/debug/minigrep frog poem.txt`
How public, like a frog
Cool! Now let’s try a word that will match multiple lines, like “body”:
$ cargo run body poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep body poem.txt`
I'm nobody! Who are you?
Are you nobody, too?
How dreary to be somebody!
And finally, let’s make sure that we don’t get any lines when we search for a word that isn’t anywhere in the poem, such as “monomorphization”:
$ cargo run monomorphization poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep monomorphization poem.txt`
Excellent! We’ve built our own mini version of a classic tool and learned a lot about how to structure applications. We’ve also learned a bit about file input and output, lifetimes, testing, and command line parsing.
To round out this project, we’ll briefly demonstrate how to work with environment variables and how to print to standard error, both of which are useful when you’re writing command line programs.
Working with Environment Variables
We’ll improve minigrep
by adding an extra feature: an option for
case-insensitive searching that the user can turn on via an environment
variable. We could make this feature a command line option and require that
users enter it each time they want it to apply, but instead we’ll use an
environment variable. Doing so allows our users to set the environment variable
once and have all their searches be case insensitive in that terminal session.
Writing a Failing Test for the Case-Insensitive search
Function
We want to add a new search_case_insensitive
function that we’ll call when
the environment variable is on. We’ll continue to follow the TDD process, so
the first step is again to write a failing test. We’ll add a new test for the
new search_case_insensitive
function and rename our old test from
one_result
to case_sensitive
to clarify the differences between the two
tests, as shown in Listing 12-20.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
for line in search(&config.query, &contents) {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 12-20: Adding a new failing test for the case-insensitive function we’re about to add
Note that we’ve edited the old test’s contents
too. We’ve added a new line
with the text "Duct tape."
using a capital D that shouldn’t match the query
"duct"
when we’re searching in a case-sensitive manner. Changing the old test
in this way helps ensure that we don’t accidentally break the case-sensitive
search functionality that we’ve already implemented. This test should pass now
and should continue to pass as we work on the case-insensitive search.
The new test for the case-insensitive search uses "rUsT"
as its query. In
the search_case_insensitive
function we’re about to add, the query "rUsT"
should match the line containing "Rust:"
with a capital R and match the line
"Trust me."
even though both have different casing from the query. This is
our failing test, and it will fail to compile because we haven’t yet defined
the search_case_insensitive
function. Feel free to add a skeleton
implementation that always returns an empty vector, similar to the way we did
for the search
function in Listing 12-16 to see the test compile and fail.
Implementing the search_case_insensitive
Function
The search_case_insensitive
function, shown in Listing 12-21, will be almost
the same as the search
function. The only difference is that we’ll lowercase
the query
and each line
so whatever the case of the input arguments,
they’ll be the same case when we check whether the line contains the query.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
for line in search(&config.query, &contents) {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 12-21: Defining the search_case_insensitive
function to lowercase the query and the line before comparing them
First, we lowercase the query
string and store it in a shadowed variable with
the same name. Calling to_lowercase
on the query is necessary so no matter
whether the user’s query is "rust"
, "RUST"
, "Rust"
, or "rUsT"
, we’ll
treat the query as if it were "rust"
and be insensitive to the case. While
to_lowercase
will handle basic Unicode, it won’t be 100% accurate. If we were
writing a real application, we’d want to do a bit more work here, but this section
is about environment variables, not Unicode, so we’ll leave it at that here.
Note that query
is now a String
rather than a string slice, because calling
to_lowercase
creates new data rather than referencing existing data. Say the
query is "rUsT"
, as an example: that string slice doesn’t contain a lowercase
u
or t
for us to use, so we have to allocate a new String
containing
"rust"
. When we pass query
as an argument to the contains
method now, we
need to add an ampersand because the signature of contains
is defined to take
a string slice.
Next, we add a call to to_lowercase
on each line
before we check whether it
contains query
to lowercase all characters. Now that we’ve converted line
and query
to lowercase, we’ll find matches no matter what the case of the
query is.
Let’s see if this implementation passes the tests:
$ cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished test [unoptimized + debuginfo] target(s) in 1.33s
Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 2 tests
test tests::case_insensitive ... ok
test tests::case_sensitive ... ok
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests minigrep
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Great! They passed. Now, let’s call the new search_case_insensitive
function
from the run
function. First, we’ll add a configuration option to the
Config
struct to switch between case-sensitive and case-insensitive search.
Adding this field will cause compiler errors because we aren’t initializing
this field anywhere yet:
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Note that we added the case_sensitive
field that holds a Boolean. Next, we
need the run
function to check the case_sensitive
field’s value and use
that to decide whether to call the search
function or the
search_case_insensitive
function, as shown in Listing 12-22. Note this still
won’t compile yet.
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 12-22: Calling either search
or
search_case_insensitive
based on the value in config.case_sensitive
Finally, we need to check for the environment variable. The functions for
working with environment variables are in the env
module in the standard
library, so we want to bring that module into scope with a use std::env;
line
at the top of src/lib.rs. Then we’ll use the var
function from the env
module to check for an environment variable named CASE_INSENSITIVE
, as shown
in Listing 12-23.
Filename: src/lib.rs
use std::env;
// --snip--
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config {
query,
filename,
case_sensitive,
})
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 12-23: Checking for an environment variable named
CASE_INSENSITIVE
Here, we create a new variable case_sensitive
. To set its value, we call the
env::var
function and pass it the name of the CASE_INSENSITIVE
environment
variable. The env::var
function returns a Result
that will be the successful
Ok
variant that contains the value of the environment variable if the
environment variable is set. It will return the Err
variant if the
environment variable is not set.
We’re using the is_err
method on the Result
to check whether it’s an error
and therefore unset, which means it should do a case-sensitive search. If the
CASE_INSENSITIVE
environment variable is set to anything, is_err
will
return false and the program will perform a case-insensitive search. We don’t
care about the value of the environment variable, just whether it’s set or
unset, so we’re checking is_err
rather than using unwrap
, expect
, or any
of the other methods we’ve seen on Result
.
We pass the value in the case_sensitive
variable to the Config
instance so
the run
function can read that value and decide whether to call search
or
search_case_insensitive
, as we implemented in Listing 12-22.
Let’s give it a try! First, we’ll run our program without the environment
variable set and with the query to
, which should match any line that contains
the word “to” in all lowercase:
$ cargo run to poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep to poem.txt`
Are you nobody, too?
How dreary to be somebody!
Looks like that still works! Now, let’s run the program with CASE_INSENSITIVE
set to 1
but with the same query to
.
If you’re using PowerShell, you will need to set the environment variable and run the program as separate commands:
PS> $Env:CASE_INSENSITIVE=1; cargo run to poem.txt
This will make CASE_INSENSITIVE
persist for the remainder of your shell
session. It can be unset with the Remove-Item
cmdlet:
PS> Remove-Item Env:CASE_INSENSITIVE
We should get lines that contain “to” that might have uppercase letters:
$ CASE_INSENSITIVE=1 cargo run to poem.txt
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep to poem.txt`
Are you nobody, too?
How dreary to be somebody!
To tell your name the livelong day
To an admiring bog!
Excellent, we also got lines containing “To”! Our minigrep
program can now do
case-insensitive searching controlled by an environment variable. Now you know
how to manage options set using either command line arguments or environment
variables.
Some programs allow arguments and environment variables for the same configuration. In those cases, the programs decide that one or the other takes precedence. For another exercise on your own, try controlling case insensitivity through either a command line argument or an environment variable. Decide whether the command line argument or the environment variable should take precedence if the program is run with one set to case sensitive and one set to case insensitive.
The std::env
module contains many more useful features for dealing with
environment variables: check out its documentation to see what is available.
Writing Error Messages to Standard Error Instead of Standard Output
At the moment, we’re writing all of our output to the terminal using the
println!
macro. In most terminals, there are two kinds of output: standard
output (stdout
) for general information and standard error (stderr
) for
error messages. This distinction enables users to choose to direct the
successful output of a program to a file but still print error messages to the
screen.
The println!
macro is only capable of printing to standard output, so we
have to use something else to print to standard error.
Checking Where Errors Are Written
First, let’s observe how the content printed by minigrep
is currently being
written to standard output, including any error messages we want to write to
standard error instead. We’ll do that by redirecting the standard output stream
to a file while also intentionally causing an error. We won’t redirect the
standard error stream, so any content sent to standard error will continue to
display on the screen.
Command line programs are expected to send error messages to the standard error stream so we can still see error messages on the screen even if we redirect the standard output stream to a file. Our program is not currently well-behaved: we’re about to see that it saves the error message output to a file instead!
The way to demonstrate this behavior is by running the program with >
and the
filename, output.txt, that we want to redirect the standard output stream to.
We won’t pass any arguments, which should cause an error:
$ cargo run > output.txt
The >
syntax tells the shell to write the contents of standard output to
output.txt instead of the screen. We didn’t see the error message we were
expecting printed to the screen, so that means it must have ended up in the
file. This is what output.txt contains:
Problem parsing arguments: not enough arguments
Yup, our error message is being printed to standard output. It’s much more useful for error messages like this to be printed to standard error so only data from a successful run ends up in the file. We’ll change that.
Printing Errors to Standard Error
We’ll use the code in Listing 12-24 to change how error messages are printed.
Because of the refactoring we did earlier in this chapter, all the code that
prints error messages is in one function, main
. The standard library provides
the eprintln!
macro that prints to the standard error stream, so let’s change
the two places we were calling println!
to print errors to use eprintln!
instead.
Filename: src/main.rs
use std::env;
use std::process;
use minigrep::Config;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {}", err);
process::exit(1);
});
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {}", e);
process::exit(1);
}
}
Listing 12-24: Writing error messages to standard error
instead of standard output using eprintln!
After changing println!
to eprintln!
, let’s run the program again in the
same way, without any arguments and redirecting standard output with >
:
$ cargo run > output.txt
Problem parsing arguments: not enough arguments
Now we see the error onscreen and output.txt contains nothing, which is the behavior we expect of command line programs.
Let’s run the program again with arguments that don’t cause an error but still redirect standard output to a file, like so:
$ cargo run to poem.txt > output.txt
We won’t see any output to the terminal, and output.txt will contain our results:
Filename: output.txt
Are you nobody, too?
How dreary to be somebody!
This demonstrates that we’re now using standard output for successful output and standard error for error output as appropriate.
Summary
This chapter recapped some of the major concepts you’ve learned so far and
covered how to perform common I/O operations in Rust. By using command line
arguments, files, environment variables, and the eprintln!
macro for printing
errors, you’re now prepared to write command line applications. By using the
concepts in previous chapters, your code will be well organized, store data
effectively in the appropriate data structures, handle errors nicely, and be
well tested.
Next, we’ll explore some Rust features that were influenced by functional languages: closures and iterators.
Functional Language Features: Iterators and Closures
Rust’s design has taken inspiration from many existing languages and techniques, and one significant influence is functional programming. Programming in a functional style often includes using functions as values by passing them in arguments, returning them from other functions, assigning them to variables for later execution, and so forth.
In this chapter, we won’t debate the issue of what functional programming is or isn’t but will instead discuss some features of Rust that are similar to features in many languages often referred to as functional.
More specifically, we’ll cover:
- Closures, a function-like construct you can store in a variable
- Iterators, a way of processing a series of elements
- How to use these two features to improve the I/O project in Chapter 12
- The performance of these two features (Spoiler alert: they’re faster than you might think!)
Other Rust features, such as pattern matching and enums, which we’ve covered in other chapters, are influenced by the functional style as well. Mastering closures and iterators is an important part of writing idiomatic, fast Rust code, so we’ll devote this entire chapter to them.
Closures: Anonymous Functions that Can Capture Their Environment
Rust’s closures are anonymous functions you can save in a variable or pass as arguments to other functions. You can create the closure in one place and then call the closure to evaluate it in a different context. Unlike functions, closures can capture values from the scope in which they’re defined. We’ll demonstrate how these closure features allow for code reuse and behavior customization.
Creating an Abstraction of Behavior with Closures
Let’s work on an example of a situation in which it’s useful to store a closure to be executed later. Along the way, we’ll talk about the syntax of closures, type inference, and traits.
Consider this hypothetical situation: we work at a startup that’s making an app to generate custom exercise workout plans. The backend is written in Rust, and the algorithm that generates the workout plan takes into account many factors, such as the app user’s age, body mass index, exercise preferences, recent workouts, and an intensity number they specify. The actual algorithm used isn’t important in this example; what’s important is that this calculation takes a few seconds. We want to call this algorithm only when we need to and only call it once so we don’t make the user wait more than necessary.
We’ll simulate calling this hypothetical algorithm with the function
simulated_expensive_calculation
shown in Listing 13-1, which will print
calculating slowly...
, wait for two seconds, and then return whatever number
we passed in.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn simulated_expensive_calculation(intensity: u32) -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); intensity } fn main() {}
Listing 13-1: A function to stand in for a hypothetical calculation that takes about 2 seconds to run
Next is the main
function, which contains the parts of the workout app
important for this example. This function represents the code that the app will
call when a user asks for a workout plan. Because the interaction with the
app’s frontend isn’t relevant to the use of closures, we’ll hardcode values
representing inputs to our program and print the outputs.
The required inputs are these:
- An intensity number from the user, which is specified when they request a workout to indicate whether they want a low-intensity workout or a high-intensity workout
- A random number that will generate some variety in the workout plans
The output will be the recommended workout plan. Listing 13-2 shows the main
function we’ll use.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn simulated_expensive_calculation(intensity: u32) -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); intensity } fn generate_workout(intensity: u32, random_number: u32) {} fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-2: A main
function with hardcoded values to
simulate user input and random number generation
We’ve hardcoded the variable simulated_user_specified_value
as 10 and the
variable simulated_random_number
as 7 for simplicity’s sake; in an actual
program, we’d get the intensity number from the app frontend, and we’d use the
rand
crate to generate a random number, as we did in the Guessing Game
example in Chapter 2. The main
function calls a generate_workout
function
with the simulated input values.
Now that we have the context, let’s get to the algorithm. The function
generate_workout
in Listing 13-3 contains the business logic of the
app that we’re most concerned with in this example. The rest of the code
changes in this example will be made to this function.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn simulated_expensive_calculation(intensity: u32) -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); intensity } fn generate_workout(intensity: u32, random_number: u32) { if intensity < 25 { println!( "Today, do {} pushups!", simulated_expensive_calculation(intensity) ); println!( "Next, do {} situps!", simulated_expensive_calculation(intensity) ); } else { if random_number == 3 { println!("Take a break today! Remember to stay hydrated!"); } else { println!( "Today, run for {} minutes!", simulated_expensive_calculation(intensity) ); } } } fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-3: The business logic that prints the workout
plans based on the inputs and calls to the simulated_expensive_calculation
function
The code in Listing 13-3 has multiple calls to the slow calculation function.
The first if
block calls simulated_expensive_calculation
twice, the if
inside the outer else
doesn’t call it at all, and the code inside the
second else
case calls it once.
The desired behavior of the generate_workout
function is to first check
whether the user wants a low-intensity workout (indicated by a number less than
25) or a high-intensity workout (a number of 25 or greater).
Low-intensity workout plans will recommend a number of push-ups and sit-ups based on the complex algorithm we’re simulating.
If the user wants a high-intensity workout, there’s some additional logic: if the value of the random number generated by the app happens to be 3, the app will recommend a break and hydration. If not, the user will get a number of minutes of running based on the complex algorithm.
This code works the way the business wants it to now, but let’s say the data
science team decides that we need to make some changes to the way we call the
simulated_expensive_calculation
function in the future. To simplify the
update when those changes happen, we want to refactor this code so it calls the
simulated_expensive_calculation
function only once. We also want to cut the
place where we’re currently unnecessarily calling the function twice without
adding any other calls to that function in the process. That is, we don’t want
to call it if the result isn’t needed, and we still want to call it only once.
Refactoring Using Functions
We could restructure the workout program in many ways. First, we’ll try
extracting the duplicated call to the simulated_expensive_calculation
function into a variable, as shown in Listing 13-4.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn simulated_expensive_calculation(intensity: u32) -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); intensity } fn generate_workout(intensity: u32, random_number: u32) { let expensive_result = simulated_expensive_calculation(intensity); if intensity < 25 { println!("Today, do {} pushups!", expensive_result); println!("Next, do {} situps!", expensive_result); } else { if random_number == 3 { println!("Take a break today! Remember to stay hydrated!"); } else { println!("Today, run for {} minutes!", expensive_result); } } } fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-4: Extracting the calls to
simulated_expensive_calculation
to one place and storing the result in the
expensive_result
variable
This change unifies all the calls to simulated_expensive_calculation
and
solves the problem of the first if
block unnecessarily calling the function
twice. Unfortunately, we’re now calling this function and waiting for the
result in all cases, which includes the inner if
block that doesn’t use the
result value at all.
We want to refer to simulated_expensive_calculation
only once in
generate_workout
, but defer the expensive calculation to only where
we actually need the result. This is a use case for closures!
Refactoring with Closures to Store Code
Instead of always calling the simulated_expensive_calculation
function before
the if
blocks, we can define a closure and store the closure in a variable
rather than storing the result of the function call, as shown in Listing 13-5.
We can actually move the whole body of simulated_expensive_calculation
within
the closure we’re introducing here.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn generate_workout(intensity: u32, random_number: u32) { let expensive_closure = |num| { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); num }; if intensity < 25 { println!("Today, do {} pushups!", expensive_closure(intensity)); println!("Next, do {} situps!", expensive_closure(intensity)); } else { if random_number == 3 { println!("Take a break today! Remember to stay hydrated!"); } else { println!( "Today, run for {} minutes!", expensive_closure(intensity) ); } } } fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-5: Defining a closure and storing it in the
expensive_closure
variable
The closure definition comes after the =
to assign it to the variable
expensive_closure
. To define a closure, we start with a pair of vertical
pipes (|
), inside which we specify the parameters to the closure; this syntax
was chosen because of its similarity to closure definitions in Smalltalk and
Ruby. This closure has one parameter named num
: if we had more than one
parameter, we would separate them with commas, like |param1, param2|
.
After the parameters, we place curly brackets that hold the body of the
closure—these are optional if the closure body is a single expression. The end
of the closure, after the curly brackets, needs a semicolon to complete the
let
statement. The value returned from the last line in the closure body
(num
) will be the value returned from the closure when it’s called, because
that line doesn’t end in a semicolon; just as in function bodies.
Note that this let
statement means expensive_closure
contains the
definition of an anonymous function, not the resulting value of calling the
anonymous function. Recall that we’re using a closure because we want to define
the code to call at one point, store that code, and call it at a later point;
the code we want to call is now stored in expensive_closure
.
With the closure defined, we can change the code in the if
blocks to call the
closure to execute the code and get the resulting value. We call a closure like
we do a function: we specify the variable name that holds the closure
definition and follow it with parentheses containing the argument values we
want to use, as shown in Listing 13-6.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn generate_workout(intensity: u32, random_number: u32) { let expensive_closure = |num| { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); num }; if intensity < 25 { println!("Today, do {} pushups!", expensive_closure(intensity)); println!("Next, do {} situps!", expensive_closure(intensity)); } else { if random_number == 3 { println!("Take a break today! Remember to stay hydrated!"); } else { println!( "Today, run for {} minutes!", expensive_closure(intensity) ); } } } fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-6: Calling the expensive_closure
we’ve
defined
Now how to perform the expensive calculation is defined in only one place, and we’re only executing that code where we need the results.
However, we’ve reintroduced one of the problems from Listing 13-3: we’re still
calling the closure twice in the first if
block, which will call the
expensive code twice and make the user wait twice as long as they need to. We
could fix this problem by creating a variable local to that if
block to hold
the result of calling the closure, but closures provide us with another
solution. We’ll talk about that solution in a bit. But first let’s talk about
why there aren’t type annotations in the closure definition and the traits
involved with closures.
Closure Type Inference and Annotation
Closures don’t require you to annotate the types of the parameters or the
return value like fn
functions do. Type annotations are required on functions
because they’re part of an explicit interface exposed to your users. Defining
this interface rigidly is important for ensuring that everyone agrees on what
types of values a function uses and returns. But closures aren’t used in an
exposed interface like this: they’re stored in variables and used without
naming them and exposing them to users of our library.
Closures are usually short and relevant only within a narrow context rather than in any arbitrary scenario. Within these limited contexts, the compiler is reliably able to infer the types of the parameters and the return type, similar to how it’s able to infer the types of most variables.
Making programmers annotate the types in these small, anonymous functions would be annoying and largely redundant with the information the compiler already has available.
As with variables, we can add type annotations if we want to increase explicitness and clarity at the cost of being more verbose than is strictly necessary. Annotating the types for the closure we defined in Listing 13-5 would look like the definition shown in Listing 13-7.
Filename: src/main.rs
use std::thread; use std::time::Duration; fn generate_workout(intensity: u32, random_number: u32) { let expensive_closure = |num: u32| -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); num }; if intensity < 25 { println!("Today, do {} pushups!", expensive_closure(intensity)); println!("Next, do {} situps!", expensive_closure(intensity)); } else { if random_number == 3 { println!("Take a break today! Remember to stay hydrated!"); } else { println!( "Today, run for {} minutes!", expensive_closure(intensity) ); } } } fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-7: Adding optional type annotations of the parameter and return value types in the closure
With type annotations added, the syntax of closures looks more similar to the syntax of functions. The following is a vertical comparison of the syntax for the definition of a function that adds 1 to its parameter and a closure that has the same behavior. We’ve added some spaces to line up the relevant parts. This illustrates how closure syntax is similar to function syntax except for the use of pipes and the amount of syntax that is optional:
fn add_one_v1 (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x| { x + 1 };
let add_one_v4 = |x| x + 1 ;
The first line shows a function definition, and the second line shows a fully
annotated closure definition. The third line removes the type annotations from
the closure definition, and the fourth line removes the brackets, which are
optional because the closure body has only one expression. These are all valid
definitions that will produce the same behavior when they’re called. Calling
the closures is required for add_one_v3
and add_one_v4
to be able to
compile because the types will be inferred from their usage.
Closure definitions will have one concrete type inferred for each of their
parameters and for their return value. For instance, Listing 13-8 shows the
definition of a short closure that just returns the value it receives as a
parameter. This closure isn’t very useful except for the purposes of this
example. Note that we haven’t added any type annotations to the definition: if
we then try to call the closure twice, using a String
as an argument the
first time and a u32
the second time, we’ll get an error.
Filename: src/main.rs
fn main() {
let example_closure = |x| x;
let s = example_closure(String::from("hello"));
let n = example_closure(5);
}
Listing 13-8: Attempting to call a closure whose types are inferred with two different types
The compiler gives us this error:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
error[E0308]: mismatched types
--> src/main.rs:5:29
|
5 | let n = example_closure(5);
| ^- help: try using a conversion method: `.to_string()`
| |
| expected struct `String`, found integer
For more information about this error, try `rustc --explain E0308`.
error: could not compile `closure-example` due to previous error
The first time we call example_closure
with the String
value, the compiler
infers the type of x
and the return type of the closure to be String
. Those
types are then locked into the closure in example_closure
, and we get a type
error if we try to use a different type with the same closure.
Storing Closures Using Generic Parameters and the Fn
Traits
Let’s return to our workout generation app. In Listing 13-6, our code was still calling the expensive calculation closure more times than it needed to. One option to solve this issue is to save the result of the expensive closure in a variable for reuse and use the variable in each place we need the result, instead of calling the closure again. However, this method could result in a lot of repeated code.
Fortunately, another solution is available to us. We can create a struct that will hold the closure and the resulting value of calling the closure. The struct will execute the closure only if we need the resulting value, and it will cache the resulting value so the rest of our code doesn’t have to be responsible for saving and reusing the result. You may know this pattern as memoization or lazy evaluation.
To make a struct that holds a closure, we need to specify the type of the closure, because a struct definition needs to know the types of each of its fields. Each closure instance has its own unique anonymous type: that is, even if two closures have the same signature, their types are still considered different. To define structs, enums, or function parameters that use closures, we use generics and trait bounds, as we discussed in Chapter 10.
The Fn
traits are provided by the standard library. All closures implement at
least one of the traits: Fn
, FnMut
, or FnOnce
. We’ll discuss the
difference between these traits in the “Capturing the Environment with
Closures” section; in
this example, we can use the Fn
trait.
We add types to the Fn
trait bound to represent the types of the parameters
and return values the closures must have to match this trait bound. In this
case, our closure has a parameter of type u32
and returns a u32
, so the
trait bound we specify is Fn(u32) -> u32
.
Listing 13-9 shows the definition of the Cacher
struct that holds a closure
and an optional result value.
Filename: src/main.rs
struct Cacher<T> where T: Fn(u32) -> u32, { calculation: T, value: Option<u32>, } fn main() {}
Listing 13-9: Defining a Cacher
struct that holds a
closure in calculation
and an optional result in value
The Cacher
struct has a calculation
field of the generic type T
. The
trait bounds on T
specify that it’s a closure by using the Fn
trait. Any
closure we want to store in the calculation
field must have one u32
parameter (specified within the parentheses after Fn
) and must return a
u32
(specified after the ->
).
Note: Functions can implement all three of the
Fn
traits too. If what we want to do doesn’t require capturing a value from the environment, we can use a function rather than a closure where we need something that implements anFn
trait.
The value
field is of type Option<u32>
. Before we execute the closure,
value
will be None
. When code using a Cacher
asks for the result of the
closure, the Cacher
will execute the closure at that time and store the
result within a Some
variant in the value
field. Then if the code asks for
the result of the closure again, instead of executing the closure again, the
Cacher
will return the result held in the Some
variant.
The logic around the value
field we’ve just described is defined in Listing
13-10.
Filename: src/main.rs
struct Cacher<T> where T: Fn(u32) -> u32, { calculation: T, value: Option<u32>, } impl<T> Cacher<T> where T: Fn(u32) -> u32, { fn new(calculation: T) -> Cacher<T> { Cacher { calculation, value: None, } } fn value(&mut self, arg: u32) -> u32 { match self.value { Some(v) => v, None => { let v = (self.calculation)(arg); self.value = Some(v); v } } } } fn main() {}
Listing 13-10: The caching logic of Cacher
We want Cacher
to manage the struct fields’ values rather than letting the
calling code potentially change the values in these fields directly, so these
fields are private.
The Cacher::new
function takes a generic parameter T
, which we’ve defined
as having the same trait bound as the Cacher
struct. Then Cacher::new
returns a Cacher
instance that holds the closure specified in the
calculation
field and a None
value in the value
field, because we haven’t
executed the closure yet.
When the calling code needs the result of evaluating the closure, instead of
calling the closure directly, it will call the value
method. This method
checks whether we already have a resulting value in self.value
in a Some
;
if we do, it returns the value within the Some
without executing the closure
again.
If self.value
is None
, the code calls the closure stored in
self.calculation
, saves the result in self.value
for future use, and
returns the value as well.
Listing 13-11 shows how we can use this Cacher
struct in the function
generate_workout
from Listing 13-6.
Filename: src/main.rs
use std::thread; use std::time::Duration; struct Cacher<T> where T: Fn(u32) -> u32, { calculation: T, value: Option<u32>, } impl<T> Cacher<T> where T: Fn(u32) -> u32, { fn new(calculation: T) -> Cacher<T> { Cacher { calculation, value: None, } } fn value(&mut self, arg: u32) -> u32 { match self.value { Some(v) => v, None => { let v = (self.calculation)(arg); self.value = Some(v); v } } } } fn generate_workout(intensity: u32, random_number: u32) { let mut expensive_result = Cacher::new(|num| { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); num }); if intensity < 25 { println!("Today, do {} pushups!", expensive_result.value(intensity)); println!("Next, do {} situps!", expensive_result.value(intensity)); } else { if random_number == 3 { println!("Take a break today! Remember to stay hydrated!"); } else { println!( "Today, run for {} minutes!", expensive_result.value(intensity) ); } } } fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; generate_workout(simulated_user_specified_value, simulated_random_number); }
Listing 13-11: Using Cacher
in the generate_workout
function to abstract away the caching logic
Instead of saving the closure in a variable directly, we save a new instance of
Cacher
that holds the closure. Then, in each place we want the result, we
call the value
method on the Cacher
instance. We can call the value
method as many times as we want, or not call it at all, and the expensive
calculation will be run a maximum of once.
Try running this program with the main
function from Listing 13-2. Change the
values in the simulated_user_specified_value
and simulated_random_number
variables to verify that in all the cases in the various if
and else
blocks, calculating slowly...
appears only once and only when needed. The
Cacher
takes care of the logic necessary to ensure we aren’t calling the
expensive calculation more than we need to so generate_workout
can focus on
the business logic.
Limitations of the Cacher
Implementation
Caching values is a generally useful behavior that we might want to use in
other parts of our code with different closures. However, there are two
problems with the current implementation of Cacher
that would make reusing it
in different contexts difficult.
The first problem is that a Cacher
instance assumes it will always get the
same value for the parameter arg
to the value
method. That is, this test of
Cacher
will fail:
struct Cacher<T>
where
T: Fn(u32) -> u32,
{
calculation: T,
value: Option<u32>,
}
impl<T> Cacher<T>
where
T: Fn(u32) -> u32,
{
fn new(calculation: T) -> Cacher<T> {
Cacher {
calculation,
value: None,
}
}
fn value(&mut self, arg: u32) -> u32 {
match self.value {
Some(v) => v,
None => {
let v = (self.calculation)(arg);
self.value = Some(v);
v
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn call_with_different_values() {
let mut c = Cacher::new(|a| a);
let v1 = c.value(1);
let v2 = c.value(2);
assert_eq!(v2, 2);
}
}
This test creates a new Cacher
instance with a closure that returns the value
passed into it. We call the value
method on this Cacher
instance with an
arg
value of 1 and then an arg
value of 2, and we expect the call to
value
with the arg
value of 2 to return 2.
Run this test with the Cacher
implementation in Listing 13-9 and Listing
13-10, and the test will fail on the assert_eq!
with this message:
$ cargo test
Compiling cacher v0.1.0 (file:///projects/cacher)
Finished test [unoptimized + debuginfo] target(s) in 0.72s
Running unittests (target/debug/deps/cacher-074d7c200c000afa)
running 1 test
test tests::call_with_different_values ... FAILED
failures:
---- tests::call_with_different_values stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
left: `1`,
right: `2`', src/lib.rs:43:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::call_with_different_values
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
The problem is that the first time we called c.value
with 1, the Cacher
instance saved Some(1)
in self.value
. Thereafter, no matter what we pass into
the value
method, it will always return 1.
Try modifying Cacher
to hold a hash map rather than a single value. The keys
of the hash map will be the arg
values that are passed in, and the values of
the hash map will be the result of calling the closure on that key. Instead of
looking at whether self.value
directly has a Some
or a None
value, the
value
function will look up the arg
in the hash map and return the value if
it’s present. If it’s not present, the Cacher
will call the closure and save
the resulting value in the hash map associated with its arg
value.
The second problem with the current Cacher
implementation is that it only
accepts closures that take one parameter of type u32
and return a u32
. We
might want to cache the results of closures that take a string slice and return
usize
values, for example. To fix this issue, try introducing more generic
parameters to increase the flexibility of the Cacher
functionality.
Capturing the Environment with Closures
In the workout generator example, we only used closures as inline anonymous functions. However, closures have an additional capability that functions don’t have: they can capture their environment and access variables from the scope in which they’re defined.
Listing 13-12 has an example of a closure stored in the equal_to_x
variable
that uses the x
variable from the closure’s surrounding environment.
Filename: src/main.rs
fn main() { let x = 4; let equal_to_x = |z| z == x; let y = 4; assert!(equal_to_x(y)); }
Listing 13-12: Example of a closure that refers to a variable in its enclosing scope
Here, even though x
is not one of the parameters of equal_to_x
, the
equal_to_x
closure is allowed to use the x
variable that’s defined in the
same scope that equal_to_x
is defined in.
We can’t do the same with functions; if we try with the following example, our code won’t compile:
Filename: src/main.rs
fn main() {
let x = 4;
fn equal_to_x(z: i32) -> bool {
z == x
}
let y = 4;
assert!(equal_to_x(y));
}
We get an error:
$ cargo run
Compiling equal-to-x v0.1.0 (file:///projects/equal-to-x)
error[E0434]: can't capture dynamic environment in a fn item
--> src/main.rs:5:14
|
5 | z == x
| ^
|
= help: use the `|| { ... }` closure form instead
For more information about this error, try `rustc --explain E0434`.
error: could not compile `equal-to-x` due to previous error
The compiler even reminds us that this only works with closures!
When a closure captures a value from its environment, it uses memory to store the values for use in the closure body. This use of memory is overhead that we don’t want to pay in more common cases where we want to execute code that doesn’t capture its environment. Because functions are never allowed to capture their environment, defining and using functions will never incur this overhead.
Closures can capture values from their environment in three ways, which
directly map to the three ways a function can take a parameter: taking
ownership, borrowing mutably, and borrowing immutably. These are encoded in the
three Fn
traits as follows:
FnOnce
consumes the variables it captures from its enclosing scope, known as the closure’s environment. To consume the captured variables, the closure must take ownership of these variables and move them into the closure when it is defined. TheOnce
part of the name represents the fact that the closure can’t take ownership of the same variables more than once, so it can be called only once.FnMut
can change the environment because it mutably borrows values.Fn
borrows values from the environment immutably.
When you create a closure, Rust infers which trait to use based on how the
closure uses the values from the environment. All closures implement FnOnce
because they can all be called at least once. Closures that don’t move the
captured variables also implement FnMut
, and closures that don’t need mutable
access to the captured variables also implement Fn
. In Listing 13-12, the
equal_to_x
closure borrows x
immutably (so equal_to_x
has the Fn
trait)
because the body of the closure only needs to read the value in x
.
If you want to force the closure to take ownership of the values it uses in the
environment, you can use the move
keyword before the parameter list. This
technique is mostly useful when passing a closure to a new thread to move the
data so it’s owned by the new thread.
Note:
move
closures may still implementFn
orFnMut
, even though they capture variables by move. This is because the traits implemented by a closure type are determined by what the closure does with captured values, not how it captures them. Themove
keyword only specifies the latter.
We’ll have more examples of move
closures in Chapter 16 when we talk about
concurrency. For now, here’s the code from Listing 13-12 with the move
keyword added to the closure definition and using vectors instead of integers,
because integers can be copied rather than moved; note that this code will not
yet compile.
Filename: src/main.rs
fn main() {
let x = vec![1, 2, 3];
let equal_to_x = move |z| z == x;
println!("can't use x here: {:?}", x);
let y = vec![1, 2, 3];
assert!(equal_to_x(y));
}
We receive the following error:
$ cargo run
Compiling equal-to-x v0.1.0 (file:///projects/equal-to-x)
error[E0382]: borrow of moved value: `x`
--> src/main.rs:6:40
|
2 | let x = vec![1, 2, 3];
| - move occurs because `x` has type `Vec<i32>`, which does not implement the `Copy` trait
3 |
4 | let equal_to_x = move |z| z == x;
| -------- - variable moved due to use in closure
| |
| value moved into closure here
5 |
6 | println!("can't use x here: {:?}", x);
| ^ value borrowed here after move
|
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0382`.
error: could not compile `equal-to-x` due to previous error
The x
value is moved into the closure when the closure is defined, because we
added the move
keyword. The closure then has ownership of x
, and main
isn’t allowed to use x
anymore in the println!
statement. Removing
println!
will fix this example.
Most of the time when specifying one of the Fn
trait bounds, you can start
with Fn
and the compiler will tell you if you need FnMut
or FnOnce
based
on what happens in the closure body.
To illustrate situations where closures that can capture their environment are useful as function parameters, let’s move on to our next topic: iterators.
Processing a Series of Items with Iterators
The iterator pattern allows you to perform some task on a sequence of items in turn. An iterator is responsible for the logic of iterating over each item and determining when the sequence has finished. When you use iterators, you don’t have to reimplement that logic yourself.
In Rust, iterators are lazy, meaning they have no effect until you call
methods that consume the iterator to use it up. For example, the code in
Listing 13-13 creates an iterator over the items in the vector v1
by calling
the iter
method defined on Vec<T>
. This code by itself doesn’t do anything
useful.
fn main() { let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); }
Listing 13-13: Creating an iterator
Once we’ve created an iterator, we can use it in a variety of ways. In Listing
3-5 in Chapter 3, we iterated over an array using a for
loop to execute some
code on each of its items. Under the hood this implicitly created and then
consumed an iterator, but we glossed over how exactly that works until now.
The example in Listing 13-14 separates the creation of the iterator from the
use of the iterator in the for
loop. The iterator is stored in the v1_iter
variable, and no iteration takes place at that time. When the for
loop is
called using the iterator in v1_iter
, each element in the iterator is used in
one iteration of the loop, which prints out each value.
fn main() { let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); for val in v1_iter { println!("Got: {}", val); } }
Listing 13-14: Using an iterator in a for
loop
In languages that don’t have iterators provided by their standard libraries, you would likely write this same functionality by starting a variable at index 0, using that variable to index into the vector to get a value, and incrementing the variable value in a loop until it reached the total number of items in the vector.
Iterators handle all that logic for you, cutting down on repetitive code you could potentially mess up. Iterators give you more flexibility to use the same logic with many different kinds of sequences, not just data structures you can index into, like vectors. Let’s examine how iterators do that.
The Iterator
Trait and the next
Method
All iterators implement a trait named Iterator
that is defined in the
standard library. The definition of the trait looks like this:
#![allow(unused)] fn main() { pub trait Iterator { type Item; fn next(&mut self) -> Option<Self::Item>; // methods with default implementations elided } }
Notice this definition uses some new syntax: type Item
and Self::Item
,
which are defining an associated type with this trait. We’ll talk about
associated types in depth in Chapter 19. For now, all you need to know is that
this code says implementing the Iterator
trait requires that you also define
an Item
type, and this Item
type is used in the return type of the next
method. In other words, the Item
type will be the type returned from the
iterator.
The Iterator
trait only requires implementors to define one method: the
next
method, which returns one item of the iterator at a time wrapped in
Some
and, when iteration is over, returns None
.
We can call the next
method on iterators directly; Listing 13-15 demonstrates
what values are returned from repeated calls to next
on the iterator created
from the vector.
Filename: src/lib.rs
#[cfg(test)]
mod tests {
#[test]
fn iterator_demonstration() {
let v1 = vec![1, 2, 3];
let mut v1_iter = v1.iter();
assert_eq!(v1_iter.next(), Some(&1));
assert_eq!(v1_iter.next(), Some(&2));
assert_eq!(v1_iter.next(), Some(&3));
assert_eq!(v1_iter.next(), None);
}
}
Listing 13-15: Calling the next
method on an
iterator
Note that we needed to make v1_iter
mutable: calling the next
method on an
iterator changes internal state that the iterator uses to keep track of where
it is in the sequence. In other words, this code consumes, or uses up, the
iterator. Each call to next
eats up an item from the iterator. We didn’t need
to make v1_iter
mutable when we used a for
loop because the loop took
ownership of v1_iter
and made it mutable behind the scenes.
Also note that the values we get from the calls to next
are immutable
references to the values in the vector. The iter
method produces an iterator
over immutable references. If we want to create an iterator that takes
ownership of v1
and returns owned values, we can call into_iter
instead of
iter
. Similarly, if we want to iterate over mutable references, we can call
iter_mut
instead of iter
.
Methods that Consume the Iterator
The Iterator
trait has a number of different methods with default
implementations provided by the standard library; you can find out about these
methods by looking in the standard library API documentation for the Iterator
trait. Some of these methods call the next
method in their definition, which
is why you’re required to implement the next
method when implementing the
Iterator
trait.
Methods that call next
are called consuming adaptors, because calling them
uses up the iterator. One example is the sum
method, which takes ownership of
the iterator and iterates through the items by repeatedly calling next
, thus
consuming the iterator. As it iterates through, it adds each item to a running
total and returns the total when iteration is complete. Listing 13-16 has a
test illustrating a use of the sum
method:
Filename: src/lib.rs
#[cfg(test)]
mod tests {
#[test]
fn iterator_sum() {
let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();
let total: i32 = v1_iter.sum();
assert_eq!(total, 6);
}
}
Listing 13-16: Calling the sum
method to get the total
of all items in the iterator
We aren’t allowed to use v1_iter
after the call to sum
because sum
takes
ownership of the iterator we call it on.
Methods that Produce Other Iterators
Other methods defined on the Iterator
trait, known as iterator adaptors,
allow you to change iterators into different kinds of iterators. You can chain
multiple calls to iterator adaptors to perform complex actions in a readable
way. But because all iterators are lazy, you have to call one of the consuming
adaptor methods to get results from calls to iterator adaptors.
Listing 13-17 shows an example of calling the iterator adaptor method map
,
which takes a closure to call on each item to produce a new iterator. The
closure here creates a new iterator in which each item from the vector has been
incremented by 1. However, this code produces a warning:
Filename: src/main.rs
fn main() { let v1: Vec<i32> = vec![1, 2, 3]; v1.iter().map(|x| x + 1); }
Listing 13-17: Calling the iterator adaptor map
to
create a new iterator
The warning we get is this:
$ cargo run
Compiling iterators v0.1.0 (file:///projects/iterators)
warning: unused `Map` that must be used
--> src/main.rs:4:5
|
4 | v1.iter().map(|x| x + 1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: iterators are lazy and do nothing unless consumed
warning: `iterators` (bin "iterators") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 0.47s
Running `target/debug/iterators`
The code in Listing 13-17 doesn’t do anything; the closure we’ve specified never gets called. The warning reminds us why: iterator adaptors are lazy, and we need to consume the iterator here.
To fix this and consume the iterator, we’ll use the collect
method, which we
used in Chapter 12 with env::args
in Listing 12-1. This method consumes the
iterator and collects the resulting values into a collection data type.
In Listing 13-18, we collect the results of iterating over the iterator that’s
returned from the call to map
into a vector. This vector will end up
containing each item from the original vector incremented by 1.
Filename: src/main.rs
fn main() { let v1: Vec<i32> = vec![1, 2, 3]; let v2: Vec<_> = v1.iter().map(|x| x + 1).collect(); assert_eq!(v2, vec![2, 3, 4]); }
Listing 13-18: Calling the map
method to create a new
iterator and then calling the collect
method to consume the new iterator and
create a vector
Because map
takes a closure, we can specify any operation we want to perform
on each item. This is a great example of how closures let you customize some
behavior while reusing the iteration behavior that the Iterator
trait
provides.
Using Closures that Capture Their Environment
Now that we’ve introduced iterators, we can demonstrate a common use of
closures that capture their environment by using the filter
iterator adaptor.
The filter
method on an iterator takes a closure that takes each item from
the iterator and returns a Boolean. If the closure returns true
, the value
will be included in the iterator produced by filter
. If the closure returns
false
, the value won’t be included in the resulting iterator.
In Listing 13-19, we use filter
with a closure that captures the shoe_size
variable from its environment to iterate over a collection of Shoe
struct
instances. It will return only shoes that are the specified size.
Filename: src/lib.rs
#[derive(PartialEq, Debug)]
struct Shoe {
size: u32,
style: String,
}
fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn filters_by_size() {
let shoes = vec![
Shoe {
size: 10,
style: String::from("sneaker"),
},
Shoe {
size: 13,
style: String::from("sandal"),
},
Shoe {
size: 10,
style: String::from("boot"),
},
];
let in_my_size = shoes_in_size(shoes, 10);
assert_eq!(
in_my_size,
vec![
Shoe {
size: 10,
style: String::from("sneaker")
},
Shoe {
size: 10,
style: String::from("boot")
},
]
);
}
}
Listing 13-19: Using the filter
method with a closure
that captures shoe_size
The shoes_in_size
function takes ownership of a vector of shoes and a shoe
size as parameters. It returns a vector containing only shoes of the specified
size.
In the body of shoes_in_size
, we call into_iter
to create an iterator
that takes ownership of the vector. Then we call filter
to adapt that
iterator into a new iterator that only contains elements for which the closure
returns true
.
The closure captures the shoe_size
parameter from the environment and
compares the value with each shoe’s size, keeping only shoes of the size
specified. Finally, calling collect
gathers the values returned by the
adapted iterator into a vector that’s returned by the function.
The test shows that when we call shoes_in_size
, we get back only shoes
that have the same size as the value we specified.
Creating Our Own Iterators with the Iterator
Trait
We’ve shown that you can create an iterator by calling iter
, into_iter
, or
iter_mut
on a vector. You can create iterators from the other collection
types in the standard library, such as hash map. You can also create iterators
that do anything you want by implementing the Iterator
trait on your own
types. As previously mentioned, the only method you’re required to provide a
definition for is the next
method. Once you’ve done that, you can use all
other methods that have default implementations provided by the Iterator
trait!
To demonstrate, let’s create an iterator that will only ever count from 1 to 5.
First, we’ll create a struct to hold some values. Then we’ll make this struct
into an iterator by implementing the Iterator
trait and using the values in
that implementation.
Listing 13-20 has the definition of the Counter
struct and an associated
new
function to create instances of Counter
:
Filename: src/lib.rs
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
Listing 13-20: Defining the Counter
struct and a new
function that creates instances of Counter
with an initial value of 0 for
count
The Counter
struct has one field named count
. This field holds a u32
value that will keep track of where we are in the process of iterating from 1
to 5. The count
field is private because we want the implementation of
Counter
to manage its value. The new
function enforces the behavior of
always starting new instances with a value of 0 in the count
field.
Next, we’ll implement the Iterator
trait for our Counter
type by defining
the body of the next
method to specify what we want to happen when this
iterator is used, as shown in Listing 13-21:
Filename: src/lib.rs
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
Listing 13-21: Implementing the Iterator
trait on our
Counter
struct
We set the associated Item
type for our iterator to u32
, meaning the
iterator will return u32
values. Again, don’t worry about associated types
yet, we’ll cover them in Chapter 19.
We want our iterator to add 1 to the current state, so we initialized count
to 0 so it would return 1 first. If the value of count
is less than 5, next
will increment count
and return the current value wrapped in Some
. Once
count
is 5, our iterator will stop incrementing count
and always return
None
.
Using Our Counter
Iterator’s next
Method
Once we’ve implemented the Iterator
trait, we have an iterator! Listing 13-22
shows a test demonstrating that we can use the iterator functionality of our
Counter
struct by calling the next
method on it directly, just as we did
with the iterator created from a vector in Listing 13-15.
Filename: src/lib.rs
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn calling_next_directly() {
let mut counter = Counter::new();
assert_eq!(counter.next(), Some(1));
assert_eq!(counter.next(), Some(2));
assert_eq!(counter.next(), Some(3));
assert_eq!(counter.next(), Some(4));
assert_eq!(counter.next(), Some(5));
assert_eq!(counter.next(), None);
}
}
Listing 13-22: Testing the functionality of the next
method implementation
This test creates a new Counter
instance in the counter
variable and then
calls next
repeatedly, verifying that we have implemented the behavior we
want this iterator to have: returning the values from 1 to 5.
Using Other Iterator
Trait Methods
We implemented the Iterator
trait by defining the next
method, so we
can now use any Iterator
trait method’s default implementations as defined in
the standard library, because they all use the next
method’s functionality.
For example, if for some reason we wanted to take the values produced by an
instance of Counter
, pair them with values produced by another Counter
instance after skipping the first value, multiply each pair together, keep only
those results that are divisible by 3, and add all the resulting values
together, we could do so, as shown in the test in Listing 13-23:
Filename: src/lib.rs
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn calling_next_directly() {
let mut counter = Counter::new();
assert_eq!(counter.next(), Some(1));
assert_eq!(counter.next(), Some(2));
assert_eq!(counter.next(), Some(3));
assert_eq!(counter.next(), Some(4));
assert_eq!(counter.next(), Some(5));
assert_eq!(counter.next(), None);
}
#[test]
fn using_other_iterator_trait_methods() {
let sum: u32 = Counter::new()
.zip(Counter::new().skip(1))
.map(|(a, b)| a * b)
.filter(|x| x % 3 == 0)
.sum();
assert_eq!(18, sum);
}
}
Listing 13-23: Using a variety of Iterator
trait
methods on our Counter
iterator
Note that zip
produces only four pairs; the theoretical fifth pair (5, None)
is never produced because zip
returns None
when either of its input
iterators return None
.
All of these method calls are possible because we specified how the next
method works, and the standard library provides default implementations for
other methods that call next
.
Improving Our I/O Project
With this new knowledge about iterators, we can improve the I/O project in
Chapter 12 by using iterators to make places in the code clearer and more
concise. Let’s look at how iterators can improve our implementation of the
Config::new
function and the search
function.
Removing a clone
Using an Iterator
In Listing 12-6, we added code that took a slice of String
values and created
an instance of the Config
struct by indexing into the slice and cloning the
values, allowing the Config
struct to own those values. In Listing 13-24,
we’ve reproduced the implementation of the Config::new
function as it was in
Listing 12-23:
Filename: src/lib.rs
use std::env;
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config {
query,
filename,
case_sensitive,
})
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 13-24: Reproduction of the Config::new
function
from Listing 12-23
At the time, we said not to worry about the inefficient clone
calls because
we would remove them in the future. Well, that time is now!
We needed clone
here because we have a slice with String
elements in the
parameter args
, but the new
function doesn’t own args
. To return
ownership of a Config
instance, we had to clone the values from the query
and filename
fields of Config
so the Config
instance can own its values.
With our new knowledge about iterators, we can change the new
function to
take ownership of an iterator as its argument instead of borrowing a slice.
We’ll use the iterator functionality instead of the code that checks the length
of the slice and indexes into specific locations. This will clarify what the
Config::new
function is doing because the iterator will access the values.
Once Config::new
takes ownership of the iterator and stops using indexing
operations that borrow, we can move the String
values from the iterator into
Config
rather than calling clone
and making a new allocation.
Using the Returned Iterator Directly
Open your I/O project’s src/main.rs file, which should look like this:
Filename: src/main.rs
use std::env;
use std::process;
use minigrep::Config;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {}", err);
process::exit(1);
});
// --snip--
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {}", e);
process::exit(1);
}
}
We’ll change the start of the main
function that we had in Listing 12-24 to
the code in Listing 13-25. This won’t compile until we update Config::new
as
well.
Filename: src/main.rs
use std::env;
use std::process;
use minigrep::Config;
fn main() {
let config = Config::new(env::args()).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {}", err);
process::exit(1);
});
// --snip--
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {}", e);
process::exit(1);
}
}
Listing 13-25: Passing the return value of env::args
to
Config::new
The env::args
function returns an iterator! Rather than collecting the
iterator values into a vector and then passing a slice to Config::new
, now
we’re passing ownership of the iterator returned from env::args
to
Config::new
directly.
Next, we need to update the definition of Config::new
. In your I/O project’s
src/lib.rs file, let’s change the signature of Config::new
to look like
Listing 13-26. This still won’t compile because we need to update the function
body.
Filename: src/lib.rs
use std::env;
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
// --snip--
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config {
query,
filename,
case_sensitive,
})
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 13-26: Updating the signature of Config::new
to
expect an iterator
The standard library documentation for the env::args
function shows that the
type of the iterator it returns is std::env::Args
. We’ve updated the
signature of the Config::new
function so the parameter args
has the type
std::env::Args
instead of &[String]
. Because we’re taking ownership of
args
and we’ll be mutating args
by iterating over it, we can add the mut
keyword into the specification of the args
parameter to make it mutable.
Using Iterator
Trait Methods Instead of Indexing
Next, we’ll fix the body of Config::new
. The standard library documentation
also mentions that std::env::Args
implements the Iterator
trait, so we know
we can call the next
method on it! Listing 13-27 updates the code from
Listing 12-23 to use the next
method:
Filename: src/lib.rs
use std::env;
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
args.next();
let query = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a query string"),
};
let filename = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a file name"),
};
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config {
query,
filename,
case_sensitive,
})
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 13-27: Changing the body of Config::new
to use
iterator methods
Remember that the first value in the return value of env::args
is the name of
the program. We want to ignore that and get to the next value, so first we call
next
and do nothing with the return value. Second, we call next
to get the
value we want to put in the query
field of Config
. If next
returns a
Some
, we use a match
to extract the value. If it returns None
, it means
not enough arguments were given and we return early with an Err
value. We do
the same thing for the filename
value.
Making Code Clearer with Iterator Adaptors
We can also take advantage of iterators in the search
function in our I/O
project, which is reproduced here in Listing 13-28 as it was in Listing 12-19:
Filename: src/lib.rs
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
Listing 13-28: The implementation of the search
function from Listing 12-19
We can write this code in a more concise way using iterator adaptor methods.
Doing so also lets us avoid having a mutable intermediate results
vector. The
functional programming style prefers to minimize the amount of mutable state to
make code clearer. Removing the mutable state might enable a future enhancement
to make searching happen in parallel, because we wouldn’t have to manage
concurrent access to the results
vector. Listing 13-29 shows this change:
Filename: src/lib.rs
use std::env;
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(mut args: std::env::Args) -> Result<Config, &'static str> {
args.next();
let query = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a query string"),
};
let filename = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a file name"),
};
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config {
query,
filename,
case_sensitive,
})
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
contents
.lines()
.filter(|line| line.contains(query))
.collect()
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
Listing 13-29: Using iterator adaptor methods in the
implementation of the search
function
Recall that the purpose of the search
function is to return all lines in
contents
that contain the query
. Similar to the filter
example in Listing
13-19, this code uses the filter
adaptor to keep only the lines that
line.contains(query)
returns true
for. We then collect the matching lines
into another vector with collect
. Much simpler! Feel free to make the same
change to use iterator methods in the search_case_insensitive
function as
well.
The next logical question is which style you should choose in your own code and why: the original implementation in Listing 13-28 or the version using iterators in Listing 13-29. Most Rust programmers prefer to use the iterator style. It’s a bit tougher to get the hang of at first, but once you get a feel for the various iterator adaptors and what they do, iterators can be easier to understand. Instead of fiddling with the various bits of looping and building new vectors, the code focuses on the high-level objective of the loop. This abstracts away some of the commonplace code so it’s easier to see the concepts that are unique to this code, such as the filtering condition each element in the iterator must pass.
But are the two implementations truly equivalent? The intuitive assumption might be that the more low-level loop will be faster. Let’s talk about performance.
Comparing Performance: Loops vs. Iterators
To determine whether to use loops or iterators, you need to know which
implementation is faster: the version of the search
function with an explicit
for
loop or the version with iterators.
We ran a benchmark by loading the entire contents of The Adventures of
Sherlock Holmes by Sir Arthur Conan Doyle into a String
and looking for the
word the in the contents. Here are the results of the benchmark on the
version of search
using the for
loop and the version using iterators:
test bench_search_for ... bench: 19,620,300 ns/iter (+/- 915,700)
test bench_search_iter ... bench: 19,234,900 ns/iter (+/- 657,200)
The iterator version was slightly faster! We won’t explain the benchmark code here, because the point is not to prove that the two versions are equivalent but to get a general sense of how these two implementations compare performance-wise.
For a more comprehensive benchmark, you should check using various texts of
various sizes as the contents
, different words and words of different lengths
as the query
, and all kinds of other variations. The point is this:
iterators, although a high-level abstraction, get compiled down to roughly the
same code as if you’d written the lower-level code yourself. Iterators are one
of Rust’s zero-cost abstractions, by which we mean using the abstraction
imposes no additional runtime overhead. This is analogous to how Bjarne
Stroustrup, the original designer and implementor of C++, defines
zero-overhead in “Foundations of C++” (2012):
In general, C++ implementations obey the zero-overhead principle: What you don’t use, you don’t pay for. And further: What you do use, you couldn’t hand code any better.
As another example, the following code is taken from an audio decoder. The
decoding algorithm uses the linear prediction mathematical operation to
estimate future values based on a linear function of the previous samples. This
code uses an iterator chain to do some math on three variables in scope: a
buffer
slice of data, an array of 12 coefficients
, and an amount by which
to shift data in qlp_shift
. We’ve declared the variables within this example
but not given them any values; although this code doesn’t have much meaning
outside of its context, it’s still a concise, real-world example of how Rust
translates high-level ideas to low-level code.
let buffer: &mut [i32];
let coefficients: [i64; 12];
let qlp_shift: i16;
for i in 12..buffer.len() {
let prediction = coefficients.iter()
.zip(&buffer[i - 12..i])
.map(|(&c, &s)| c * s as i64)
.sum::<i64>() >> qlp_shift;
let delta = buffer[i];
buffer[i] = prediction as i32 + delta;
}
To calculate the value of prediction
, this code iterates through each of the
12 values in coefficients
and uses the zip
method to pair the coefficient
values with the previous 12 values in buffer
. Then, for each pair, we
multiply the values together, sum all the results, and shift the bits in the
sum qlp_shift
bits to the right.
Calculations in applications like audio decoders often prioritize performance
most highly. Here, we’re creating an iterator, using two adaptors, and then
consuming the value. What assembly code would this Rust code compile to? Well,
as of this writing, it compiles down to the same assembly you’d write by hand.
There’s no loop at all corresponding to the iteration over the values in
coefficients
: Rust knows that there are 12 iterations, so it “unrolls” the
loop. Unrolling is an optimization that removes the overhead of the loop
controlling code and instead generates repetitive code for each iteration of
the loop.
All of the coefficients get stored in registers, which means accessing the values is very fast. There are no bounds checks on the array access at runtime. All these optimizations that Rust is able to apply make the resulting code extremely efficient. Now that you know this, you can use iterators and closures without fear! They make code seem like it’s higher level but don’t impose a runtime performance penalty for doing so.
Summary
Closures and iterators are Rust features inspired by functional programming language ideas. They contribute to Rust’s capability to clearly express high-level ideas at low-level performance. The implementations of closures and iterators are such that runtime performance is not affected. This is part of Rust’s goal to strive to provide zero-cost abstractions.
Now that we’ve improved the expressiveness of our I/O project, let’s look at
some more features of cargo
that will help us share the project with the
world.
Giới thiệu thêm về Cargo and Crates.io
Cho đến nay, chúng ta chỉ sử dụng các tính năng cơ bản nhất của Cargo để build, run và kiểm tra mã của chúng ta, nhưng nó có thể làm được nhiều hơn thế. Trong chương này, chúng ta sẽ thảo luận một số tính năng khác của nó, nhiều tính năng nâng cao hơn được để giúp bạn cách làm chúng như sau:
- Tùy chỉnh build của bạn thông qua cấu hình release
- Xuất bản những lib bạn xây dựng lên crates.io
- Tổ chức các dự án lớn với những không gian làm việc
- Cài đặt những mã nhị phân từ crates.io
- Mở rộng Cargo sử dụng những commands tuỳ chỉnh
Cargo thậm chí có thể làm được nhiều hơn những gì chúng ta đề cập trong chương này, vì vậy để được giải thích đầy đủ về tất cả các tính năng của nó, hãy xem its documentation.
Tuỳ chỉnh Builds với cấu hình Release
Trong Rust, cấu hình release là các cấu hình được xác định trước và có thể tùy chỉnh với những config khác nhau cho phép lập trình viên có nhiều quyền kiểm soát hơn đối với các tùy chọn khác nhau để biên dịch mã. Mỗi cấu hình được config độc lập với những cấu hình khác.
Cargo có 2 cấu hình chính: cấu hình dev
Cargo sử dụng khi bạn chạy lệnh cargo build
và cấu hình release
Cargo sử dụng khi bạn chạy lệnh cargo build --release
. Cấu hình dev
được định nghĩa các giá trị mặc định tốt cho quá trình phát triển,
và cấu hình release
tốt cho các bản phát hành.
Tên các cấu hình này có thể quen thuộc từ output khi bạn build:
$ cargo build
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
$ cargo build --release
Finished release [optimized] target(s) in 0.0s
dev
and release
được hiển thị trong đầu ra bản dựng này chỉ ra rằng trình
biên dịch đang sử dụng các cấu hình khác nhau.
Cargo có cài đặt mặc định cho từng cấu hình nó áp dụng khi không có bất kì phần [profile.*]
trong file Cargo.toml của dự án. Bằng cách thêm phần [profile.*]
cho bất kỳ cấu hình nào bạn muốn tùy chỉnh, bạn có thể ghi đè bất kỳ tập hợp con nào của cấu hình mặc định.
Ví dụ, đây là cấu giá trị mặc định cài đặt opt-level
cho cấu hình dev
và release
:
Filename: Cargo.toml
[profile.dev]
opt-level = 0
[profile.release]
opt-level = 3
Cài đặt opt-level
kiểm soát số lượng tối ưu hóa Rust sẽ áp dụng cho mã của bạn,
với phạm vi từ 0 đến 3. Áp dụng nhiều tối ưu hóa hơn sẽ kéo dài thời gian biên dịch,
vì vậy nếu bạn đang trong quá trình phát triển và biên dịch mã của mình thường xuyên,
bạn sẽ muốn biên dịch nhanh hơn ngay cả khi mã kết quả chạy chậm hơn. Đó là lý do giá trị mặc định
opt-level
cho dev
là 0
. Khi bạn chuẩn bị phát hành code của mình,
tốt nhất là dành nhiều thời gian hơn để biên dịch. Bạn chỉ phải biên dịch code 1 lần,
nhưng bạn sẽ chạy code đã compile nhiều làn, vì vậy chế độ phát hành đánh đổi nhiều thời gian
biên dịch hơn để cho đoạn code chạy nhanh hơn.
Đó là lý do giá trị mặc định opt-level
cho cấu hình release
là 3
.
Bạn có thể ghi đè bất kì cài đặt mặc định nào bằng cách thêm một giá trị khác vào trong file Cargo.toml. Ví dụ, nếu chúng ta muốn sử dụng tối ưu level 1 trong cấu hình phát triển, chúng ta có thể thêm 2 dòng vào trong file Cargo.toml của dự án:
Filename: Cargo.toml
[profile.dev]
opt-level = 1
Đoạn code này ghi đè giá trị mặc định là 0
. Bây giờ khi chúng ta run cargo build
,
Cargo sẽ sử dụng cấu hình mặc định dev
thêm tuỳ chỉnh của chúng ta với opt-level
.
Bởi vì chúng ta cài đặt opt-level
là 1
, Cargo sẽ chấp nhận tối ưu hơn mặc định,
nhưng không nhiều như trong một bản phát hành.
Để có danh sách đầy đủ các tùy chọn cấu hình và mặc định cho từng cấu hình, xem Cargo’s documentation.
Publishing a Crate to Crates.io
We’ve used packages from crates.io as dependencies of our project, but you can also share your code with other people by publishing your own packages. The crate registry at crates.io distributes the source code of your packages, so it primarily hosts code that is open source.
Rust and Cargo have features that help make your published package easier for people to use and to find in the first place. We’ll talk about some of these features next and then explain how to publish a package.
Making Useful Documentation Comments
Accurately documenting your packages will help other users know how and when to
use them, so it’s worth investing the time to write documentation. In Chapter
3, we discussed how to comment Rust code using two slashes, //
. Rust also has
a particular kind of comment for documentation, known conveniently as a
documentation comment, that will generate HTML documentation. The HTML
displays the contents of documentation comments for public API items intended
for programmers interested in knowing how to use your crate as opposed to how
your crate is implemented.
Documentation comments use three slashes, ///
, instead of two and support
Markdown notation for formatting the text. Place documentation comments just
before the item they’re documenting. Listing 14-1 shows documentation comments
for an add_one
function in a crate named my_crate
.
Filename: src/lib.rs
/// Adds one to the number given.
///
/// # Examples
///
/// ```
/// let arg = 5;
/// let answer = my_crate::add_one(arg);
///
/// assert_eq!(6, answer);
/// ```
pub fn add_one(x: i32) -> i32 {
x + 1
}
Listing 14-1: A documentation comment for a function
Here, we give a description of what the add_one
function does, start a
section with the heading Examples
, and then provide code that demonstrates
how to use the add_one
function. We can generate the HTML documentation from
this documentation comment by running cargo doc
. This command runs the
rustdoc
tool distributed with Rust and puts the generated HTML documentation
in the target/doc directory.
For convenience, running cargo doc --open
will build the HTML for your
current crate’s documentation (as well as the documentation for all of your
crate’s dependencies) and open the result in a web browser. Navigate to the
add_one
function and you’ll see how the text in the documentation comments is
rendered, as shown in Figure 14-1:
![Rendered HTML documentation for the `add_one` function of `my_crate`](img/trpl14-01.png)
Figure 14-1: HTML documentation for the add_one
function
Commonly Used Sections
We used the # Examples
Markdown heading in Listing 14-1 to create a section
in the HTML with the title “Examples.” Here are some other sections that crate
authors commonly use in their documentation:
- Panics: The scenarios in which the function being documented could panic. Callers of the function who don’t want their programs to panic should make sure they don’t call the function in these situations.
- Errors: If the function returns a
Result
, describing the kinds of errors that might occur and what conditions might cause those errors to be returned can be helpful to callers so they can write code to handle the different kinds of errors in different ways. - Safety: If the function is
unsafe
to call (we discuss unsafety in Chapter 19), there should be a section explaining why the function is unsafe and covering the invariants that the function expects callers to uphold.
Most documentation comments don’t need all of these sections, but this is a good checklist to remind you of the aspects of your code that people calling your code will be interested in knowing about.
Documentation Comments as Tests
Adding example code blocks in your documentation comments can help demonstrate
how to use your library, and doing so has an additional bonus: running cargo test
will run the code examples in your documentation as tests! Nothing is
better than documentation with examples. But nothing is worse than examples
that don’t work because the code has changed since the documentation was
written. If we run cargo test
with the documentation for the add_one
function from Listing 14-1, we will see a section in the test results like this:
Doc-tests my_crate
running 1 test
test src/lib.rs - add_one (line 5) ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.27s
Now if we change either the function or the example so the assert_eq!
in the
example panics and run cargo test
again, we’ll see that the doc tests catch
that the example and the code are out of sync with each other!
Commenting Contained Items
Another style of doc comment, //!
, adds documentation to the item that
contains the comments rather than adding documentation to the items following
the comments. We typically use these doc comments inside the crate root file
(src/lib.rs by convention) or inside a module to document the crate or the
module as a whole.
For example, if we want to add documentation that describes the purpose of the
my_crate
crate that contains the add_one
function, we can add documentation
comments that start with //!
to the beginning of the src/lib.rs file, as
shown in Listing 14-2:
Filename: src/lib.rs
//! # My Crate
//!
//! `my_crate` is a collection of utilities to make performing certain
//! calculations more convenient.
/// Adds one to the number given.
// --snip--
///
/// # Examples
///
/// ```
/// let arg = 5;
/// let answer = my_crate::add_one(arg);
///
/// assert_eq!(6, answer);
/// ```
pub fn add_one(x: i32) -> i32 {
x + 1
}
Listing 14-2: Documentation for the my_crate
crate as a
whole
Notice there isn’t any code after the last line that begins with //!
. Because
we started the comments with //!
instead of ///
, we’re documenting the item
that contains this comment rather than an item that follows this comment. In
this case, the item that contains this comment is the src/lib.rs file, which
is the crate root. These comments describe the entire crate.
When we run cargo doc --open
, these comments will display on the front
page of the documentation for my_crate
above the list of public items in the
crate, as shown in Figure 14-2:
![Rendered HTML documentation with a comment for the crate as a whole](img/trpl14-02.png)
Figure 14-2: Rendered documentation for my_crate
,
including the comment describing the crate as a whole
Documentation comments within items are useful for describing crates and modules especially. Use them to explain the overall purpose of the container to help your users understand the crate’s organization.
Exporting a Convenient Public API with pub use
In Chapter 7, we covered how to organize our code into modules using the mod
keyword, how to make items public using the pub
keyword, and how to bring
items into a scope with the use
keyword. However, the structure that makes
sense to you while you’re developing a crate might not be very convenient for
your users. You might want to organize your structs in a hierarchy containing
multiple levels, but then people who want to use a type you’ve defined deep in
the hierarchy might have trouble finding out that type exists. They might also
be annoyed at having to enter use
my_crate::some_module::another_module::UsefulType;
rather than use
my_crate::UsefulType;
.
The structure of your public API is a major consideration when publishing a crate. People who use your crate are less familiar with the structure than you are and might have difficulty finding the pieces they want to use if your crate has a large module hierarchy.
The good news is that if the structure isn’t convenient for others to use
from another library, you don’t have to rearrange your internal organization:
instead, you can re-export items to make a public structure that’s different
from your private structure by using pub use
. Re-exporting takes a public
item in one location and makes it public in another location, as if it were
defined in the other location instead.
For example, say we made a library named art
for modeling artistic concepts.
Within this library are two modules: a kinds
module containing two enums
named PrimaryColor
and SecondaryColor
and a utils
module containing a
function named mix
, as shown in Listing 14-3:
Filename: src/lib.rs
//! # Art
//!
//! A library for modeling artistic concepts.
pub mod kinds {
/// The primary colors according to the RYB color model.
pub enum PrimaryColor {
Red,
Yellow,
Blue,
}
/// The secondary colors according to the RYB color model.
pub enum SecondaryColor {
Orange,
Green,
Purple,
}
}
pub mod utils {
use crate::kinds::*;
/// Combines two primary colors in equal amounts to create
/// a secondary color.
pub fn mix(c1: PrimaryColor, c2: PrimaryColor) -> SecondaryColor {
// --snip--
unimplemented!();
}
}
Listing 14-3: An art
library with items organized into
kinds
and utils
modules
Figure 14-3 shows what the front page of the documentation for this crate
generated by cargo doc
would look like:
![Rendered documentation for the `art` crate that lists the `kinds` and `utils` modules](img/trpl14-03.png)
Figure 14-3: Front page of the documentation for art
that lists the kinds
and utils
modules
Note that the PrimaryColor
and SecondaryColor
types aren’t listed on the
front page, nor is the mix
function. We have to click kinds
and utils
to
see them.
Another crate that depends on this library would need use
statements that
bring the items from art
into scope, specifying the module structure that’s
currently defined. Listing 14-4 shows an example of a crate that uses the
PrimaryColor
and mix
items from the art
crate:
Filename: src/main.rs
use art::kinds::PrimaryColor;
use art::utils::mix;
fn main() {
let red = PrimaryColor::Red;
let yellow = PrimaryColor::Yellow;
mix(red, yellow);
}
Listing 14-4: A crate using the art
crate’s items with
its internal structure exported
The author of the code in Listing 14-4, which uses the art
crate, had to
figure out that PrimaryColor
is in the kinds
module and mix
is in the
utils
module. The module structure of the art
crate is more relevant to
developers working on the art
crate than to developers using the art
crate.
The internal structure that organizes parts of the crate into the kinds
module and the utils
module doesn’t contain any useful information for
someone trying to understand how to use the art
crate. Instead, the art
crate’s module structure causes confusion because developers have to figure out
where to look, and the structure is inconvenient because developers must
specify the module names in the use
statements.
To remove the internal organization from the public API, we can modify the
art
crate code in Listing 14-3 to add pub use
statements to re-export the
items at the top level, as shown in Listing 14-5:
Filename: src/lib.rs
//! # Art
//!
//! A library for modeling artistic concepts.
pub use self::kinds::PrimaryColor;
pub use self::kinds::SecondaryColor;
pub use self::utils::mix;
pub mod kinds {
// --snip--
/// The primary colors according to the RYB color model.
pub enum PrimaryColor {
Red,
Yellow,
Blue,
}
/// The secondary colors according to the RYB color model.
pub enum SecondaryColor {
Orange,
Green,
Purple,
}
}
pub mod utils {
// --snip--
use crate::kinds::*;
/// Combines two primary colors in equal amounts to create
/// a secondary color.
pub fn mix(c1: PrimaryColor, c2: PrimaryColor) -> SecondaryColor {
SecondaryColor::Orange
}
}
Listing 14-5: Adding pub use
statements to re-export
items
The API documentation that cargo doc
generates for this crate will now list
and link re-exports on the front page, as shown in Figure 14-4, making the
PrimaryColor
and SecondaryColor
types and the mix
function easier to find.
![Rendered documentation for the `art` crate with the re-exports on the front page](img/trpl14-04.png)
Figure 14-4: The front page of the documentation for art
that lists the re-exports
The art
crate users can still see and use the internal structure from Listing
14-3 as demonstrated in Listing 14-4, or they can use the more convenient
structure in Listing 14-5, as shown in Listing 14-6:
Filename: src/main.rs
use art::mix;
use art::PrimaryColor;
fn main() {
// --snip--
let red = PrimaryColor::Red;
let yellow = PrimaryColor::Yellow;
mix(red, yellow);
}
Listing 14-6: A program using the re-exported items from
the art
crate
In cases where there are many nested modules, re-exporting the types at the top
level with pub use
can make a significant difference in the experience of
people who use the crate.
Creating a useful public API structure is more of an art than a science, and
you can iterate to find the API that works best for your users. Choosing pub use
gives you flexibility in how you structure your crate internally and
decouples that internal structure from what you present to your users. Look at
some of the code of crates you’ve installed to see if their internal structure
differs from their public API.
Setting Up a Crates.io Account
Before you can publish any crates, you need to create an account on
crates.io and get an API token. To do so,
visit the home page at crates.io and log in
via a GitHub account. (The GitHub account is currently a requirement, but the
site might support other ways of creating an account in the future.) Once
you’re logged in, visit your account settings at
https://crates.io/me/ and retrieve your
API key. Then run the cargo login
command with your API key, like this:
$ cargo login abcdefghijklmnopqrstuvwxyz012345
This command will inform Cargo of your API token and store it locally in ~/.cargo/credentials. Note that this token is a secret: do not share it with anyone else. If you do share it with anyone for any reason, you should revoke it and generate a new token on crates.io.
Adding Metadata to a New Crate
Now that you have an account, let’s say you have a crate you want to publish.
Before publishing, you’ll need to add some metadata to your crate by adding it
to the [package]
section of the crate’s Cargo.toml file.
Your crate will need a unique name. While you’re working on a crate locally,
you can name a crate whatever you’d like. However, crate names on
crates.io are allocated on a first-come,
first-served basis. Once a crate name is taken, no one else can publish a crate
with that name. Before attempting to publish a crate, search for the name you
want to use on the site. If the name has been used by another crate, you will
need to find another name and edit the name
field in the Cargo.toml file
under the [package]
section to use the new name for publishing, like so:
Filename: Cargo.toml
[package]
name = "guessing_game"
Even if you’ve chosen a unique name, when you run cargo publish
to publish
the crate at this point, you’ll get a warning and then an error:
$ cargo publish
Updating crates.io index
warning: manifest has no description, license, license-file, documentation, homepage or repository.
See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
--snip--
error: failed to publish to registry at https://crates.io
Caused by:
the remote server responded with an error: missing or empty metadata fields: description, license. Please see https://doc.rust-lang.org/cargo/reference/manifest.html for how to upload metadata
The reason is that you’re missing some crucial information: a description and license are required so people will know what your crate does and under what terms they can use it. To rectify this error, you need to include this information in the Cargo.toml file.
Add a description that is just a sentence or two, because it will appear with
your crate in search results. For the license
field, you need to give a
license identifier value. The Linux Foundation’s Software Package Data
Exchange (SPDX) lists the identifiers you can use for this value. For
example, to specify that you’ve licensed your crate using the MIT License, add
the MIT
identifier:
Filename: Cargo.toml
[package]
name = "guessing_game"
license = "MIT"
If you want to use a license that doesn’t appear in the SPDX, you need to place
the text of that license in a file, include the file in your project, and then
use license-file
to specify the name of that file instead of using the
license
key.
Guidance on which license is appropriate for your project is beyond the scope
of this book. Many people in the Rust community license their projects in the
same way as Rust by using a dual license of MIT OR Apache-2.0
. This practice
demonstrates that you can also specify multiple license identifiers separated
by OR
to have multiple licenses for your project.
With a unique name, the version, your description, and a license added, the Cargo.toml file for a project that is ready to publish might look like this:
Filename: Cargo.toml
[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"
description = "A fun game where you guess what number the computer has chosen."
license = "MIT OR Apache-2.0"
[dependencies]
Cargo’s documentation describes other metadata you can specify to ensure others can discover and use your crate more easily.
Publishing to Crates.io
Now that you’ve created an account, saved your API token, chosen a name for your crate, and specified the required metadata, you’re ready to publish! Publishing a crate uploads a specific version to crates.io for others to use.
Be careful when publishing a crate because a publish is permanent. The version can never be overwritten, and the code cannot be deleted. One major goal of crates.io is to act as a permanent archive of code so that builds of all projects that depend on crates from crates.io will continue to work. Allowing version deletions would make fulfilling that goal impossible. However, there is no limit to the number of crate versions you can publish.
Run the cargo publish
command again. It should succeed now:
$ cargo publish
Updating crates.io index
Packaging guessing_game v0.1.0 (file:///projects/guessing_game)
Verifying guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0
(file:///projects/guessing_game/target/package/guessing_game-0.1.0)
Finished dev [unoptimized + debuginfo] target(s) in 0.19s
Uploading guessing_game v0.1.0 (file:///projects/guessing_game)
Congratulations! You’ve now shared your code with the Rust community, and anyone can easily add your crate as a dependency of their project.
Publishing a New Version of an Existing Crate
When you’ve made changes to your crate and are ready to release a new version,
you change the version
value specified in your Cargo.toml file and
republish. Use the Semantic Versioning rules to decide what an
appropriate next version number is based on the kinds of changes you’ve made.
Then run cargo publish
to upload the new version.
Removing Versions from Crates.io with cargo yank
Although you can’t remove previous versions of a crate, you can prevent any future projects from adding them as a new dependency. This is useful when a crate version is broken for one reason or another. In such situations, Cargo supports yanking a crate version.
Yanking a version prevents new projects from starting to depend on that version while allowing all existing projects that depend on it to continue to download and depend on that version. Essentially, a yank means that all projects with a Cargo.lock will not break, and any future Cargo.lock files generated will not use the yanked version.
To yank a version of a crate, run cargo yank
and specify which version you
want to yank:
$ cargo yank --vers 1.0.1
By adding --undo
to the command, you can also undo a yank and allow projects
to start depending on a version again:
$ cargo yank --vers 1.0.1 --undo
A yank does not delete any code. For example, the yank feature is not intended for deleting accidentally uploaded secrets. If that happens, you must reset those secrets immediately.
Cargo Workspaces
In Chapter 12, we built a package that included a binary crate and a library crate. As your project develops, you might find that the library crate continues to get bigger and you want to split up your package further into multiple library crates. In this situation, Cargo offers a feature called workspaces that can help manage multiple related packages that are developed in tandem.
Creating a Workspace
A workspace is a set of packages that share the same Cargo.lock and output
directory. Let’s make a project using a workspace—we’ll use trivial code so we
can concentrate on the structure of the workspace. There are multiple ways to
structure a workspace; we’re going to show one common way. We’ll have a
workspace containing a binary and two libraries. The binary, which will provide
the main functionality, will depend on the two libraries. One library will
provide an add_one
function, and a second library an add_two
function.
These three crates will be part of the same workspace. We’ll start by creating
a new directory for the workspace:
$ mkdir add
$ cd add
Next, in the add directory, we create the Cargo.toml file that will
configure the entire workspace. This file won’t have a [package]
section or
the metadata we’ve seen in other Cargo.toml files. Instead, it will start
with a [workspace]
section that will allow us to add members to the workspace
by specifying the path to the package with our binary crate; in this case,
that path is adder:
Filename: Cargo.toml
[workspace]
members = [
"adder",
]
Next, we’ll create the adder
binary crate by running cargo new
within the
add directory:
$ cargo new adder
Created binary (application) `adder` package
At this point, we can build the workspace by running cargo build
. The files
in your add directory should look like this:
├── Cargo.lock
├── Cargo.toml
├── adder
│ ├── Cargo.toml
│ └── src
│ └── main.rs
└── target
The workspace has one target directory at the top level for the compiled
artifacts to be placed into; the adder
package doesn’t have its own target
directory. Even if we were to run cargo build
from inside the adder
directory, the compiled artifacts would still end up in add/target rather
than add/adder/target. Cargo structures the target directory in a workspace
like this because the crates in a workspace are meant to depend on each other.
If each crate had its own target directory, each crate would have to
recompile each of the other crates in the workspace to have the artifacts in
its own target directory. By sharing one target directory, the crates can
avoid unnecessary rebuilding.
Creating the Second Package in the Workspace
Next, let’s create another member package in the workspace and call it add_one
.
Change the top-level Cargo.toml to specify the add_one path in the
members
list:
Filename: Cargo.toml
[workspace]
members = [
"adder",
"add_one",
]
Then generate a new library crate named add_one
:
$ cargo new add_one --lib
Created library `add_one` package
Your add directory should now have these directories and files:
├── Cargo.lock
├── Cargo.toml
├── add_one
│ ├── Cargo.toml
│ └── src
│ └── lib.rs
├── adder
│ ├── Cargo.toml
│ └── src
│ └── main.rs
└── target
In the add_one/src/lib.rs file, let’s add an add_one
function:
Filename: add_one/src/lib.rs
pub fn add_one(x: i32) -> i32 {
x + 1
}
Now that we have another package in the workspace, we can have the adder
package with our binary depend on the add_one
package, that has our
library. First, we’ll need to add a path dependency on add_one
to
adder/Cargo.toml.
Filename: adder/Cargo.toml
[dependencies]
add_one = { path = "../add_one" }
Cargo doesn’t assume that crates in a workspace will depend on each other, so we need to be explicit about the dependency relationships between the crates.
Next, let’s use the add_one
function from the add_one
crate in the adder
crate. Open the adder/src/main.rs file and add a use
line at the top to
bring the new add_one
library crate into scope. Then change the main
function to call the add_one
function, as in Listing 14-7.
Filename: adder/src/main.rs
use add_one;
fn main() {
let num = 10;
println!(
"Hello, world! {} plus one is {}!",
num,
add_one::add_one(num)
);
}
Listing 14-7: Using the add_one
library crate from the
adder
crate
Let’s build the workspace by running cargo build
in the top-level add
directory!
$ cargo build
Compiling add_one v0.1.0 (file:///projects/add/add_one)
Compiling adder v0.1.0 (file:///projects/add/adder)
Finished dev [unoptimized + debuginfo] target(s) in 0.68s
To run the binary crate from the add directory, we can specify which
package in the workspace we want to run by using the -p
argument and the
package name with cargo run
:
$ cargo run -p adder
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/adder`
Hello, world! 10 plus one is 11!
This runs the code in adder/src/main.rs, which depends on the add_one
crate.
Depending on an External Package in a Workspace
Notice that the workspace has only one Cargo.lock file at the top level of
the workspace rather than having a Cargo.lock in each crate’s directory. This
ensures that all crates are using the same version of all dependencies. If we
add the rand
package to the adder/Cargo.toml and add_one/Cargo.toml
files, Cargo will resolve both of those to one version of rand
and record
that in the one Cargo.lock. Making all crates in the workspace use the same
dependencies means the crates in the workspace will always be compatible with
each other. Let’s add the rand
crate to the [dependencies]
section in the
add_one/Cargo.toml file to be able to use the rand
crate in the add_one
crate:
Filename: add_one/Cargo.toml
[dependencies]
rand = "0.8.3"
We can now add use rand;
to the add_one/src/lib.rs file, and building the
whole workspace by running cargo build
in the add directory will bring in
and compile the rand
crate. We will get one warning because we aren’t
referring to the rand
we brought into scope:
$ cargo build
Updating crates.io index
Downloaded rand v0.8.3
--snip--
Compiling rand v0.8.3
Compiling add_one v0.1.0 (file:///projects/add/add_one)
warning: unused import: `rand`
--> add_one/src/lib.rs:1:5
|
1 | use rand;
| ^^^^
|
= note: `#[warn(unused_imports)]` on by default
warning: 1 warning emitted
Compiling adder v0.1.0 (file:///projects/add/adder)
Finished dev [unoptimized + debuginfo] target(s) in 10.18s
The top-level Cargo.lock now contains information about the dependency of
add_one
on rand
. However, even though rand
is used somewhere in the
workspace, we can’t use it in other crates in the workspace unless we add
rand
to their Cargo.toml files as well. For example, if we add use rand;
to the adder/src/main.rs file for the adder
package, we’ll get an error:
$ cargo build
--snip--
Compiling adder v0.1.0 (file:///projects/add/adder)
error[E0432]: unresolved import `rand`
--> adder/src/main.rs:2:5
|
2 | use rand;
| ^^^^ no external crate `rand`
To fix this, edit the Cargo.toml file for the adder
package and indicate
that rand
is a dependency for it as well. Building the adder
package will
add rand
to the list of dependencies for adder
in Cargo.lock, but no
additional copies of rand
will be downloaded. Cargo has ensured that every
crate in every package in the workspace using the rand
package will be
using the same version. Using the same version of rand
across the workspace
saves space because we won’t have multiple copies and ensures that the crates
in the workspace will be compatible with each other.
Adding a Test to a Workspace
For another enhancement, let’s add a test of the add_one::add_one
function
within the add_one
crate:
Filename: add_one/src/lib.rs
pub fn add_one(x: i32) -> i32 {
x + 1
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
assert_eq!(3, add_one(2));
}
}
Now run cargo test
in the top-level add directory:
$ cargo test
Compiling add_one v0.1.0 (file:///projects/add/add_one)
Compiling adder v0.1.0 (file:///projects/add/adder)
Finished test [unoptimized + debuginfo] target(s) in 0.27s
Running target/debug/deps/add_one-f0253159197f7841
running 1 test
test tests::it_works ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running target/debug/deps/adder-49979ff40686fa8e
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests add_one
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
The first section of the output shows that the it_works
test in the add_one
crate passed. The next section shows that zero tests were found in the adder
crate, and then the last section shows zero documentation tests were found in
the add_one
crate. Running cargo test
in a workspace structured like this
one will run the tests for all the crates in the workspace.
We can also run tests for one particular crate in a workspace from the
top-level directory by using the -p
flag and specifying the name of the crate
we want to test:
$ cargo test -p add_one
Finished test [unoptimized + debuginfo] target(s) in 0.00s
Running target/debug/deps/add_one-b3235fea9a156f74
running 1 test
test tests::it_works ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests add_one
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
This output shows cargo test
only ran the tests for the add_one
crate and
didn’t run the adder
crate tests.
If you publish the crates in the workspace to crates.io,
each crate in the workspace will need to be published separately. The cargo publish
command does not have an --all
flag or a -p
flag, so you must
change to each crate’s directory and run cargo publish
on each crate in the
workspace to publish the crates.
For additional practice, add an add_two
crate to this workspace in a similar
way as the add_one
crate!
As your project grows, consider using a workspace: it’s easier to understand smaller, individual components than one big blob of code. Furthermore, keeping the crates in a workspace can make coordination between them easier if they are often changed at the same time.
Installing Binaries from Crates.io with cargo install
The cargo install
command allows you to install and use binary crates
locally. This isn’t intended to replace system packages; it’s meant to be a
convenient way for Rust developers to install tools that others have shared on
crates.io. Note that you can only install
packages that have binary targets. A binary target is the runnable program
that is created if the crate has a src/main.rs file or another file specified
as a binary, as opposed to a library target that isn’t runnable on its own but
is suitable for including within other programs. Usually, crates have
information in the README file about whether a crate is a library, has a
binary target, or both.
All binaries installed with cargo install
are stored in the installation
root’s bin folder. If you installed Rust using rustup.rs and don’t have any
custom configurations, this directory will be $HOME/.cargo/bin. Ensure that
directory is in your $PATH
to be able to run programs you’ve installed with
cargo install
.
For example, in Chapter 12 we mentioned that there’s a Rust implementation of
the grep
tool called ripgrep
for searching files. If we want to install
ripgrep
, we can run the following:
$ cargo install ripgrep
Updating crates.io index
Downloaded ripgrep v11.0.2
Downloaded 1 crate (243.3 KB) in 0.88s
Installing ripgrep v11.0.2
--snip--
Compiling ripgrep v11.0.2
Finished release [optimized + debuginfo] target(s) in 3m 10s
Installing ~/.cargo/bin/rg
Installed package `ripgrep v11.0.2` (executable `rg`)
The second-to-last line of the output shows the location and the name of the
installed binary, which in the case of ripgrep
is rg
. As long as the
installation directory is in your $PATH
, as mentioned previously, you can
then run rg --help
and start using a faster, rustier tool for searching files!
Extending Cargo with Custom Commands
Cargo is designed so you can extend it with new subcommands without having to
modify Cargo. If a binary in your $PATH
is named cargo-something
, you can
run it as if it was a Cargo subcommand by running cargo something
. Custom
commands like this are also listed when you run cargo --list
. Being able to
use cargo install
to install extensions and then run them just like the
built-in Cargo tools is a super convenient benefit of Cargo’s design!
Summary
Sharing code with Cargo and crates.io is part of what makes the Rust ecosystem useful for many different tasks. Rust’s standard library is small and stable, but crates are easy to share, use, and improve on a timeline different from that of the language. Don’t be shy about sharing code that’s useful to you on crates.io; it’s likely that it will be useful to someone else as well!
Smart Pointers
A pointer is a general concept for a variable that contains an address in
memory. This address refers to, or “points at,” some other data. The most
common kind of pointer in Rust is a reference, which you learned about in
Chapter 4. References are indicated by the &
symbol and borrow the value they
point to. They don’t have any special capabilities other than referring to
data. Also, they don’t have any overhead and are the kind of pointer we use
most often.
Smart pointers, on the other hand, are data structures that not only act like a pointer but also have additional metadata and capabilities. The concept of smart pointers isn’t unique to Rust: smart pointers originated in C++ and exist in other languages as well. In Rust, the different smart pointers defined in the standard library provide functionality beyond that provided by references. One example that we’ll explore in this chapter is the reference counting smart pointer type. This pointer enables you to have multiple owners of data by keeping track of the number of owners and, when no owners remain, cleaning up the data.
In Rust, which uses the concept of ownership and borrowing, an additional difference between references and smart pointers is that references are pointers that only borrow data; in contrast, in many cases, smart pointers own the data they point to.
We’ve already encountered a few smart pointers in this book, such as String
and Vec<T>
in Chapter 8, although we didn’t call them smart pointers at the
time. Both these types count as smart pointers because they own some memory and
allow you to manipulate it. They also have metadata (such as their capacity)
and extra capabilities or guarantees (such as with String
ensuring its data
will always be valid UTF-8).
Smart pointers are usually implemented using structs. The characteristic that
distinguishes a smart pointer from an ordinary struct is that smart pointers
implement the Deref
and Drop
traits. The Deref
trait allows an instance
of the smart pointer struct to behave like a reference so you can write code
that works with either references or smart pointers. The Drop
trait allows
you to customize the code that is run when an instance of the smart pointer
goes out of scope. In this chapter, we’ll discuss both traits and demonstrate
why they’re important to smart pointers.
Given that the smart pointer pattern is a general design pattern used frequently in Rust, this chapter won’t cover every existing smart pointer. Many libraries have their own smart pointers, and you can even write your own. We’ll cover the most common smart pointers in the standard library:
Box<T>
for allocating values on the heapRc<T>
, a reference counting type that enables multiple ownershipRef<T>
andRefMut<T>
, accessed throughRefCell<T>
, a type that enforces the borrowing rules at runtime instead of compile time
In addition, we’ll cover the interior mutability pattern where an immutable type exposes an API for mutating an interior value. We’ll also discuss reference cycles: how they can leak memory and how to prevent them.
Let’s dive in!
Using Box<T>
to Point to Data on the Heap
The most straightforward smart pointer is a box, whose type is written
Box<T>
. Boxes allow you to store data on the heap rather than the stack. What
remains on the stack is the pointer to the heap data. Refer to Chapter 4 to
review the difference between the stack and the heap.
Boxes don’t have performance overhead, other than storing their data on the heap instead of on the stack. But they don’t have many extra capabilities either. You’ll use them most often in these situations:
- When you have a type whose size can’t be known at compile time and you want to use a value of that type in a context that requires an exact size
- When you have a large amount of data and you want to transfer ownership but ensure the data won’t be copied when you do so
- When you want to own a value and you care only that it’s a type that implements a particular trait rather than being of a specific type
We’ll demonstrate the first situation in the “Enabling Recursive Types with Boxes” section. In the second case, transferring ownership of a large amount of data can take a long time because the data is copied around on the stack. To improve performance in this situation, we can store the large amount of data on the heap in a box. Then, only the small amount of pointer data is copied around on the stack, while the data it references stays in one place on the heap. The third case is known as a trait object, and Chapter 17 devotes an entire section, “Using Trait Objects That Allow for Values of Different Types,” just to that topic. So what you learn here you’ll apply again in Chapter 17!
Using a Box<T>
to Store Data on the Heap
Before we discuss this use case for Box<T>
, we’ll cover the syntax and how to
interact with values stored within a Box<T>
.
Listing 15-1 shows how to use a box to store an i32
value on the heap:
Filename: src/main.rs
fn main() { let b = Box::new(5); println!("b = {}", b); }
Listing 15-1: Storing an i32
value on the heap using a
box
We define the variable b
to have the value of a Box
that points to the
value 5
, which is allocated on the heap. This program will print b = 5
; in
this case, we can access the data in the box similar to how we would if this
data were on the stack. Just like any owned value, when a box goes out of
scope, as b
does at the end of main
, it will be deallocated. The
deallocation happens for the box (stored on the stack) and the data it points
to (stored on the heap).
Putting a single value on the heap isn’t very useful, so you won’t use boxes by
themselves in this way very often. Having values like a single i32
on the
stack, where they’re stored by default, is more appropriate in the majority of
situations. Let’s look at a case where boxes allow us to define types that we
wouldn’t be allowed to if we didn’t have boxes.
Enabling Recursive Types with Boxes
At compile time, Rust needs to know how much space a type takes up. One type whose size can’t be known at compile time is a recursive type, where a value can have as part of itself another value of the same type. Because this nesting of values could theoretically continue infinitely, Rust doesn’t know how much space a value of a recursive type needs. However, boxes have a known size, so by inserting a box in a recursive type definition, you can have recursive types.
Let’s explore the cons list, which is a data type common in functional programming languages, as an example of a recursive type. The cons list type we’ll define is straightforward except for the recursion; therefore, the concepts in the example we’ll work with will be useful any time you get into more complex situations involving recursive types.
More Information About the Cons List
A cons list is a data structure that comes from the Lisp programming language
and its dialects. In Lisp, the cons
function (short for “construct function”)
constructs a new pair from its two arguments, which usually are a single value
and another pair. These pairs containing pairs form a list.
The cons function concept has made its way into more general functional programming jargon: “to cons x onto y” informally means to construct a new container instance by putting the element x at the start of this new container, followed by the container y.
Each item in a cons list contains two elements: the value of the current item
and the next item. The last item in the list contains only a value called Nil
without a next item. A cons list is produced by recursively calling the cons
function. The canonical name to denote the base case of the recursion is Nil
.
Note that this is not the same as the “null” or “nil” concept in Chapter 6,
which is an invalid or absent value.
Although functional programming languages use cons lists frequently, the cons
list isn’t a commonly used data structure in Rust. Most of the time when you
have a list of items in Rust, Vec<T>
is a better choice to use. Other, more
complex recursive data types are useful in various situations, but by
starting with the cons list, we can explore how boxes let us define a recursive
data type without much distraction.
Listing 15-2 contains an enum definition for a cons list. Note that this code
won’t compile yet because the List
type doesn’t have a known size, which
we’ll demonstrate.
Filename: src/main.rs
enum List {
Cons(i32, List),
Nil,
}
fn main() {}
Listing 15-2: The first attempt at defining an enum to
represent a cons list data structure of i32
values
Note: We’re implementing a cons list that holds only
i32
values for the purposes of this example. We could have implemented it using generics, as we discussed in Chapter 10, to define a cons list type that could store values of any type.
Using the List
type to store the list 1, 2, 3
would look like the code in
Listing 15-3:
Filename: src/main.rs
enum List {
Cons(i32, List),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let list = Cons(1, Cons(2, Cons(3, Nil)));
}
Listing 15-3: Using the List
enum to store the list 1, 2, 3
The first Cons
value holds 1
and another List
value. This List
value is
another Cons
value that holds 2
and another List
value. This List
value
is one more Cons
value that holds 3
and a List
value, which is finally
Nil
, the non-recursive variant that signals the end of the list.
If we try to compile the code in Listing 15-3, we get the error shown in Listing 15-4:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0072]: recursive type `List` has infinite size
--> src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^ recursive type has infinite size
2 | Cons(i32, List),
| ---- recursive without indirection
|
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to make `List` representable
|
2 | Cons(i32, Box<List>),
| ++++ +
error[E0391]: cycle detected when computing drop-check constraints for `List`
--> src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^
|
= note: ...which immediately requires computing drop-check constraints for `List` again
= note: cycle used when computing dropck types for `Canonical { max_universe: U0, variables: [], value: ParamEnvAnd { param_env: ParamEnv { caller_bounds: [], reveal: UserFacing, constness: NotConst }, value: List } }`
Some errors have detailed explanations: E0072, E0391.
For more information about an error, try `rustc --explain E0072`.
error: could not compile `cons-list` due to 2 previous errors
Listing 15-4: The error we get when attempting to define a recursive enum
The error shows this type “has infinite size.” The reason is that we’ve defined
List
with a variant that is recursive: it holds another value of itself
directly. As a result, Rust can’t figure out how much space it needs to store a
List
value. Let’s break down why we get this error a bit. First, let’s look
at how Rust decides how much space it needs to store a value of a non-recursive
type.
Computing the Size of a Non-Recursive Type
Recall the Message
enum we defined in Listing 6-2 when we discussed enum
definitions in Chapter 6:
enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32), } fn main() {}
To determine how much space to allocate for a Message
value, Rust goes
through each of the variants to see which variant needs the most space. Rust
sees that Message::Quit
doesn’t need any space, Message::Move
needs enough
space to store two i32
values, and so forth. Because only one variant will be
used, the most space a Message
value will need is the space it would take to
store the largest of its variants.
Contrast this with what happens when Rust tries to determine how much space a
recursive type like the List
enum in Listing 15-2 needs. The compiler starts
by looking at the Cons
variant, which holds a value of type i32
and a value
of type List
. Therefore, Cons
needs an amount of space equal to the size of
an i32
plus the size of a List
. To figure out how much memory the List
type needs, the compiler looks at the variants, starting with the Cons
variant. The Cons
variant holds a value of type i32
and a value of type
List
, and this process continues infinitely, as shown in Figure 15-1.
Figure 15-1: An infinite List
consisting of infinite
Cons
variants
Using Box<T>
to Get a Recursive Type with a Known Size
Rust can’t figure out how much space to allocate for recursively defined types, so the compiler gives the error in Listing 15-4. But the error does include this helpful suggestion:
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to make `List` representable
|
2 | Cons(i32, Box<List>),
| ^^^^ ^
In this suggestion, “indirection” means that instead of storing a value directly, we’ll change the data structure to store the value indirectly by storing a pointer to the value instead.
Because a Box<T>
is a pointer, Rust always knows how much space a Box<T>
needs: a pointer’s size doesn’t change based on the amount of data it’s
pointing to. This means we can put a Box<T>
inside the Cons
variant instead
of another List
value directly. The Box<T>
will point to the next List
value that will be on the heap rather than inside the Cons
variant.
Conceptually, we still have a list, created with lists “holding” other lists,
but this implementation is now more like placing the items next to one another
rather than inside one another.
We can change the definition of the List
enum in Listing 15-2 and the usage
of the List
in Listing 15-3 to the code in Listing 15-5, which will compile:
Filename: src/main.rs
enum List { Cons(i32, Box<List>), Nil, } use crate::List::{Cons, Nil}; fn main() { let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil)))))); }
Listing 15-5: Definition of List
that uses Box<T>
in
order to have a known size
The Cons
variant will need the size of an i32
plus the space to store the
box’s pointer data. The Nil
variant stores no values, so it needs less space
than the Cons
variant. We now know that any List
value will take up the
size of an i32
plus the size of a box’s pointer data. By using a box, we’ve
broken the infinite, recursive chain, so the compiler can figure out the size
it needs to store a List
value. Figure 15-2 shows what the Cons
variant
looks like now.
Figure 15-2: A List
that is not infinitely sized
because Cons
holds a Box
Boxes provide only the indirection and heap allocation; they don’t have any other special capabilities, like those we’ll see with the other smart pointer types. They also don’t have any performance overhead that these special capabilities incur, so they can be useful in cases like the cons list where the indirection is the only feature we need. We’ll look at more use cases for boxes in Chapter 17, too.
The Box<T>
type is a smart pointer because it implements the Deref
trait,
which allows Box<T>
values to be treated like references. When a Box<T>
value goes out of scope, the heap data that the box is pointing to is cleaned
up as well because of the Drop
trait implementation. Let’s explore these two
traits in more detail. These two traits will be even more important to the
functionality provided by the other smart pointer types we’ll discuss in the
rest of this chapter.
Treating Smart Pointers Like Regular References with the Deref
Trait
Implementing the Deref
trait allows you to customize the behavior of the
dereference operator, *
(as opposed to the multiplication or glob
operator). By implementing Deref
in such a way that a smart pointer can be
treated like a regular reference, you can write code that operates on
references and use that code with smart pointers too.
Let’s first look at how the dereference operator works with regular references.
Then we’ll try to define a custom type that behaves like Box<T>
, and see why
the dereference operator doesn’t work like a reference on our newly defined
type. We’ll explore how implementing the Deref
trait makes it possible for
smart pointers to work in ways similar to references. Then we’ll look at
Rust’s deref coercion feature and how it lets us work with either references
or smart pointers.
Note: there’s one big difference between the
MyBox<T>
type we’re about to build and the realBox<T>
: our version will not store its data on the heap. We are focusing this example onDeref
, so where the data is actually stored is less important than the pointer-like behavior.
Following the Pointer to the Value with the Dereference Operator
A regular reference is a type of pointer, and one way to think of a pointer is
as an arrow to a value stored somewhere else. In Listing 15-6, we create a
reference to an i32
value and then use the dereference operator to follow the
reference to the data:
Filename: src/main.rs
fn main() { let x = 5; let y = &x; assert_eq!(5, x); assert_eq!(5, *y); }
Listing 15-6: Using the dereference operator to follow a
reference to an i32
value
The variable x
holds an i32
value, 5
. We set y
equal to a reference to
x
. We can assert that x
is equal to 5
. However, if we want to make an
assertion about the value in y
, we have to use *y
to follow the reference
to the value it’s pointing to (hence dereference). Once we dereference y
,
we have access to the integer value y
is pointing to that we can compare with
5
.
If we tried to write assert_eq!(5, y);
instead, we would get this compilation
error:
$ cargo run
Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0277]: can't compare `{integer}` with `&{integer}`
--> src/main.rs:6:5
|
6 | assert_eq!(5, y);
| ^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}`
|
= help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`
= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0277`.
error: could not compile `deref-example` due to previous error
Comparing a number and a reference to a number isn’t allowed because they’re different types. We must use the dereference operator to follow the reference to the value it’s pointing to.
Using Box<T>
Like a Reference
We can rewrite the code in Listing 15-6 to use a Box<T>
instead of a
reference; the dereference operator will work as shown in Listing 15-7:
Filename: src/main.rs
fn main() { let x = 5; let y = Box::new(x); assert_eq!(5, x); assert_eq!(5, *y); }
Listing 15-7: Using the dereference operator on a
Box<i32>
The main difference between Listing 15-7 and Listing 15-6 is that here we set
y
to be an instance of a box pointing to a copied value of x
rather than a
reference pointing to the value of x
. In the last assertion, we can use the
dereference operator to follow the box’s pointer in the same way that we did
when y
was a reference. Next, we’ll explore what is special about Box<T>
that enables us to use the dereference operator by defining our own box type.
Defining Our Own Smart Pointer
Let’s build a smart pointer similar to the Box<T>
type provided by the
standard library to experience how smart pointers behave differently from
references by default. Then we’ll look at how to add the ability to use the
dereference operator.
The Box<T>
type is ultimately defined as a tuple struct with one element, so
Listing 15-8 defines a MyBox<T>
type in the same way. We’ll also define a
new
function to match the new
function defined on Box<T>
.
Filename: src/main.rs
struct MyBox<T>(T); impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } fn main() {}
Listing 15-8: Defining a MyBox<T>
type
We define a struct named MyBox
and declare a generic parameter T
, because
we want our type to hold values of any type. The MyBox
type is a tuple struct
with one element of type T
. The MyBox::new
function takes one parameter of
type T
and returns a MyBox
instance that holds the value passed in.
Let’s try adding the main
function in Listing 15-7 to Listing 15-8 and
changing it to use the MyBox<T>
type we’ve defined instead of Box<T>
. The
code in Listing 15-9 won’t compile because Rust doesn’t know how to dereference
MyBox
.
Filename: src/main.rs
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
fn main() {
let x = 5;
let y = MyBox::new(x);
assert_eq!(5, x);
assert_eq!(5, *y);
}
Listing 15-9: Attempting to use MyBox<T>
in the same
way we used references and Box<T>
Here’s the resulting compilation error:
$ cargo run
Compiling deref-example v0.1.0 (file:///projects/deref-example)
error[E0614]: type `MyBox<{integer}>` cannot be dereferenced
--> src/main.rs:14:19
|
14 | assert_eq!(5, *y);
| ^^
For more information about this error, try `rustc --explain E0614`.
error: could not compile `deref-example` due to previous error
Our MyBox<T>
type can’t be dereferenced because we haven’t implemented that
ability on our type. To enable dereferencing with the *
operator, we
implement the Deref
trait.
Treating a Type Like a Reference by Implementing the Deref
Trait
As discussed in the “Implementing a Trait on a Type” section of Chapter 10, to implement a trait, we need to provide
implementations for the trait’s required methods. The Deref
trait, provided
by the standard library, requires us to implement one method named deref
that
borrows self
and returns a reference to the inner data. Listing 15-10
contains an implementation of Deref
to add to the definition of MyBox
:
Filename: src/main.rs
use std::ops::Deref; impl<T> Deref for MyBox<T> { type Target = T; fn deref(&self) -> &Self::Target { &self.0 } } struct MyBox<T>(T); impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } fn main() { let x = 5; let y = MyBox::new(x); assert_eq!(5, x); assert_eq!(5, *y); }
Listing 15-10: Implementing Deref
on MyBox<T>
The type Target = T;
syntax defines an associated type for the Deref
trait
to use. Associated types are a slightly different way of declaring a generic
parameter, but you don’t need to worry about them for now; we’ll cover them in
more detail in Chapter 19.
We fill in the body of the deref
method with &self.0
so deref
returns a
reference to the value we want to access with the *
operator. Recall from the
“Using Tuple Structs without Named Fields to Create Different
Types” section of Chapter 5 that .0
accesses
the first value in a tuple struct. The main
function in Listing 15-9 that
calls *
on the MyBox<T>
value now compiles, and the assertions pass!
Without the Deref
trait, the compiler can only dereference &
references.
The deref
method gives the compiler the ability to take a value of any type
that implements Deref
and call the deref
method to get a &
reference that
it knows how to dereference.
When we entered *y
in Listing 15-9, behind the scenes Rust actually ran this
code:
*(y.deref())
Rust substitutes the *
operator with a call to the deref
method and then a
plain dereference so we don’t have to think about whether or not we need to
call the deref
method. This Rust feature lets us write code that functions
identically whether we have a regular reference or a type that implements
Deref
.
The reason the deref
method returns a reference to a value, and that the plain
dereference outside the parentheses in *(y.deref())
is still necessary, is the
ownership system. If the deref
method returned the value directly instead of
a reference to the value, the value would be moved out of self
. We don’t want
to take ownership of the inner value inside MyBox<T>
in this case or in most
cases where we use the dereference operator.
Note that the *
operator is replaced with a call to the deref
method and
then a call to the *
operator just once, each time we use a *
in our code.
Because the substitution of the *
operator does not recurse infinitely, we
end up with data of type i32
, which matches the 5
in assert_eq!
in
Listing 15-9.
Implicit Deref Coercions with Functions and Methods
Deref coercion is a convenience that Rust performs on arguments to functions
and methods. Deref coercion works only on types that implement the Deref
trait. Deref coercion converts a reference to such a type into a reference to
another type. For example, deref coercion can convert &String
to &str
because String
implements the Deref
trait such that it returns &str
.
Deref coercion happens automatically when we pass a reference to a particular
type’s value as an argument to a function or method that doesn’t match the
parameter type in the function or method definition. A sequence of calls to the
deref
method converts the type we provided into the type the parameter needs.
Deref coercion was added to Rust so that programmers writing function and
method calls don’t need to add as many explicit references and dereferences
with &
and *
. The deref coercion feature also lets us write more code that
can work for either references or smart pointers.
To see deref coercion in action, let’s use the MyBox<T>
type we defined in
Listing 15-8 as well as the implementation of Deref
that we added in Listing
15-10. Listing 15-11 shows the definition of a function that has a string slice
parameter:
Filename: src/main.rs
fn hello(name: &str) { println!("Hello, {}!", name); } fn main() {}
Listing 15-11: A hello
function that has the parameter
name
of type &str
We can call the hello
function with a string slice as an argument, such as
hello("Rust");
for example. Deref coercion makes it possible to call hello
with a reference to a value of type MyBox<String>
, as shown in Listing 15-12:
Filename: src/main.rs
use std::ops::Deref; impl<T> Deref for MyBox<T> { type Target = T; fn deref(&self) -> &T { &self.0 } } struct MyBox<T>(T); impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } fn hello(name: &str) { println!("Hello, {}!", name); } fn main() { let m = MyBox::new(String::from("Rust")); hello(&m); }
Listing 15-12: Calling hello
with a reference to a
MyBox<String>
value, which works because of deref coercion
Here we’re calling the hello
function with the argument &m
, which is a
reference to a MyBox<String>
value. Because we implemented the Deref
trait
on MyBox<T>
in Listing 15-10, Rust can turn &MyBox<String>
into &String
by calling deref
. The standard library provides an implementation of Deref
on String
that returns a string slice, and this is in the API documentation
for Deref
. Rust calls deref
again to turn the &String
into &str
, which
matches the hello
function’s definition.
If Rust didn’t implement deref coercion, we would have to write the code in
Listing 15-13 instead of the code in Listing 15-12 to call hello
with a value
of type &MyBox<String>
.
Filename: src/main.rs
use std::ops::Deref; impl<T> Deref for MyBox<T> { type Target = T; fn deref(&self) -> &T { &self.0 } } struct MyBox<T>(T); impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } fn hello(name: &str) { println!("Hello, {}!", name); } fn main() { let m = MyBox::new(String::from("Rust")); hello(&(*m)[..]); }
Listing 15-13: The code we would have to write if Rust didn’t have deref coercion
The (*m)
dereferences the MyBox<String>
into a String
. Then the &
and
[..]
take a string slice of the String
that is equal to the whole string to
match the signature of hello
. The code without deref coercions is harder to
read, write, and understand with all of these symbols involved. Deref coercion
allows Rust to handle these conversions for us automatically.
When the Deref
trait is defined for the types involved, Rust will analyze the
types and use Deref::deref
as many times as necessary to get a reference to
match the parameter’s type. The number of times that Deref::deref
needs to be
inserted is resolved at compile time, so there is no runtime penalty for taking
advantage of deref coercion!
How Deref Coercion Interacts with Mutability
Similar to how you use the Deref
trait to override the *
operator on
immutable references, you can use the DerefMut
trait to override the *
operator on mutable references.
Rust does deref coercion when it finds types and trait implementations in three cases:
- From
&T
to&U
whenT: Deref<Target=U>
- From
&mut T
to&mut U
whenT: DerefMut<Target=U>
- From
&mut T
to&U
whenT: Deref<Target=U>
The first two cases are the same except for mutability. The first case states
that if you have a &T
, and T
implements Deref
to some type U
, you can
get a &U
transparently. The second case states that the same deref coercion
happens for mutable references.
The third case is trickier: Rust will also coerce a mutable reference to an immutable one. But the reverse is not possible: immutable references will never coerce to mutable references. Because of the borrowing rules, if you have a mutable reference, that mutable reference must be the only reference to that data (otherwise, the program wouldn’t compile). Converting one mutable reference to one immutable reference will never break the borrowing rules. Converting an immutable reference to a mutable reference would require that the initial immutable reference is the only immutable reference to that data, but the borrowing rules don’t guarantee that. Therefore, Rust can’t make the assumption that converting an immutable reference to a mutable reference is possible.
Running Code on Cleanup with the Drop
Trait
The second trait important to the smart pointer pattern is Drop
, which lets
you customize what happens when a value is about to go out of scope. You can
provide an implementation for the Drop
trait on any type, and the code you
specify can be used to release resources like files or network connections.
We’re introducing Drop
in the context of smart pointers because the
functionality of the Drop
trait is almost always used when implementing a
smart pointer. For example, when a Box<T>
is dropped it will deallocate the space
on the heap that the box points to.
In some languages, the programmer must call code to free memory or resources every time they finish using an instance of a smart pointer. If they forget, the system might become overloaded and crash. In Rust, you can specify that a particular bit of code be run whenever a value goes out of scope, and the compiler will insert this code automatically. As a result, you don’t need to be careful about placing cleanup code everywhere in a program that an instance of a particular type is finished with—you still won’t leak resources!
Specify the code to run when a value goes out of scope by implementing the
Drop
trait. The Drop
trait requires you to implement one method named
drop
that takes a mutable reference to self
. To see when Rust calls drop
,
let’s implement drop
with println!
statements for now.
Listing 15-14 shows a CustomSmartPointer
struct whose only custom
functionality is that it will print Dropping CustomSmartPointer!
when the
instance goes out of scope. This example demonstrates when Rust runs the drop
function.
Filename: src/main.rs
struct CustomSmartPointer { data: String, } impl Drop for CustomSmartPointer { fn drop(&mut self) { println!("Dropping CustomSmartPointer with data `{}`!", self.data); } } fn main() { let c = CustomSmartPointer { data: String::from("my stuff"), }; let d = CustomSmartPointer { data: String::from("other stuff"), }; println!("CustomSmartPointers created."); }
Listing 15-14: A CustomSmartPointer
struct that
implements the Drop
trait where we would put our cleanup code
The Drop
trait is included in the prelude, so we don’t need to bring it into
scope. We implement the Drop
trait on CustomSmartPointer
and provide an
implementation for the drop
method that calls println!
. The body of the
drop
function is where you would place any logic that you wanted to run when
an instance of your type goes out of scope. We’re printing some text here to
demonstrate when Rust will call drop
.
In main
, we create two instances of CustomSmartPointer
and then print
CustomSmartPointers created
. At the end of main
, our instances of
CustomSmartPointer
will go out of scope, and Rust will call the code we put
in the drop
method, printing our final message. Note that we didn’t need to
call the drop
method explicitly.
When we run this program, we’ll see the following output:
$ cargo run
Compiling drop-example v0.1.0 (file:///projects/drop-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.60s
Running `target/debug/drop-example`
CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!
Rust automatically called drop
for us when our instances went out of scope,
calling the code we specified. Variables are dropped in the reverse order of
their creation, so d
was dropped before c
. This example gives you a visual
guide to how the drop
method works; usually you would specify the cleanup
code that your type needs to run rather than a print message.
Dropping a Value Early with std::mem::drop
Unfortunately, it’s not straightforward to disable the automatic drop
functionality. Disabling drop
isn’t usually necessary; the whole point of the
Drop
trait is that it’s taken care of automatically. Occasionally, however,
you might want to clean up a value early. One example is when using smart
pointers that manage locks: you might want to force the drop
method that
releases the lock so that other code in the same scope can acquire the lock.
Rust doesn’t let you call the Drop
trait’s drop
method manually; instead
you have to call the std::mem::drop
function provided by the standard library
if you want to force a value to be dropped before the end of its scope.
If we try to call the Drop
trait’s drop
method manually by modifying the
main
function from Listing 15-14, as shown in Listing 15-15, we’ll get a
compiler error:
Filename: src/main.rs
struct CustomSmartPointer {
data: String,
}
impl Drop for CustomSmartPointer {
fn drop(&mut self) {
println!("Dropping CustomSmartPointer with data `{}`!", self.data);
}
}
fn main() {
let c = CustomSmartPointer {
data: String::from("some data"),
};
println!("CustomSmartPointer created.");
c.drop();
println!("CustomSmartPointer dropped before the end of main.");
}
Listing 15-15: Attempting to call the drop
method from
the Drop
trait manually to clean up early
When we try to compile this code, we’ll get this error:
$ cargo run
Compiling drop-example v0.1.0 (file:///projects/drop-example)
error[E0040]: explicit use of destructor method
--> src/main.rs:16:7
|
16 | c.drop();
| --^^^^--
| | |
| | explicit destructor calls not allowed
| help: consider using `drop` function: `drop(c)`
For more information about this error, try `rustc --explain E0040`.
error: could not compile `drop-example` due to previous error
This error message states that we’re not allowed to explicitly call drop
. The
error message uses the term destructor, which is the general programming term
for a function that cleans up an instance. A destructor is analogous to a
constructor, which creates an instance. The drop
function in Rust is one
particular destructor.
Rust doesn’t let us call drop
explicitly because Rust would still
automatically call drop
on the value at the end of main
. This would be a
double free error because Rust would be trying to clean up the same value
twice.
We can’t disable the automatic insertion of drop
when a value goes out of
scope, and we can’t call the drop
method explicitly. So, if we need to force
a value to be cleaned up early, we can use the std::mem::drop
function.
The std::mem::drop
function is different from the drop
method in the Drop
trait. We call it by passing the value we want to force to be dropped early as
an argument. The function is in the prelude, so we can modify main
in Listing
15-15 to call the drop
function, as shown in Listing 15-16:
Filename: src/main.rs
struct CustomSmartPointer { data: String, } impl Drop for CustomSmartPointer { fn drop(&mut self) { println!("Dropping CustomSmartPointer with data `{}`!", self.data); } } fn main() { let c = CustomSmartPointer { data: String::from("some data"), }; println!("CustomSmartPointer created."); drop(c); println!("CustomSmartPointer dropped before the end of main."); }
Listing 15-16: Calling std::mem::drop
to explicitly
drop a value before it goes out of scope
Running this code will print the following:
$ cargo run
Compiling drop-example v0.1.0 (file:///projects/drop-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.73s
Running `target/debug/drop-example`
CustomSmartPointer created.
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main.
The text Dropping CustomSmartPointer with data `some data`!
is printed
between the CustomSmartPointer created.
and CustomSmartPointer dropped before the end of main.
text, showing that the drop
method code is called to
drop c
at that point.
You can use code specified in a Drop
trait implementation in many ways to
make cleanup convenient and safe: for instance, you could use it to create your
own memory allocator! With the Drop
trait and Rust’s ownership system, you
don’t have to remember to clean up because Rust does it automatically.
You also don’t have to worry about problems resulting from accidentally
cleaning up values still in use: the ownership system that makes sure
references are always valid also ensures that drop
gets called only once when
the value is no longer being used.
Now that we’ve examined Box<T>
and some of the characteristics of smart
pointers, let’s look at a few other smart pointers defined in the standard
library.
Rc<T>
, the Reference Counted Smart Pointer
In the majority of cases, ownership is clear: you know exactly which variable owns a given value. However, there are cases when a single value might have multiple owners. For example, in graph data structures, multiple edges might point to the same node, and that node is conceptually owned by all of the edges that point to it. A node shouldn’t be cleaned up unless it doesn’t have any edges pointing to it.
To enable multiple ownership, Rust has a type called Rc<T>
, which is an
abbreviation for reference counting. The Rc<T>
type keeps track of the
number of references to a value to determine whether or not the value is still
in use. If there are zero references to a value, the value can be cleaned up
without any references becoming invalid.
Imagine Rc<T>
as a TV in a family room. When one person enters to watch TV,
they turn it on. Others can come into the room and watch the TV. When the last
person leaves the room, they turn off the TV because it’s no longer being used.
If someone turns off the TV while others are still watching it, there would be
uproar from the remaining TV watchers!
We use the Rc<T>
type when we want to allocate some data on the heap for
multiple parts of our program to read and we can’t determine at compile time
which part will finish using the data last. If we knew which part would finish
last, we could just make that part the data’s owner, and the normal ownership
rules enforced at compile time would take effect.
Note that Rc<T>
is only for use in single-threaded scenarios. When we discuss
concurrency in Chapter 16, we’ll cover how to do reference counting in
multithreaded programs.
Using Rc<T>
to Share Data
Let’s return to our cons list example in Listing 15-5. Recall that we defined
it using Box<T>
. This time, we’ll create two lists that both share ownership
of a third list. Conceptually, this looks similar to Figure 15-3:
Figure 15-3: Two lists, b
and c
, sharing ownership of
a third list, a
We’ll create list a
that contains 5 and then 10. Then we’ll make two more
lists: b
that starts with 3 and c
that starts with 4. Both b
and c
lists will then continue on to the first a
list containing 5 and 10. In other
words, both lists will share the first list containing 5 and 10.
Trying to implement this scenario using our definition of List
with Box<T>
won’t work, as shown in Listing 15-17:
Filename: src/main.rs
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
let b = Cons(3, Box::new(a));
let c = Cons(4, Box::new(a));
}
Listing 15-17: Demonstrating we’re not allowed to have
two lists using Box<T>
that try to share ownership of a third list
When we compile this code, we get this error:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
--> src/main.rs:11:30
|
9 | let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
| - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 | let b = Cons(3, Box::new(a));
| - value moved here
11 | let c = Cons(4, Box::new(a));
| ^ value used here after move
For more information about this error, try `rustc --explain E0382`.
error: could not compile `cons-list` due to previous error
The Cons
variants own the data they hold, so when we create the b
list, a
is moved into b
and b
owns a
. Then, when we try to use a
again when
creating c
, we’re not allowed to because a
has been moved.
We could change the definition of Cons
to hold references instead, but then
we would have to specify lifetime parameters. By specifying lifetime
parameters, we would be specifying that every element in the list will live at
least as long as the entire list. This is the case for the elements and lists
in Listing 15-17, but not in every scenario.
Instead, we’ll change our definition of List
to use Rc<T>
in place of
Box<T>
, as shown in Listing 15-18. Each Cons
variant will now hold a value
and an Rc<T>
pointing to a List
. When we create b
, instead of taking
ownership of a
, we’ll clone the Rc<List>
that a
is holding, thereby
increasing the number of references from one to two and letting a
and b
share ownership of the data in that Rc<List>
. We’ll also clone a
when
creating c
, increasing the number of references from two to three. Every time
we call Rc::clone
, the reference count to the data within the Rc<List>
will
increase, and the data won’t be cleaned up unless there are zero references to
it.
Filename: src/main.rs
enum List { Cons(i32, Rc<List>), Nil, } use crate::List::{Cons, Nil}; use std::rc::Rc; fn main() { let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); let b = Cons(3, Rc::clone(&a)); let c = Cons(4, Rc::clone(&a)); }
Listing 15-18: A definition of List
that uses
Rc<T>
We need to add a use
statement to bring Rc<T>
into scope because it’s not
in the prelude. In main
, we create the list holding 5 and 10 and store it in
a new Rc<List>
in a
. Then when we create b
and c
, we call the
Rc::clone
function and pass a reference to the Rc<List>
in a
as an
argument.
We could have called a.clone()
rather than Rc::clone(&a)
, but Rust’s
convention is to use Rc::clone
in this case. The implementation of
Rc::clone
doesn’t make a deep copy of all the data like most types’
implementations of clone
do. The call to Rc::clone
only increments the
reference count, which doesn’t take much time. Deep copies of data can take a
lot of time. By using Rc::clone
for reference counting, we can visually
distinguish between the deep-copy kinds of clones and the kinds of clones that
increase the reference count. When looking for performance problems in the
code, we only need to consider the deep-copy clones and can disregard calls to
Rc::clone
.
Cloning an Rc<T>
Increases the Reference Count
Let’s change our working example in Listing 15-18 so we can see the reference
counts changing as we create and drop references to the Rc<List>
in a
.
In Listing 15-19, we’ll change main
so it has an inner scope around list c
;
then we can see how the reference count changes when c
goes out of scope.
Filename: src/main.rs
enum List { Cons(i32, Rc<List>), Nil, } use crate::List::{Cons, Nil}; use std::rc::Rc; fn main() { let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); println!("count after creating a = {}", Rc::strong_count(&a)); let b = Cons(3, Rc::clone(&a)); println!("count after creating b = {}", Rc::strong_count(&a)); { let c = Cons(4, Rc::clone(&a)); println!("count after creating c = {}", Rc::strong_count(&a)); } println!("count after c goes out of scope = {}", Rc::strong_count(&a)); }
Listing 15-19: Printing the reference count
At each point in the program where the reference count changes, we print the
reference count, which we can get by calling the Rc::strong_count
function.
This function is named strong_count
rather than count
because the Rc<T>
type also has a weak_count
; we’ll see what weak_count
is used for in the
“Preventing Reference Cycles: Turning an Rc<T>
into a
Weak<T>
” section.
This code prints the following:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished dev [unoptimized + debuginfo] target(s) in 0.45s
Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2
We can see that the Rc<List>
in a
has an initial reference count of 1; then
each time we call clone
, the count goes up by 1. When c
goes out of scope,
the count goes down by 1. We don’t have to call a function to decrease the
reference count like we have to call Rc::clone
to increase the reference
count: the implementation of the Drop
trait decreases the reference count
automatically when an Rc<T>
value goes out of scope.
What we can’t see in this example is that when b
and then a
go out of scope
at the end of main
, the count is then 0, and the Rc<List>
is cleaned up
completely at that point. Using Rc<T>
allows a single value to have
multiple owners, and the count ensures that the value remains valid as long as
any of the owners still exist.
Via immutable references, Rc<T>
allows you to share data between multiple
parts of your program for reading only. If Rc<T>
allowed you to have multiple
mutable references too, you might violate one of the borrowing rules discussed
in Chapter 4: multiple mutable borrows to the same place can cause data races
and inconsistencies. But being able to mutate data is very useful! In the next
section, we’ll discuss the interior mutability pattern and the RefCell<T>
type that you can use in conjunction with an Rc<T>
to work with this
immutability restriction.
RefCell<T>
and the Interior Mutability Pattern
Interior mutability is a design pattern in Rust that allows you to mutate
data even when there are immutable references to that data; normally, this
action is disallowed by the borrowing rules. To mutate data, the pattern uses
unsafe
code inside a data structure to bend Rust’s usual rules that govern
mutation and borrowing. We haven’t yet covered unsafe code; we will in Chapter
19. We can use types that use the interior mutability pattern when we can
ensure that the borrowing rules will be followed at runtime, even though the
compiler can’t guarantee that. The unsafe
code involved is then wrapped in a
safe API, and the outer type is still immutable.
Let’s explore this concept by looking at the RefCell<T>
type that follows the
interior mutability pattern.
Enforcing Borrowing Rules at Runtime with RefCell<T>
Unlike Rc<T>
, the RefCell<T>
type represents single ownership over the data
it holds. So, what makes RefCell<T>
different from a type like Box<T>
?
Recall the borrowing rules you learned in Chapter 4:
- At any given time, you can have either (but not both of) one mutable reference or any number of immutable references.
- References must always be valid.
With references and Box<T>
, the borrowing rules’ invariants are enforced at
compile time. With RefCell<T>
, these invariants are enforced at runtime.
With references, if you break these rules, you’ll get a compiler error. With
RefCell<T>
, if you break these rules, your program will panic and exit.
The advantages of checking the borrowing rules at compile time are that errors will be caught sooner in the development process, and there is no impact on runtime performance because all the analysis is completed beforehand. For those reasons, checking the borrowing rules at compile time is the best choice in the majority of cases, which is why this is Rust’s default.
The advantage of checking the borrowing rules at runtime instead is that certain memory-safe scenarios are then allowed, whereas they are disallowed by the compile-time checks. Static analysis, like the Rust compiler, is inherently conservative. Some properties of code are impossible to detect by analyzing the code: the most famous example is the Halting Problem, which is beyond the scope of this book but is an interesting topic to research.
Because some analysis is impossible, if the Rust compiler can’t be sure the
code complies with the ownership rules, it might reject a correct program; in
this way, it’s conservative. If Rust accepted an incorrect program, users
wouldn’t be able to trust in the guarantees Rust makes. However, if Rust
rejects a correct program, the programmer will be inconvenienced, but nothing
catastrophic can occur. The RefCell<T>
type is useful when you’re sure your
code follows the borrowing rules but the compiler is unable to understand and
guarantee that.
Similar to Rc<T>
, RefCell<T>
is only for use in single-threaded scenarios
and will give you a compile-time error if you try using it in a multithreaded
context. We’ll talk about how to get the functionality of RefCell<T>
in a
multithreaded program in Chapter 16.
Here is a recap of the reasons to choose Box<T>
, Rc<T>
, or RefCell<T>
:
Rc<T>
enables multiple owners of the same data;Box<T>
andRefCell<T>
have single owners.Box<T>
allows immutable or mutable borrows checked at compile time;Rc<T>
allows only immutable borrows checked at compile time;RefCell<T>
allows immutable or mutable borrows checked at runtime.- Because
RefCell<T>
allows mutable borrows checked at runtime, you can mutate the value inside theRefCell<T>
even when theRefCell<T>
is immutable.
Mutating the value inside an immutable value is the interior mutability pattern. Let’s look at a situation in which interior mutability is useful and examine how it’s possible.
Interior Mutability: A Mutable Borrow to an Immutable Value
A consequence of the borrowing rules is that when you have an immutable value, you can’t borrow it mutably. For example, this code won’t compile:
fn main() {
let x = 5;
let y = &mut x;
}
If you tried to compile this code, you’d get the following error:
$ cargo run
Compiling borrowing v0.1.0 (file:///projects/borrowing)
error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
--> src/main.rs:3:13
|
2 | let x = 5;
| - help: consider changing this to be mutable: `mut x`
3 | let y = &mut x;
| ^^^^^^ cannot borrow as mutable
For more information about this error, try `rustc --explain E0596`.
error: could not compile `borrowing` due to previous error
However, there are situations in which it would be useful for a value to mutate
itself in its methods but appear immutable to other code. Code outside the
value’s methods would not be able to mutate the value. Using RefCell<T>
is
one way to get the ability to have interior mutability. But RefCell<T>
doesn’t get around the borrowing rules completely: the borrow checker in the
compiler allows this interior mutability, and the borrowing rules are checked
at runtime instead. If you violate the rules, you’ll get a panic!
instead of
a compiler error.
Let’s work through a practical example where we can use RefCell<T>
to mutate
an immutable value and see why that is useful.
A Use Case for Interior Mutability: Mock Objects
A test double is the general programming concept for a type used in place of another type during testing. Mock objects are specific types of test doubles that record what happens during a test so you can assert that the correct actions took place.
Rust doesn’t have objects in the same sense as other languages have objects, and Rust doesn’t have mock object functionality built into the standard library as some other languages do. However, you can definitely create a struct that will serve the same purposes as a mock object.
Here’s the scenario we’ll test: we’ll create a library that tracks a value against a maximum value and sends messages based on how close to the maximum value the current value is. This library could be used to keep track of a user’s quota for the number of API calls they’re allowed to make, for example.
Our library will only provide the functionality of tracking how close to the
maximum a value is and what the messages should be at what times. Applications
that use our library will be expected to provide the mechanism for sending the
messages: the application could put a message in the application, send an
email, send a text message, or something else. The library doesn’t need to know
that detail. All it needs is something that implements a trait we’ll provide
called Messenger
. Listing 15-20 shows the library code:
Filename: src/lib.rs
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
Listing 15-20: A library to keep track of how close a value is to a maximum value and warn when the value is at certain levels
One important part of this code is that the Messenger
trait has one method
called send
that takes an immutable reference to self
and the text of the
message. This trait is the interface our mock object needs to implement so that
the mock can be used in the same way a real object is. The other important part
is that we want to test the behavior of the set_value
method on the
LimitTracker
. We can change what we pass in for the value
parameter, but
set_value
doesn’t return anything for us to make assertions on. We want to be
able to say that if we create a LimitTracker
with something that implements
the Messenger
trait and a particular value for max
, when we pass different
numbers for value
, the messenger is told to send the appropriate messages.
We need a mock object that, instead of sending an email or text message when we
call send
, will only keep track of the messages it’s told to send. We can
create a new instance of the mock object, create a LimitTracker
that uses the
mock object, call the set_value
method on LimitTracker
, and then check that
the mock object has the messages we expect. Listing 15-21 shows an attempt to
implement a mock object to do just that, but the borrow checker won’t allow it:
Filename: src/lib.rs
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
struct MockMessenger {
sent_messages: Vec<String>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: vec![],
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
self.sent_messages.push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.len(), 1);
}
}
Listing 15-21: An attempt to implement a MockMessenger
that isn’t allowed by the borrow checker
This test code defines a MockMessenger
struct that has a sent_messages
field with a Vec
of String
values to keep track of the messages it’s told
to send. We also define an associated function new
to make it convenient to
create new MockMessenger
values that start with an empty list of messages. We
then implement the Messenger
trait for MockMessenger
so we can give a
MockMessenger
to a LimitTracker
. In the definition of the send
method, we
take the message passed in as a parameter and store it in the MockMessenger
list of sent_messages
.
In the test, we’re testing what happens when the LimitTracker
is told to set
value
to something that is more than 75 percent of the max
value. First, we
create a new MockMessenger
, which will start with an empty list of messages.
Then we create a new LimitTracker
and give it a reference to the new
MockMessenger
and a max
value of 100. We call the set_value
method on the
LimitTracker
with a value of 80, which is more than 75 percent of 100. Then
we assert that the list of messages that the MockMessenger
is keeping track
of should now have one message in it.
However, there’s one problem with this test, as shown here:
$ cargo test
Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
error[E0596]: cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference
--> src/lib.rs:58:13
|
2 | fn send(&self, msg: &str);
| ----- help: consider changing that to be a mutable reference: `&mut self`
...
58 | self.sent_messages.push(String::from(message));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be borrowed as mutable
For more information about this error, try `rustc --explain E0596`.
error: could not compile `limit-tracker` due to previous error
warning: build failed, waiting for other jobs to finish...
error: build failed
We can’t modify the MockMessenger
to keep track of the messages, because the
send
method takes an immutable reference to self
. We also can’t take the
suggestion from the error text to use &mut self
instead, because then the
signature of send
wouldn’t match the signature in the Messenger
trait
definition (feel free to try and see what error message you get).
This is a situation in which interior mutability can help! We’ll store the
sent_messages
within a RefCell<T>
, and then the send
method will be
able to modify sent_messages
to store the messages we’ve seen. Listing 15-22
shows what that looks like:
Filename: src/lib.rs
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
struct MockMessenger {
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: RefCell::new(vec![]),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
self.sent_messages.borrow_mut().push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
// --snip--
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}
}
Listing 15-22: Using RefCell<T>
to mutate an inner
value while the outer value is considered immutable
The sent_messages
field is now of type RefCell<Vec<String>>
instead of
Vec<String>
. In the new
function, we create a new RefCell<Vec<String>>
instance around the empty vector.
For the implementation of the send
method, the first parameter is still an
immutable borrow of self
, which matches the trait definition. We call
borrow_mut
on the RefCell<Vec<String>>
in self.sent_messages
to get a
mutable reference to the value inside the RefCell<Vec<String>>
, which is
the vector. Then we can call push
on the mutable reference to the vector to
keep track of the messages sent during the test.
The last change we have to make is in the assertion: to see how many items are
in the inner vector, we call borrow
on the RefCell<Vec<String>>
to get an
immutable reference to the vector.
Now that you’ve seen how to use RefCell<T>
, let’s dig into how it works!
Keeping Track of Borrows at Runtime with RefCell<T>
When creating immutable and mutable references, we use the &
and &mut
syntax, respectively. With RefCell<T>
, we use the borrow
and borrow_mut
methods, which are part of the safe API that belongs to RefCell<T>
. The
borrow
method returns the smart pointer type Ref<T>
, and borrow_mut
returns the smart pointer type RefMut<T>
. Both types implement Deref
, so we
can treat them like regular references.
The RefCell<T>
keeps track of how many Ref<T>
and RefMut<T>
smart
pointers are currently active. Every time we call borrow
, the RefCell<T>
increases its count of how many immutable borrows are active. When a Ref<T>
value goes out of scope, the count of immutable borrows goes down by one. Just
like the compile-time borrowing rules, RefCell<T>
lets us have many immutable
borrows or one mutable borrow at any point in time.
If we try to violate these rules, rather than getting a compiler error as we
would with references, the implementation of RefCell<T>
will panic at
runtime. Listing 15-23 shows a modification of the implementation of send
in
Listing 15-22. We’re deliberately trying to create two mutable borrows active
for the same scope to illustrate that RefCell<T>
prevents us from doing this
at runtime.
Filename: src/lib.rs
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
struct MockMessenger {
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: RefCell::new(vec![]),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
let mut one_borrow = self.sent_messages.borrow_mut();
let mut two_borrow = self.sent_messages.borrow_mut();
one_borrow.push(String::from(message));
two_borrow.push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}
}
Listing 15-23: Creating two mutable references in the
same scope to see that RefCell<T>
will panic
We create a variable one_borrow
for the RefMut<T>
smart pointer returned
from borrow_mut
. Then we create another mutable borrow in the same way in the
variable two_borrow
. This makes two mutable references in the same scope,
which isn’t allowed. When we run the tests for our library, the code in Listing
15-23 will compile without any errors, but the test will fail:
$ cargo test
Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
Finished test [unoptimized + debuginfo] target(s) in 0.91s
Running unittests (target/debug/deps/limit_tracker-e599811fa246dbde)
running 1 test
test tests::it_sends_an_over_75_percent_warning_message ... FAILED
failures:
---- tests::it_sends_an_over_75_percent_warning_message stdout ----
thread 'main' panicked at 'already borrowed: BorrowMutError', src/lib.rs:60:53
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::it_sends_an_over_75_percent_warning_message
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass '--lib'
Notice that the code panicked with the message already borrowed: BorrowMutError
. This is how RefCell<T>
handles violations of the borrowing
rules at runtime.
Catching borrowing errors at runtime rather than compile time means that you
would find a mistake in your code later in the development process and possibly
not until your code was deployed to production. Also, your code would incur a
small runtime performance penalty as a result of keeping track of the borrows
at runtime rather than compile time. However, using RefCell<T>
makes it
possible to write a mock object that can modify itself to keep track of the
messages it has seen while you’re using it in a context where only immutable
values are allowed. You can use RefCell<T>
despite its trade-offs to get more
functionality than regular references provide.
Having Multiple Owners of Mutable Data by Combining Rc<T>
and RefCell<T>
A common way to use RefCell<T>
is in combination with Rc<T>
. Recall that
Rc<T>
lets you have multiple owners of some data, but it only gives immutable
access to that data. If you have an Rc<T>
that holds a RefCell<T>
, you can
get a value that can have multiple owners and that you can mutate!
For example, recall the cons list example in Listing 15-18 where we used
Rc<T>
to allow multiple lists to share ownership of another list. Because
Rc<T>
holds only immutable values, we can’t change any of the values in the
list once we’ve created them. Let’s add in RefCell<T>
to gain the ability to
change the values in the lists. Listing 15-24 shows that by using a
RefCell<T>
in the Cons
definition, we can modify the value stored in all
the lists:
Filename: src/main.rs
#[derive(Debug)] enum List { Cons(Rc<RefCell<i32>>, Rc<List>), Nil, } use crate::List::{Cons, Nil}; use std::cell::RefCell; use std::rc::Rc; fn main() { let value = Rc::new(RefCell::new(5)); let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil))); let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a)); let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a)); *value.borrow_mut() += 10; println!("a after = {:?}", a); println!("b after = {:?}", b); println!("c after = {:?}", c); }
Listing 15-24: Using Rc<RefCell<i32>>
to create a
List
that we can mutate
We create a value that is an instance of Rc<RefCell<i32>>
and store it in a
variable named value
so we can access it directly later. Then we create a
List
in a
with a Cons
variant that holds value
. We need to clone
value
so both a
and value
have ownership of the inner 5
value rather
than transferring ownership from value
to a
or having a
borrow from
value
.
We wrap the list a
in an Rc<T>
so when we create lists b
and c
, they
can both refer to a
, which is what we did in Listing 15-18.
After we’ve created the lists in a
, b
, and c
, we add 10 to the value in
value
. We do this by calling borrow_mut
on value
, which uses the
automatic dereferencing feature we discussed in Chapter 5 (see the section
“Where’s the ->
Operator?”) to
dereference the Rc<T>
to the inner RefCell<T>
value. The borrow_mut
method returns a RefMut<T>
smart pointer, and we use the dereference operator
on it and change the inner value.
When we print a
, b
, and c
, we can see that they all have the modified
value of 15 rather than 5:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished dev [unoptimized + debuginfo] target(s) in 0.63s
Running `target/debug/cons-list`
a after = Cons(RefCell { value: 15 }, Nil)
b after = Cons(RefCell { value: 3 }, Cons(RefCell { value: 15 }, Nil))
c after = Cons(RefCell { value: 4 }, Cons(RefCell { value: 15 }, Nil))
This technique is pretty neat! By using RefCell<T>
, we have an outwardly
immutable List
value. But we can use the methods on RefCell<T>
that provide
access to its interior mutability so we can modify our data when we need to.
The runtime checks of the borrowing rules protect us from data races, and it’s
sometimes worth trading a bit of speed for this flexibility in our data
structures.
The standard library has other types that provide interior mutability, such as
Cell<T>
, which is similar except that instead of giving references to the
inner value, the value is copied in and out of the Cell<T>
. There’s also
Mutex<T>
, which offers interior mutability that’s safe to use across threads;
we’ll discuss its use in Chapter 16. Check out the standard library docs for
more details on the differences between these types.
Reference Cycles Can Leak Memory
Rust’s memory safety guarantees make it difficult, but not impossible, to
accidentally create memory that is never cleaned up (known as a memory leak).
Preventing memory leaks entirely is not one of Rust’s guarantees, meaning
memory leaks are memory safe in Rust. We can see that Rust allows memory leaks
by using Rc<T>
and RefCell<T>
: it’s possible to create references where
items refer to each other in a cycle. This creates memory leaks because the
reference count of each item in the cycle will never reach 0, and the values
will never be dropped.
Creating a Reference Cycle
Let’s look at how a reference cycle might happen and how to prevent it,
starting with the definition of the List
enum and a tail
method in Listing
15-25:
Filename: src/main.rs
use crate::List::{Cons, Nil}; use std::cell::RefCell; use std::rc::Rc; #[derive(Debug)] enum List { Cons(i32, RefCell<Rc<List>>), Nil, } impl List { fn tail(&self) -> Option<&RefCell<Rc<List>>> { match self { Cons(_, item) => Some(item), Nil => None, } } } fn main() {}
Listing 15-25: A cons list definition that holds a
RefCell<T>
so we can modify what a Cons
variant is referring to
We’re using another variation of the List
definition from Listing 15-5. The
second element in the Cons
variant is now RefCell<Rc<List>>
, meaning that
instead of having the ability to modify the i32
value as we did in Listing
15-24, we want to modify which List
value a Cons
variant is pointing to.
We’re also adding a tail
method to make it convenient for us to access the
second item if we have a Cons
variant.
In Listing 15-26, we’re adding a main
function that uses the definitions in
Listing 15-25. This code creates a list in a
and a list in b
that points to
the list in a
. Then it modifies the list in a
to point to b
, creating a
reference cycle. There are println!
statements along the way to show what the
reference counts are at various points in this process.
Filename: src/main.rs
use crate::List::{Cons, Nil}; use std::cell::RefCell; use std::rc::Rc; #[derive(Debug)] enum List { Cons(i32, RefCell<Rc<List>>), Nil, } impl List { fn tail(&self) -> Option<&RefCell<Rc<List>>> { match self { Cons(_, item) => Some(item), Nil => None, } } } fn main() { let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil)))); println!("a initial rc count = {}", Rc::strong_count(&a)); println!("a next item = {:?}", a.tail()); let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a)))); println!("a rc count after b creation = {}", Rc::strong_count(&a)); println!("b initial rc count = {}", Rc::strong_count(&b)); println!("b next item = {:?}", b.tail()); if let Some(link) = a.tail() { *link.borrow_mut() = Rc::clone(&b); } println!("b rc count after changing a = {}", Rc::strong_count(&b)); println!("a rc count after changing a = {}", Rc::strong_count(&a)); // Uncomment the next line to see that we have a cycle; // it will overflow the stack // println!("a next item = {:?}", a.tail()); }
Listing 15-26: Creating a reference cycle of two List
values pointing to each other
We create an Rc<List>
instance holding a List
value in the variable a
with an initial list of 5, Nil
. We then create an Rc<List>
instance
holding another List
value in the variable b
that contains the value 10 and
points to the list in a
.
We modify a
so it points to b
instead of Nil
, creating a cycle. We
do that by using the tail
method to get a reference to the
RefCell<Rc<List>>
in a
, which we put in the variable link
. Then we use
the borrow_mut
method on the RefCell<Rc<List>>
to change the value inside
from an Rc<List>
that holds a Nil
value to the Rc<List>
in b
.
When we run this code, keeping the last println!
commented out for the
moment, we’ll get this output:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished dev [unoptimized + debuginfo] target(s) in 0.53s
Running `target/debug/cons-list`
a initial rc count = 1
a next item = Some(RefCell { value: Nil })
a rc count after b creation = 2
b initial rc count = 1
b next item = Some(RefCell { value: Cons(5, RefCell { value: Nil }) })
b rc count after changing a = 2
a rc count after changing a = 2
The reference count of the Rc<List>
instances in both a
and b
are 2 after
we change the list in a
to point to b
. At the end of main
, Rust drops the
variable b
, which decreases the reference count of the Rc<List>
instance
from 2 to 1. The memory that Rc<List>
has on the heap won’t be dropped at
this point, because its reference count is 1, not 0. Then Rust drops a
, which
decreases the reference count of the a
Rc<List>
instance from 2 to 1 as
well. This instance’s memory can’t be dropped either, because the other
Rc<List>
instance still refers to it. The memory allocated to the list will
remain uncollected forever. To visualize this reference cycle, we’ve created a
diagram in Figure 15-4.
Figure 15-4: A reference cycle of lists a
and b
pointing to each other
If you uncomment the last println!
and run the program, Rust will try to
print this cycle with a
pointing to b
pointing to a
and so forth until it
overflows the stack.
In this case, right after we create the reference cycle, the program ends. The consequences of this cycle aren’t very dire. However, if a more complex program allocated lots of memory in a cycle and held onto it for a long time, the program would use more memory than it needed and might overwhelm the system, causing it to run out of available memory.
Creating reference cycles is not easily done, but it’s not impossible either.
If you have RefCell<T>
values that contain Rc<T>
values or similar nested
combinations of types with interior mutability and reference counting, you must
ensure that you don’t create cycles; you can’t rely on Rust to catch them.
Creating a reference cycle would be a logic bug in your program that you should
use automated tests, code reviews, and other software development practices to
minimize.
Another solution for avoiding reference cycles is reorganizing your data
structures so that some references express ownership and some references don’t.
As a result, you can have cycles made up of some ownership relationships and
some non-ownership relationships, and only the ownership relationships affect
whether or not a value can be dropped. In Listing 15-25, we always want Cons
variants to own their list, so reorganizing the data structure isn’t possible.
Let’s look at an example using graphs made up of parent nodes and child nodes
to see when non-ownership relationships are an appropriate way to prevent
reference cycles.
Preventing Reference Cycles: Turning an Rc<T>
into a Weak<T>
So far, we’ve demonstrated that calling Rc::clone
increases the
strong_count
of an Rc<T>
instance, and an Rc<T>
instance is only cleaned
up if its strong_count
is 0. You can also create a weak reference to the
value within an Rc<T>
instance by calling Rc::downgrade
and passing a
reference to the Rc<T>
. When you call Rc::downgrade
, you get a smart
pointer of type Weak<T>
. Instead of increasing the strong_count
in the
Rc<T>
instance by 1, calling Rc::downgrade
increases the weak_count
by 1.
The Rc<T>
type uses weak_count
to keep track of how many Weak<T>
references exist, similar to strong_count
. The difference is the weak_count
doesn’t need to be 0 for the Rc<T>
instance to be cleaned up.
Strong references are how you can share ownership of an Rc<T>
instance. Weak
references don’t express an ownership relationship. They won’t cause a
reference cycle because any cycle involving some weak references will be broken
once the strong reference count of values involved is 0.
Because the value that Weak<T>
references might have been dropped, to do
anything with the value that a Weak<T>
is pointing to, you must make sure the
value still exists. Do this by calling the upgrade
method on a Weak<T>
instance, which will return an Option<Rc<T>>
. You’ll get a result of Some
if the Rc<T>
value has not been dropped yet and a result of None
if the
Rc<T>
value has been dropped. Because upgrade
returns an Option<Rc<T>>
,
Rust will ensure that the Some
case and the None
case are handled, and
there won’t be an invalid pointer.
As an example, rather than using a list whose items know only about the next item, we’ll create a tree whose items know about their children items and their parent items.
Creating a Tree Data Structure: a Node
with Child Nodes
To start, we’ll build a tree with nodes that know about their child nodes.
We’ll create a struct named Node
that holds its own i32
value as well as
references to its children Node
values:
Filename: src/main.rs
use std::cell::RefCell; use std::rc::Rc; #[derive(Debug)] struct Node { value: i32, children: RefCell<Vec<Rc<Node>>>, } fn main() { let leaf = Rc::new(Node { value: 3, children: RefCell::new(vec![]), }); let branch = Rc::new(Node { value: 5, children: RefCell::new(vec![Rc::clone(&leaf)]), }); }
We want a Node
to own its children, and we want to share that ownership with
variables so we can access each Node
in the tree directly. To do this, we
define the Vec<T>
items to be values of type Rc<Node>
. We also want to
modify which nodes are children of another node, so we have a RefCell<T>
in
children
around the Vec<Rc<Node>>
.
Next, we’ll use our struct definition and create one Node
instance named
leaf
with the value 3 and no children, and another instance named branch
with the value 5 and leaf
as one of its children, as shown in Listing 15-27:
Filename: src/main.rs
use std::cell::RefCell; use std::rc::Rc; #[derive(Debug)] struct Node { value: i32, children: RefCell<Vec<Rc<Node>>>, } fn main() { let leaf = Rc::new(Node { value: 3, children: RefCell::new(vec![]), }); let branch = Rc::new(Node { value: 5, children: RefCell::new(vec![Rc::clone(&leaf)]), }); }
Listing 15-27: Creating a leaf
node with no children
and a branch
node with leaf
as one of its children
We clone the Rc<Node>
in leaf
and store that in branch
, meaning the
Node
in leaf
now has two owners: leaf
and branch
. We can get from
branch
to leaf
through branch.children
, but there’s no way to get from
leaf
to branch
. The reason is that leaf
has no reference to branch
and
doesn’t know they’re related. We want leaf
to know that branch
is its
parent. We’ll do that next.
Adding a Reference from a Child to Its Parent
To make the child node aware of its parent, we need to add a parent
field to
our Node
struct definition. The trouble is in deciding what the type of
parent
should be. We know it can’t contain an Rc<T>
, because that would
create a reference cycle with leaf.parent
pointing to branch
and
branch.children
pointing to leaf
, which would cause their strong_count
values to never be 0.
Thinking about the relationships another way, a parent node should own its children: if a parent node is dropped, its child nodes should be dropped as well. However, a child should not own its parent: if we drop a child node, the parent should still exist. This is a case for weak references!
So instead of Rc<T>
, we’ll make the type of parent
use Weak<T>
,
specifically a RefCell<Weak<Node>>
. Now our Node
struct definition looks
like this:
Filename: src/main.rs
use std::cell::RefCell; use std::rc::{Rc, Weak}; #[derive(Debug)] struct Node { value: i32, parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, } fn main() { let leaf = Rc::new(Node { value: 3, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]), }); println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch); println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); }
A node will be able to refer to its parent node but doesn’t own its parent.
In Listing 15-28, we update main
to use this new definition so the leaf
node will have a way to refer to its parent, branch
:
Filename: src/main.rs
use std::cell::RefCell; use std::rc::{Rc, Weak}; #[derive(Debug)] struct Node { value: i32, parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, } fn main() { let leaf = Rc::new(Node { value: 3, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]), }); println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch); println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); }
Listing 15-28: A leaf
node with a weak reference to its
parent node branch
Creating the leaf
node looks similar to how creating the leaf
node looked
in Listing 15-27 with the exception of the parent
field: leaf
starts out
without a parent, so we create a new, empty Weak<Node>
reference instance.
At this point, when we try to get a reference to the parent of leaf
by using
the upgrade
method, we get a None
value. We see this in the output from the
first println!
statement:
leaf parent = None
When we create the branch
node, it will also have a new Weak<Node>
reference in the parent
field, because branch
doesn’t have a parent node.
We still have leaf
as one of the children of branch
. Once we have the
Node
instance in branch
, we can modify leaf
to give it a Weak<Node>
reference to its parent. We use the borrow_mut
method on the
RefCell<Weak<Node>>
in the parent
field of leaf
, and then we use the
Rc::downgrade
function to create a Weak<Node>
reference to branch
from
the Rc<Node>
in branch.
When we print the parent of leaf
again, this time we’ll get a Some
variant
holding branch
: now leaf
can access its parent! When we print leaf
, we
also avoid the cycle that eventually ended in a stack overflow like we had in
Listing 15-26; the Weak<Node>
references are printed as (Weak)
:
leaf parent = Some(Node { value: 5, parent: RefCell { value: (Weak) },
children: RefCell { value: [Node { value: 3, parent: RefCell { value: (Weak) },
children: RefCell { value: [] } }] } })
The lack of infinite output indicates that this code didn’t create a reference
cycle. We can also tell this by looking at the values we get from calling
Rc::strong_count
and Rc::weak_count
.
Visualizing Changes to strong_count
and weak_count
Let’s look at how the strong_count
and weak_count
values of the Rc<Node>
instances change by creating a new inner scope and moving the creation of
branch
into that scope. By doing so, we can see what happens when branch
is
created and then dropped when it goes out of scope. The modifications are shown
in Listing 15-29:
Filename: src/main.rs
use std::cell::RefCell; use std::rc::{Rc, Weak}; #[derive(Debug)] struct Node { value: i32, parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, } fn main() { let leaf = Rc::new(Node { value: 3, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]), }); println!( "leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf), ); { let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch); println!( "branch strong = {}, weak = {}", Rc::strong_count(&branch), Rc::weak_count(&branch), ); println!( "leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf), ); } println!("leaf parent = {:?}", leaf.parent.borrow().upgrade()); println!( "leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf), ); }
Listing 15-29: Creating branch
in an inner scope and
examining strong and weak reference counts
After leaf
is created, its Rc<Node>
has a strong count of 1 and a weak
count of 0. In the inner scope, we create branch
and associate it with
leaf
, at which point when we print the counts, the Rc<Node>
in branch
will have a strong count of 1 and a weak count of 1 (for leaf.parent
pointing
to branch
with a Weak<Node>
). When we print the counts in leaf
, we’ll see
it will have a strong count of 2, because branch
now has a clone of the
Rc<Node>
of leaf
stored in branch.children
, but will still have a weak
count of 0.
When the inner scope ends, branch
goes out of scope and the strong count of
the Rc<Node>
decreases to 0, so its Node
is dropped. The weak count of 1
from leaf.parent
has no bearing on whether or not Node
is dropped, so we
don’t get any memory leaks!
If we try to access the parent of leaf
after the end of the scope, we’ll get
None
again. At the end of the program, the Rc<Node>
in leaf
has a strong
count of 1 and a weak count of 0, because the variable leaf
is now the only
reference to the Rc<Node>
again.
All of the logic that manages the counts and value dropping is built into
Rc<T>
and Weak<T>
and their implementations of the Drop
trait. By
specifying that the relationship from a child to its parent should be a
Weak<T>
reference in the definition of Node
, you’re able to have parent
nodes point to child nodes and vice versa without creating a reference cycle
and memory leaks.
Summary
This chapter covered how to use smart pointers to make different guarantees and
trade-offs from those Rust makes by default with regular references. The
Box<T>
type has a known size and points to data allocated on the heap. The
Rc<T>
type keeps track of the number of references to data on the heap so
that data can have multiple owners. The RefCell<T>
type with its interior
mutability gives us a type that we can use when we need an immutable type but
need to change an inner value of that type; it also enforces the borrowing
rules at runtime instead of at compile time.
Also discussed were the Deref
and Drop
traits, which enable a lot of the
functionality of smart pointers. We explored reference cycles that can cause
memory leaks and how to prevent them using Weak<T>
.
If this chapter has piqued your interest and you want to implement your own smart pointers, check out “The Rustonomicon” for more useful information.
Next, we’ll talk about concurrency in Rust. You’ll even learn about a few new smart pointers.
Fearless Concurrency
Handling concurrent programming safely and efficiently is another of Rust’s major goals. Concurrent programming, where different parts of a program execute independently, and parallel programming, where different parts of a program execute at the same time, are becoming increasingly important as more computers take advantage of their multiple processors. Historically, programming in these contexts has been difficult and error prone: Rust hopes to change that.
Initially, the Rust team thought that ensuring memory safety and preventing concurrency problems were two separate challenges to be solved with different methods. Over time, the team discovered that the ownership and type systems are a powerful set of tools to help manage memory safety and concurrency problems! By leveraging ownership and type checking, many concurrency errors are compile-time errors in Rust rather than runtime errors. Therefore, rather than making you spend lots of time trying to reproduce the exact circumstances under which a runtime concurrency bug occurs, incorrect code will refuse to compile and present an error explaining the problem. As a result, you can fix your code while you’re working on it rather than potentially after it has been shipped to production. We’ve nicknamed this aspect of Rust fearless concurrency. Fearless concurrency allows you to write code that is free of subtle bugs and is easy to refactor without introducing new bugs.
Note: For simplicity’s sake, we’ll refer to many of the problems as concurrent rather than being more precise by saying concurrent and/or parallel. If this book were about concurrency and/or parallelism, we’d be more specific. For this chapter, please mentally substitute concurrent and/or parallel whenever we use concurrent.
Many languages are dogmatic about the solutions they offer for handling concurrent problems. For example, Erlang has elegant functionality for message-passing concurrency but has only obscure ways to share state between threads. Supporting only a subset of possible solutions is a reasonable strategy for higher-level languages, because a higher-level language promises benefits from giving up some control to gain abstractions. However, lower-level languages are expected to provide the solution with the best performance in any given situation and have fewer abstractions over the hardware. Therefore, Rust offers a variety of tools for modeling problems in whatever way is appropriate for your situation and requirements.
Here are the topics we’ll cover in this chapter:
- How to create threads to run multiple pieces of code at the same time
- Message-passing concurrency, where channels send messages between threads
- Shared-state concurrency, where multiple threads have access to some piece of data
- The
Sync
andSend
traits, which extend Rust’s concurrency guarantees to user-defined types as well as types provided by the standard library
Using Threads to Run Code Simultaneously
In most current operating systems, an executed program’s code is run in a process, and the operating system manages multiple processes at once. Within your program, you can also have independent parts that run simultaneously. The features that run these independent parts are called threads.
Splitting the computation in your program into multiple threads can improve performance because the program does multiple tasks at the same time, but it also adds complexity. Because threads can run simultaneously, there’s no inherent guarantee about the order in which parts of your code on different threads will run. This can lead to problems, such as:
- Race conditions, where threads are accessing data or resources in an inconsistent order
- Deadlocks, where two threads are waiting for each other to finish using a resource the other thread has, preventing both threads from continuing
- Bugs that happen only in certain situations and are hard to reproduce and fix reliably
Rust attempts to mitigate the negative effects of using threads, but programming in a multithreaded context still takes careful thought and requires a code structure that is different from that in programs running in a single thread.
Programming languages implement threads in a few different ways. Many operating systems provide an API for creating new threads. This model where a language calls the operating system APIs to create threads is sometimes called 1:1, meaning one operating system thread per one language thread. The Rust standard library only provides an implementation of 1:1 threading; there are crates that implement other models of threading that make different tradeoffs.
Creating a New Thread with spawn
To create a new thread, we call the thread::spawn
function and pass it a
closure (we talked about closures in Chapter 13) containing the code we want to
run in the new thread. The example in Listing 16-1 prints some text from a main
thread and other text from a new thread:
Filename: src/main.rs
use std::thread; use std::time::Duration; fn main() { thread::spawn(|| { for i in 1..10 { println!("hi number {} from the spawned thread!", i); thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { println!("hi number {} from the main thread!", i); thread::sleep(Duration::from_millis(1)); } }
Listing 16-1: Creating a new thread to print one thing while the main thread prints something else
Note that with this function, the new thread will be stopped when the main thread ends, whether or not it has finished running. The output from this program might be a little different every time, but it will look similar to the following:
hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
The calls to thread::sleep
force a thread to stop its execution for a short
duration, allowing a different thread to run. The threads will probably take
turns, but that isn’t guaranteed: it depends on how your operating system
schedules the threads. In this run, the main thread printed first, even though
the print statement from the spawned thread appears first in the code. And even
though we told the spawned thread to print until i
is 9, it only got to 5
before the main thread shut down.
If you run this code and only see output from the main thread, or don’t see any overlap, try increasing the numbers in the ranges to create more opportunities for the operating system to switch between the threads.
Waiting for All Threads to Finish Using join
Handles
The code in Listing 16-1 not only stops the spawned thread prematurely most of the time due to the main thread ending, but also can’t guarantee that the spawned thread will get to run at all. The reason is that there is no guarantee on the order in which threads run!
We can fix the problem of the spawned thread not getting to run, or not getting
to run completely, by saving the return value of thread::spawn
in a variable.
The return type of thread::spawn
is JoinHandle
. A JoinHandle
is an owned
value that, when we call the join
method on it, will wait for its thread to
finish. Listing 16-2 shows how to use the JoinHandle
of the thread we created
in Listing 16-1 and call join
to make sure the spawned thread finishes before
main
exits:
Filename: src/main.rs
use std::thread; use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { println!("hi number {} from the spawned thread!", i); thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { println!("hi number {} from the main thread!", i); thread::sleep(Duration::from_millis(1)); } handle.join().unwrap(); }
Listing 16-2: Saving a JoinHandle
from thread::spawn
to guarantee the thread is run to completion
Calling join
on the handle blocks the thread currently running until the
thread represented by the handle terminates. Blocking a thread means that
thread is prevented from performing work or exiting. Because we’ve put the call
to join
after the main thread’s for
loop, running Listing 16-2 should
produce output similar to this:
hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 1 from the spawned thread!
hi number 3 from the main thread!
hi number 2 from the spawned thread!
hi number 4 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!
The two threads continue alternating, but the main thread waits because of the
call to handle.join()
and does not end until the spawned thread is finished.
But let’s see what happens when we instead move handle.join()
before the
for
loop in main
, like this:
Filename: src/main.rs
use std::thread; use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { println!("hi number {} from the spawned thread!", i); thread::sleep(Duration::from_millis(1)); } }); handle.join().unwrap(); for i in 1..5 { println!("hi number {} from the main thread!", i); thread::sleep(Duration::from_millis(1)); } }
The main thread will wait for the spawned thread to finish and then run its
for
loop, so the output won’t be interleaved anymore, as shown here:
hi number 1 from the spawned thread!
hi number 2 from the spawned thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!
hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 3 from the main thread!
hi number 4 from the main thread!
Small details, such as where join
is called, can affect whether or not your
threads run at the same time.
Using move
Closures with Threads
The move
keyword is often used with closures passed to thread::spawn
because the closure will then take ownership of the values it uses from the
environment, thus transferring ownership of those values from one thread to
another. In the “Capturing the Environment with Closures” section of Chapter 13, we discussed move
in the context of closures. Now,
we’ll concentrate more on the interaction between move
and thread::spawn
Notice in Listing 16-1 that the closure we pass to thread::spawn
takes no
arguments: we’re not using any data from the main thread in the spawned
thread’s code. To use data from the main thread in the spawned thread, the
spawned thread’s closure must capture the values it needs. Listing 16-3 shows
an attempt to create a vector in the main thread and use it in the spawned
thread. However, this won’t yet work, as you’ll see in a moment.
Filename: src/main.rs
use std::thread;
fn main() {
let v = vec![1, 2, 3];
let handle = thread::spawn(|| {
println!("Here's a vector: {:?}", v);
});
handle.join().unwrap();
}
Listing 16-3: Attempting to use a vector created by the main thread in another thread
The closure uses v
, so it will capture v
and make it part of the closure’s
environment. Because thread::spawn
runs this closure in a new thread, we
should be able to access v
inside that new thread. But when we compile this
example, we get the following error:
$ cargo run
Compiling threads v0.1.0 (file:///projects/threads)
error[E0373]: closure may outlive the current function, but it borrows `v`, which is owned by the current function
--> src/main.rs:6:32
|
6 | let handle = thread::spawn(|| {
| ^^ may outlive borrowed value `v`
7 | println!("Here's a vector: {:?}", v);
| - `v` is borrowed here
|
note: function requires argument type to outlive `'static`
--> src/main.rs:6:18
|
6 | let handle = thread::spawn(|| {
| __________________^
7 | | println!("Here's a vector: {:?}", v);
8 | | });
| |______^
help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword
|
6 | let handle = thread::spawn(move || {
| ++++
For more information about this error, try `rustc --explain E0373`.
error: could not compile `threads` due to previous error
Rust infers how to capture v
, and because println!
only needs a reference
to v
, the closure tries to borrow v
. However, there’s a problem: Rust can’t
tell how long the spawned thread will run, so it doesn’t know if the reference
to v
will always be valid.
Listing 16-4 provides a scenario that’s more likely to have a reference to v
that won’t be valid:
Filename: src/main.rs
use std::thread;
fn main() {
let v = vec![1, 2, 3];
let handle = thread::spawn(|| {
println!("Here's a vector: {:?}", v);
});
drop(v); // oh no!
handle.join().unwrap();
}
Listing 16-4: A thread with a closure that attempts to
capture a reference to v
from a main thread that drops v
If we were allowed to run this code, there’s a possibility the spawned thread
would be immediately put in the background without running at all. The spawned
thread has a reference to v
inside, but the main thread immediately drops
v
, using the drop
function we discussed in Chapter 15. Then, when the
spawned thread starts to execute, v
is no longer valid, so a reference to it
is also invalid. Oh no!
To fix the compiler error in Listing 16-3, we can use the error message’s advice:
help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword
|
6 | let handle = thread::spawn(move || {
| ++++
By adding the move
keyword before the closure, we force the closure to take
ownership of the values it’s using rather than allowing Rust to infer that it
should borrow the values. The modification to Listing 16-3 shown in Listing
16-5 will compile and run as we intend:
Filename: src/main.rs
use std::thread; fn main() { let v = vec![1, 2, 3]; let handle = thread::spawn(move || { println!("Here's a vector: {:?}", v); }); handle.join().unwrap(); }
Listing 16-5: Using the move
keyword to force a closure
to take ownership of the values it uses
What would happen to the code in Listing 16-4 where the main thread called
drop
if we use a move
closure? Would move
fix that case? Unfortunately,
no; we would get a different error because what Listing 16-4 is trying to do
isn’t allowed for a different reason. If we added move
to the closure, we
would move v
into the closure’s environment, and we could no longer call
drop
on it in the main thread. We would get this compiler error instead:
$ cargo run
Compiling threads v0.1.0 (file:///projects/threads)
error[E0382]: use of moved value: `v`
--> src/main.rs:10:10
|
4 | let v = vec![1, 2, 3];
| - move occurs because `v` has type `Vec<i32>`, which does not implement the `Copy` trait
5 |
6 | let handle = thread::spawn(move || {
| ------- value moved into closure here
7 | println!("Here's a vector: {:?}", v);
| - variable moved due to use in closure
...
10 | drop(v); // oh no!
| ^ value used here after move
For more information about this error, try `rustc --explain E0382`.
error: could not compile `threads` due to previous error
Rust’s ownership rules have saved us again! We got an error from the code in
Listing 16-3 because Rust was being conservative and only borrowing v
for the
thread, which meant the main thread could theoretically invalidate the spawned
thread’s reference. By telling Rust to move ownership of v
to the spawned
thread, we’re guaranteeing Rust that the main thread won’t use v
anymore. If
we change Listing 16-4 in the same way, we’re then violating the ownership
rules when we try to use v
in the main thread. The move
keyword overrides
Rust’s conservative default of borrowing; it doesn’t let us violate the
ownership rules.
With a basic understanding of threads and the thread API, let’s look at what we can do with threads.
Using Message Passing to Transfer Data Between Threads
One increasingly popular approach to ensuring safe concurrency is message passing, where threads or actors communicate by sending each other messages containing data. Here’s the idea in a slogan from the Go language documentation: “Do not communicate by sharing memory; instead, share memory by communicating.”
One major tool Rust has for accomplishing message-sending concurrency is the channel, a programming concept that Rust’s standard library provides an implementation of. You can imagine a channel in programming as being like a channel of water, such as a stream or a river. If you put something like a rubber duck or boat into a stream, it will travel downstream to the end of the waterway.
A channel in programming has two halves: a transmitter and a receiver. The transmitter half is the upstream location where you put rubber ducks into the river, and the receiver half is where the rubber duck ends up downstream. One part of your code calls methods on the transmitter with the data you want to send, and another part checks the receiving end for arriving messages. A channel is said to be closed if either the transmitter or receiver half is dropped.
Here, we’ll work up to a program that has one thread to generate values and send them down a channel, and another thread that will receive the values and print them out. We’ll be sending simple values between threads using a channel to illustrate the feature. Once you’re familiar with the technique, you could use channels to implement a chat system or a system where many threads perform parts of a calculation and send the parts to one thread that aggregates the results.
First, in Listing 16-6, we’ll create a channel but not do anything with it. Note that this won’t compile yet because Rust can’t tell what type of values we want to send over the channel.
Filename: src/main.rs
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
}
Listing 16-6: Creating a channel and assigning the two
halves to tx
and rx
We create a new channel using the mpsc::channel
function; mpsc
stands for
multiple producer, single consumer. In short, the way Rust’s standard library
implements channels means a channel can have multiple sending ends that
produce values but only one receiving end that consumes those values. Imagine
multiple streams flowing together into one big river: everything sent down any
of the streams will end up in one river at the end. We’ll start with a single
producer for now, but we’ll add multiple producers when we get this example
working.
The mpsc::channel
function returns a tuple, the first element of which is the
sending end and the second element is the receiving end. The abbreviations tx
and rx
are traditionally used in many fields for transmitter and receiver
respectively, so we name our variables as such to indicate each end. We’re
using a let
statement with a pattern that destructures the tuples; we’ll
discuss the use of patterns in let
statements and destructuring in Chapter
18. Using a let
statement this way is a convenient approach to extract the
pieces of the tuple returned by mpsc::channel
.
Let’s move the transmitting end into a spawned thread and have it send one string so the spawned thread is communicating with the main thread, as shown in Listing 16-7. This is like putting a rubber duck in the river upstream or sending a chat message from one thread to another.
Filename: src/main.rs
use std::sync::mpsc; use std::thread; fn main() { let (tx, rx) = mpsc::channel(); thread::spawn(move || { let val = String::from("hi"); tx.send(val).unwrap(); }); }
Listing 16-7: Moving tx
to a spawned thread and sending
“hi”
Again, we’re using thread::spawn
to create a new thread and then using move
to move tx
into the closure so the spawned thread owns tx
. The spawned
thread needs to own the transmitting end of the channel to be able to send
messages through the channel.
The transmitting end has a send
method that takes the value we want to send.
The send
method returns a Result<T, E>
type, so if the receiving end has
already been dropped and there’s nowhere to send a value, the send operation
will return an error. In this example, we’re calling unwrap
to panic in case
of an error. But in a real application, we would handle it properly: return to
Chapter 9 to review strategies for proper error handling.
In Listing 16-8, we’ll get the value from the receiving end of the channel in the main thread. This is like retrieving the rubber duck from the water at the end of the river or like getting a chat message.
Filename: src/main.rs
use std::sync::mpsc; use std::thread; fn main() { let (tx, rx) = mpsc::channel(); thread::spawn(move || { let val = String::from("hi"); tx.send(val).unwrap(); }); let received = rx.recv().unwrap(); println!("Got: {}", received); }
Listing 16-8: Receiving the value “hi” in the main thread and printing it
The receiving end of a channel has two useful methods: recv
and try_recv
.
We’re using recv
, short for receive, which will block the main thread’s
execution and wait until a value is sent down the channel. Once a value is
sent, recv
will return it in a Result<T, E>
. When the sending end of the
channel closes, recv
will return an error to signal that no more values will
be coming.
The try_recv
method doesn’t block, but will instead return a Result<T, E>
immediately: an Ok
value holding a message if one is available and an Err
value if there aren’t any messages this time. Using try_recv
is useful if
this thread has other work to do while waiting for messages: we could write a
loop that calls try_recv
every so often, handles a message if one is
available, and otherwise does other work for a little while until checking
again.
We’ve used recv
in this example for simplicity; we don’t have any other work
for the main thread to do other than wait for messages, so blocking the main
thread is appropriate.
When we run the code in Listing 16-8, we’ll see the value printed from the main thread:
Got: hi
Perfect!
Channels and Ownership Transference
The ownership rules play a vital role in message sending because they help you
write safe, concurrent code. Preventing errors in concurrent programming is the
advantage of thinking about ownership throughout your Rust programs. Let’s do
an experiment to show how channels and ownership work together to prevent
problems: we’ll try to use a val
value in the spawned thread after we’ve
sent it down the channel. Try compiling the code in Listing 16-9 to see why
this code isn’t allowed:
Filename: src/main.rs
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap();
println!("val is {}", val);
});
let received = rx.recv().unwrap();
println!("Got: {}", received);
}
Listing 16-9: Attempting to use val
after we’ve sent it
down the channel
Here, we try to print val
after we’ve sent it down the channel via tx.send
.
Allowing this would be a bad idea: once the value has been sent to another
thread, that thread could modify or drop it before we try to use the value
again. Potentially, the other thread’s modifications could cause errors or
unexpected results due to inconsistent or nonexistent data. However, Rust gives
us an error if we try to compile the code in Listing 16-9:
$ cargo run
Compiling message-passing v0.1.0 (file:///projects/message-passing)
error[E0382]: borrow of moved value: `val`
--> src/main.rs:10:31
|
8 | let val = String::from("hi");
| --- move occurs because `val` has type `String`, which does not implement the `Copy` trait
9 | tx.send(val).unwrap();
| --- value moved here
10 | println!("val is {}", val);
| ^^^ value borrowed here after move
|
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try `rustc --explain E0382`.
error: could not compile `message-passing` due to previous error
Our concurrency mistake has caused a compile time error. The send
function
takes ownership of its parameter, and when the value is moved, the receiver
takes ownership of it. This stops us from accidentally using the value again
after sending it; the ownership system checks that everything is okay.
Sending Multiple Values and Seeing the Receiver Waiting
The code in Listing 16-8 compiled and ran, but it didn’t clearly show us that two separate threads were talking to each other over the channel. In Listing 16-10 we’ve made some modifications that will prove the code in Listing 16-8 is running concurrently: the spawned thread will now send multiple messages and pause for a second between each message.
Filename: src/main.rs
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let vals = vec![
String::from("hi"),
String::from("from"),
String::from("the"),
String::from("thread"),
];
for val in vals {
tx.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
for received in rx {
println!("Got: {}", received);
}
}
Listing 16-10: Sending multiple messages and pausing between each
This time, the spawned thread has a vector of strings that we want to send to
the main thread. We iterate over them, sending each individually, and pause
between each by calling the thread::sleep
function with a Duration
value of
1 second.
In the main thread, we’re not calling the recv
function explicitly anymore:
instead, we’re treating rx
as an iterator. For each value received, we’re
printing it. When the channel is closed, iteration will end.
When running the code in Listing 16-10, you should see the following output with a 1-second pause in between each line:
Got: hi
Got: from
Got: the
Got: thread
Because we don’t have any code that pauses or delays in the for
loop in the
main thread, we can tell that the main thread is waiting to receive values from
the spawned thread.
Creating Multiple Producers by Cloning the Transmitter
Earlier we mentioned that mpsc
was an acronym for multiple producer,
single consumer. Let’s put mpsc
to use and expand the code in Listing 16-10
to create multiple threads that all send values to the same receiver. We can do
so by cloning the transmitting half of the channel, as shown in Listing 16-11:
Filename: src/main.rs
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
// --snip--
let (tx, rx) = mpsc::channel();
let tx1 = tx.clone();
thread::spawn(move || {
let vals = vec![
String::from("hi"),
String::from("from"),
String::from("the"),
String::from("thread"),
];
for val in vals {
tx1.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
thread::spawn(move || {
let vals = vec![
String::from("more"),
String::from("messages"),
String::from("for"),
String::from("you"),
];
for val in vals {
tx.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
for received in rx {
println!("Got: {}", received);
}
// --snip--
}
Listing 16-11: Sending multiple messages from multiple producers
This time, before we create the first spawned thread, we call clone
on the
sending end of the channel. This will give us a new sending handle we can pass
to the first spawned thread. We pass the original sending end of the channel to
a second spawned thread. This gives us two threads, each sending different
messages to the receiving end of the channel.
When you run the code, your output should look something like this:
Got: hi
Got: more
Got: from
Got: messages
Got: for
Got: the
Got: thread
Got: you
You might see the values in another order; it depends on your system. This is
what makes concurrency interesting as well as difficult. If you experiment with
thread::sleep
, giving it various values in the different threads, each run
will be more nondeterministic and create different output each time.
Now that we’ve looked at how channels work, let’s look at a different method of concurrency.
Shared-State Concurrency
Message passing is a fine way of handling concurrency, but it’s not the only one. Consider this part of the slogan from the Go language documentation again: “do not communicate by sharing memory.”
What would communicating by sharing memory look like? In addition, why would message-passing enthusiasts not use it and do the opposite instead?
In a way, channels in any programming language are similar to single ownership, because once you transfer a value down a channel, you should no longer use that value. Shared memory concurrency is like multiple ownership: multiple threads can access the same memory location at the same time. As you saw in Chapter 15, where smart pointers made multiple ownership possible, multiple ownership can add complexity because these different owners need managing. Rust’s type system and ownership rules greatly assist in getting this management correct. For an example, let’s look at mutexes, one of the more common concurrency primitives for shared memory.
Using Mutexes to Allow Access to Data from One Thread at a Time
Mutex is an abbreviation for mutual exclusion, as in, a mutex allows only one thread to access some data at any given time. To access the data in a mutex, a thread must first signal that it wants access by asking to acquire the mutex’s lock. The lock is a data structure that is part of the mutex that keeps track of who currently has exclusive access to the data. Therefore, the mutex is described as guarding the data it holds via the locking system.
Mutexes have a reputation for being difficult to use because you have to remember two rules:
- You must attempt to acquire the lock before using the data.
- When you’re done with the data that the mutex guards, you must unlock the data so other threads can acquire the lock.
For a real-world metaphor for a mutex, imagine a panel discussion at a conference with only one microphone. Before a panelist can speak, they have to ask or signal that they want to use the microphone. When they get the microphone, they can talk for as long as they want to and then hand the microphone to the next panelist who requests to speak. If a panelist forgets to hand the microphone off when they’re finished with it, no one else is able to speak. If management of the shared microphone goes wrong, the panel won’t work as planned!
Management of mutexes can be incredibly tricky to get right, which is why so many people are enthusiastic about channels. However, thanks to Rust’s type system and ownership rules, you can’t get locking and unlocking wrong.
The API of Mutex<T>
As an example of how to use a mutex, let’s start by using a mutex in a single-threaded context, as shown in Listing 16-12:
Filename: src/main.rs
use std::sync::Mutex; fn main() { let m = Mutex::new(5); { let mut num = m.lock().unwrap(); *num = 6; } println!("m = {:?}", m); }
Listing 16-12: Exploring the API of Mutex<T>
in a
single-threaded context for simplicity
As with many types, we create a Mutex<T>
using the associated function new
.
To access the data inside the mutex, we use the lock
method to acquire the
lock. This call will block the current thread so it can’t do any work until
it’s our turn to have the lock.
The call to lock
would fail if another thread holding the lock panicked. In
that case, no one would ever be able to get the lock, so we’ve chosen to
unwrap
and have this thread panic if we’re in that situation.
After we’ve acquired the lock, we can treat the return value, named num
in
this case, as a mutable reference to the data inside. The type system ensures
that we acquire a lock before using the value in m
: Mutex<i32>
is not an
i32
, so we must acquire the lock to be able to use the i32
value. We
can’t forget; the type system won’t let us access the inner i32
otherwise.
As you might suspect, Mutex<T>
is a smart pointer. More accurately, the call
to lock
returns a smart pointer called MutexGuard
, wrapped in a
LockResult
that we handled with the call to unwrap
. The MutexGuard
smart
pointer implements Deref
to point at our inner data; the smart pointer also
has a Drop
implementation that releases the lock automatically when a
MutexGuard
goes out of scope, which happens at the end of the inner scope in
Listing 16-12. As a result, we don’t risk forgetting to release the lock and
blocking the mutex from being used by other threads because the lock release
happens automatically.
After dropping the lock, we can print the mutex value and see that we were able
to change the inner i32
to 6.
Sharing a Mutex<T>
Between Multiple Threads
Now, let’s try to share a value between multiple threads using Mutex<T>
.
We’ll spin up 10 threads and have them each increment a counter value by 1, so
the counter goes from 0 to 10. The next example in Listing 16-13 will have
a compiler error, and we’ll use that error to learn more about using
Mutex<T>
and how Rust helps us use it correctly.
Filename: src/main.rs
use std::sync::Mutex;
use std::thread;
fn main() {
let counter = Mutex::new(0);
let mut handles = vec![];
for _ in 0..10 {
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
}
Listing 16-13: Ten threads each increment a counter
guarded by a Mutex<T>
We create a counter
variable to hold an i32
inside a Mutex<T>
, as we
did in Listing 16-12. Next, we create 10 threads by iterating over a range
of numbers. We use thread::spawn
and give all the threads the same closure,
one that moves the counter into the thread, acquires a lock on the Mutex<T>
by calling the lock
method, and then adds 1 to the value in the mutex. When a
thread finishes running its closure, num
will go out of scope and release the
lock so another thread can acquire it.
In the main thread, we collect all the join handles. Then, as we did in Listing
16-2, we call join
on each handle to make sure all the threads finish. At
that point, the main thread will acquire the lock and print the result of this
program.
We hinted that this example wouldn’t compile. Now let’s find out why!
$ cargo run
Compiling shared-state v0.1.0 (file:///projects/shared-state)
error[E0382]: use of moved value: `counter`
--> src/main.rs:9:36
|
5 | let counter = Mutex::new(0);
| ------- move occurs because `counter` has type `Mutex<i32>`, which does not implement the `Copy` trait
...
9 | let handle = thread::spawn(move || {
| ^^^^^^^ value moved into closure here, in previous iteration of loop
10 | let mut num = counter.lock().unwrap();
| ------- use occurs due to use in closure
For more information about this error, try `rustc --explain E0382`.
error: could not compile `shared-state` due to previous error
The error message states that the counter
value was moved in the previous
iteration of the loop. So Rust is telling us that we can’t move the ownership
of lock counter
into multiple threads. Let’s fix the compiler error with a
multiple-ownership method we discussed in Chapter 15.
Multiple Ownership with Multiple Threads
In Chapter 15, we gave a value multiple owners by using the smart pointer
Rc<T>
to create a reference counted value. Let’s do the same here and see
what happens. We’ll wrap the Mutex<T>
in Rc<T>
in Listing 16-14 and clone
the Rc<T>
before moving ownership to the thread.
Filename: src/main.rs
use std::rc::Rc;
use std::sync::Mutex;
use std::thread;
fn main() {
let counter = Rc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Rc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
}
Listing 16-14: Attempting to use Rc<T>
to allow
multiple threads to own the Mutex<T>
Once again, we compile and get... different errors! The compiler is teaching us a lot.
$ cargo run
Compiling shared-state v0.1.0 (file:///projects/shared-state)
error[E0277]: `Rc<Mutex<i32>>` cannot be sent between threads safely
--> src/main.rs:11:22
|
11 | let handle = thread::spawn(move || {
| ______________________^^^^^^^^^^^^^_-
| | |
| | `Rc<Mutex<i32>>` cannot be sent between threads safely
12 | | let mut num = counter.lock().unwrap();
13 | |
14 | | *num += 1;
15 | | });
| |_________- within this `[closure@src/main.rs:11:36: 15:10]`
|
= help: within `[closure@src/main.rs:11:36: 15:10]`, the trait `Send` is not implemented for `Rc<Mutex<i32>>`
= note: required because it appears within the type `[closure@src/main.rs:11:36: 15:10]`
note: required by a bound in `spawn`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `shared-state` due to previous error
Wow, that error message is very wordy! Here’s the important part to focus
on: `Rc<Mutex<i32>>` cannot be sent between threads safely
. The compiler
is also telling us the reason why: the trait `Send` is not implemented for `Rc<Mutex<i32>>`
. We’ll talk about Send
in the next section: it’s one of
the traits that ensures the types we use with threads are meant for use in
concurrent situations.
Unfortunately, Rc<T>
is not safe to share across threads. When Rc<T>
manages the reference count, it adds to the count for each call to clone
and
subtracts from the count when each clone is dropped. But it doesn’t use any
concurrency primitives to make sure that changes to the count can’t be
interrupted by another thread. This could lead to wrong counts—subtle bugs that
could in turn lead to memory leaks or a value being dropped before we’re done
with it. What we need is a type exactly like Rc<T>
but one that makes changes
to the reference count in a thread-safe way.
Atomic Reference Counting with Arc<T>
Fortunately, Arc<T>
is a type like Rc<T>
that is safe to use in
concurrent situations. The a stands for atomic, meaning it’s an atomically
reference counted type. Atomics are an additional kind of concurrency
primitive that we won’t cover in detail here: see the standard library
documentation for std::sync::atomic
for more
details. At this point, you just need to know that atomics work like primitive
types but are safe to share across threads.
You might then wonder why all primitive types aren’t atomic and why standard
library types aren’t implemented to use Arc<T>
by default. The reason is that
thread safety comes with a performance penalty that you only want to pay when
you really need to. If you’re just performing operations on values within a
single thread, your code can run faster if it doesn’t have to enforce the
guarantees atomics provide.
Let’s return to our example: Arc<T>
and Rc<T>
have the same API, so we fix
our program by changing the use
line, the call to new
, and the call to
clone
. The code in Listing 16-15 will finally compile and run:
Filename: src/main.rs
use std::sync::{Arc, Mutex}; use std::thread; fn main() { let counter = Arc::new(Mutex::new(0)); let mut handles = vec![]; for _ in 0..10 { let counter = Arc::clone(&counter); let handle = thread::spawn(move || { let mut num = counter.lock().unwrap(); *num += 1; }); handles.push(handle); } for handle in handles { handle.join().unwrap(); } println!("Result: {}", *counter.lock().unwrap()); }
Listing 16-15: Using an Arc<T>
to wrap the Mutex<T>
to be able to share ownership across multiple threads
This code will print the following:
Result: 10
We did it! We counted from 0 to 10, which may not seem very impressive, but it
did teach us a lot about Mutex<T>
and thread safety. You could also use this
program’s structure to do more complicated operations than just incrementing a
counter. Using this strategy, you can divide a calculation into independent
parts, split those parts across threads, and then use a Mutex<T>
to have each
thread update the final result with its part.
Similarities Between RefCell<T>
/Rc<T>
and Mutex<T>
/Arc<T>
You might have noticed that counter
is immutable but we could get a mutable
reference to the value inside it; this means Mutex<T>
provides interior
mutability, as the Cell
family does. In the same way we used RefCell<T>
in
Chapter 15 to allow us to mutate contents inside an Rc<T>
, we use Mutex<T>
to mutate contents inside an Arc<T>
.
Another detail to note is that Rust can’t protect you from all kinds of logic
errors when you use Mutex<T>
. Recall in Chapter 15 that using Rc<T>
came
with the risk of creating reference cycles, where two Rc<T>
values refer to
each other, causing memory leaks. Similarly, Mutex<T>
comes with the risk of
creating deadlocks. These occur when an operation needs to lock two resources
and two threads have each acquired one of the locks, causing them to wait for
each other forever. If you’re interested in deadlocks, try creating a Rust
program that has a deadlock; then research deadlock mitigation strategies for
mutexes in any language and have a go at implementing them in Rust. The
standard library API documentation for Mutex<T>
and MutexGuard
offers
useful information.
We’ll round out this chapter by talking about the Send
and Sync
traits and
how we can use them with custom types.
Extensible Concurrency with the Sync
and Send
Traits
Interestingly, the Rust language has very few concurrency features. Almost every concurrency feature we’ve talked about so far in this chapter has been part of the standard library, not the language. Your options for handling concurrency are not limited to the language or the standard library; you can write your own concurrency features or use those written by others.
However, two concurrency concepts are embedded in the language: the
std::marker
traits Sync
and Send
.
Allowing Transference of Ownership Between Threads with Send
The Send
marker trait indicates that ownership of values of the type implementing
Send
can be transferred between threads. Almost every Rust type is Send
,
but there are some exceptions, including Rc<T>
: this cannot be Send
because
if you cloned an Rc<T>
value and tried to transfer ownership of the clone to
another thread, both threads might update the reference count at the same time.
For this reason, Rc<T>
is implemented for use in single-threaded situations
where you don’t want to pay the thread-safe performance penalty.
Therefore, Rust’s type system and trait bounds ensure that you can never
accidentally send an Rc<T>
value across threads unsafely. When we tried to do
this in Listing 16-14, we got the error the trait Send is not implemented for Rc<Mutex<i32>>
. When we switched to Arc<T>
, which is Send
, the code
compiled.
Any type composed entirely of Send
types is automatically marked as Send
as
well. Almost all primitive types are Send
, aside from raw pointers, which
we’ll discuss in Chapter 19.
Allowing Access from Multiple Threads with Sync
The Sync
marker trait indicates that it is safe for the type implementing
Sync
to be referenced from multiple threads. In other words, any type T
is
Sync
if &T
(an immutable reference to T
) is Send
, meaning the reference
can be sent safely to another thread. Similar to Send
, primitive types are
Sync
, and types composed entirely of types that are Sync
are also Sync
.
The smart pointer Rc<T>
is also not Sync
for the same reasons that it’s not
Send
. The RefCell<T>
type (which we talked about in Chapter 15) and the
family of related Cell<T>
types are not Sync
. The implementation of borrow
checking that RefCell<T>
does at runtime is not thread-safe. The smart
pointer Mutex<T>
is Sync
and can be used to share access with multiple
threads as you saw in the “Sharing a Mutex<T>
Between Multiple
Threads” section.
Implementing Send
and Sync
Manually Is Unsafe
Because types that are made up of Send
and Sync
traits are automatically
also Send
and Sync
, we don’t have to implement those traits manually. As
marker traits, they don’t even have any methods to implement. They’re just
useful for enforcing invariants related to concurrency.
Manually implementing these traits involves implementing unsafe Rust code.
We’ll talk about using unsafe Rust code in Chapter 19; for now, the important
information is that building new concurrent types not made up of Send
and
Sync
parts requires careful thought to uphold the safety guarantees. “The
Rustonomicon” has more information about these guarantees and how to
uphold them.
Summary
This isn’t the last you’ll see of concurrency in this book: the project in Chapter 20 will use the concepts in this chapter in a more realistic situation than the smaller examples discussed here.
As mentioned earlier, because very little of how Rust handles concurrency is part of the language, many concurrency solutions are implemented as crates. These evolve more quickly than the standard library, so be sure to search online for the current, state-of-the-art crates to use in multithreaded situations.
The Rust standard library provides channels for message passing and smart
pointer types, such as Mutex<T>
and Arc<T>
, that are safe to use in
concurrent contexts. The type system and the borrow checker ensure that the
code using these solutions won’t end up with data races or invalid references.
Once you get your code to compile, you can rest assured that it will happily
run on multiple threads without the kinds of hard-to-track-down bugs common in
other languages. Concurrent programming is no longer a concept to be afraid of:
go forth and make your programs concurrent, fearlessly!
Next, we’ll talk about idiomatic ways to model problems and structure solutions as your Rust programs get bigger. In addition, we’ll discuss how Rust’s idioms relate to those you might be familiar with from object-oriented programming.
Object Oriented Programming Features of Rust
Object-oriented programming (OOP) is a way of modeling programs. Objects came from Simula in the 1960s. Those objects influenced Alan Kay’s programming architecture in which objects pass messages to each other. He coined the term object-oriented programming in 1967 to describe this architecture. Many competing definitions describe what OOP is; some definitions would classify Rust as object oriented, but other definitions would not. In this chapter, we’ll explore certain characteristics that are commonly considered object oriented and how those characteristics translate to idiomatic Rust. We’ll then show you how to implement an object-oriented design pattern in Rust and discuss the trade-offs of doing so versus implementing a solution using some of Rust’s strengths instead.
Characteristics of Object-Oriented Languages
There is no consensus in the programming community about what features a language must have to be considered object oriented. Rust is influenced by many programming paradigms, including OOP; for example, we explored the features that came from functional programming in Chapter 13. Arguably, OOP languages share certain common characteristics, namely objects, encapsulation, and inheritance. Let’s look at what each of those characteristics means and whether Rust supports it.
Objects Contain Data and Behavior
The book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides (Addison-Wesley Professional, 1994), colloquially referred to as The Gang of Four book, is a catalog of object-oriented design patterns. It defines OOP this way:
Object-oriented programs are made up of objects. An object packages both data and the procedures that operate on that data. The procedures are typically called methods or operations.
Using this definition, Rust is object oriented: structs and enums have data,
and impl
blocks provide methods on structs and enums. Even though structs and
enums with methods aren’t called objects, they provide the same
functionality, according to the Gang of Four’s definition of objects.
Encapsulation that Hides Implementation Details
Another aspect commonly associated with OOP is the idea of encapsulation, which means that the implementation details of an object aren’t accessible to code using that object. Therefore, the only way to interact with an object is through its public API; code using the object shouldn’t be able to reach into the object’s internals and change data or behavior directly. This enables the programmer to change and refactor an object’s internals without needing to change the code that uses the object.
We discussed how to control encapsulation in Chapter 7: we can use the pub
keyword to decide which modules, types, functions, and methods in our code
should be public, and by default everything else is private. For example, we
can define a struct AveragedCollection
that has a field containing a vector
of i32
values. The struct can also have a field that contains the average of
the values in the vector, meaning the average doesn’t have to be computed
on demand whenever anyone needs it. In other words, AveragedCollection
will
cache the calculated average for us. Listing 17-1 has the definition of the
AveragedCollection
struct:
Filename: src/lib.rs
pub struct AveragedCollection {
list: Vec<i32>,
average: f64,
}
Listing 17-1: An AveragedCollection
struct that
maintains a list of integers and the average of the items in the
collection
The struct is marked pub
so that other code can use it, but the fields within
the struct remain private. This is important in this case because we want to
ensure that whenever a value is added or removed from the list, the average is
also updated. We do this by implementing add
, remove
, and average
methods
on the struct, as shown in Listing 17-2:
Filename: src/lib.rs
pub struct AveragedCollection {
list: Vec<i32>,
average: f64,
}
impl AveragedCollection {
pub fn add(&mut self, value: i32) {
self.list.push(value);
self.update_average();
}
pub fn remove(&mut self) -> Option<i32> {
let result = self.list.pop();
match result {
Some(value) => {
self.update_average();
Some(value)
}
None => None,
}
}
pub fn average(&self) -> f64 {
self.average
}
fn update_average(&mut self) {
let total: i32 = self.list.iter().sum();
self.average = total as f64 / self.list.len() as f64;
}
}
Listing 17-2: Implementations of the public methods
add
, remove
, and average
on AveragedCollection
The public methods add
, remove
, and average
are the only ways to access
or modify data in an instance of AveragedCollection
. When an item is added
to list
using the add
method or removed using the remove
method, the
implementations of each call the private update_average
method that handles
updating the average
field as well.
We leave the list
and average
fields private so there is no way for
external code to add or remove items to the list
field directly; otherwise,
the average
field might become out of sync when the list
changes. The
average
method returns the value in the average
field, allowing external
code to read the average
but not modify it.
Because we’ve encapsulated the implementation details of the struct
AveragedCollection
, we can easily change aspects, such as the data structure,
in the future. For instance, we could use a HashSet<i32>
instead of a
Vec<i32>
for the list
field. As long as the signatures of the add
,
remove
, and average
public methods stay the same, code using
AveragedCollection
wouldn’t need to change. If we made list
public instead,
this wouldn’t necessarily be the case: HashSet<i32>
and Vec<i32>
have
different methods for adding and removing items, so the external code would
likely have to change if it were modifying list
directly.
If encapsulation is a required aspect for a language to be considered object
oriented, then Rust meets that requirement. The option to use pub
or not for
different parts of code enables encapsulation of implementation details.
Inheritance as a Type System and as Code Sharing
Inheritance is a mechanism whereby an object can inherit from another object’s definition, thus gaining the parent object’s data and behavior without you having to define them again.
If a language must have inheritance to be an object-oriented language, then Rust is not one. There is no way to define a struct that inherits the parent struct’s fields and method implementations. However, if you’re used to having inheritance in your programming toolbox, you can use other solutions in Rust, depending on your reason for reaching for inheritance in the first place.
You choose inheritance for two main reasons. One is for reuse of code: you can
implement particular behavior for one type, and inheritance enables you to
reuse that implementation for a different type. You can share Rust code using
default trait method implementations instead, which you saw in Listing 10-14
when we added a default implementation of the summarize
method on the
Summary
trait. Any type implementing the Summary
trait would have the
summarize
method available on it without any further code. This is similar to
a parent class having an implementation of a method and an inheriting child
class also having the implementation of the method. We can also override the
default implementation of the summarize
method when we implement the
Summary
trait, which is similar to a child class overriding the
implementation of a method inherited from a parent class.
The other reason to use inheritance relates to the type system: to enable a child type to be used in the same places as the parent type. This is also called polymorphism, which means that you can substitute multiple objects for each other at runtime if they share certain characteristics.
Polymorphism
To many people, polymorphism is synonymous with inheritance. But it’s actually a more general concept that refers to code that can work with data of multiple types. For inheritance, those types are generally subclasses.
Rust instead uses generics to abstract over different possible types and trait bounds to impose constraints on what those types must provide. This is sometimes called bounded parametric polymorphism.
Inheritance has recently fallen out of favor as a programming design solution in many programming languages because it’s often at risk of sharing more code than necessary. Subclasses shouldn’t always share all characteristics of their parent class but will do so with inheritance. This can make a program’s design less flexible. It also introduces the possibility of calling methods on subclasses that don’t make sense or that cause errors because the methods don’t apply to the subclass. In addition, some languages will only allow a subclass to inherit from one class, further restricting the flexibility of a program’s design.
For these reasons, Rust takes a different approach, using trait objects instead of inheritance. Let’s look at how trait objects enable polymorphism in Rust.
Using Trait Objects That Allow for Values of Different Types
In Chapter 8, we mentioned that one limitation of vectors is that they can
store elements of only one type. We created a workaround in Listing 8-10 where
we defined a SpreadsheetCell
enum that had variants to hold integers, floats,
and text. This meant we could store different types of data in each cell and
still have a vector that represented a row of cells. This is a perfectly good
solution when our interchangeable items are a fixed set of types that we know
when our code is compiled.
However, sometimes we want our library user to be able to extend the set of
types that are valid in a particular situation. To show how we might achieve
this, we’ll create an example graphical user interface (GUI) tool that iterates
through a list of items, calling a draw
method on each one to draw it to the
screen—a common technique for GUI tools. We’ll create a library crate called
gui
that contains the structure of a GUI library. This crate might include
some types for people to use, such as Button
or TextField
. In addition,
gui
users will want to create their own types that can be drawn: for
instance, one programmer might add an Image
and another might add a
SelectBox
.
We won’t implement a fully fledged GUI library for this example but will show
how the pieces would fit together. At the time of writing the library, we can’t
know and define all the types other programmers might want to create. But we do
know that gui
needs to keep track of many values of different types, and it
needs to call a draw
method on each of these differently typed values. It
doesn’t need to know exactly what will happen when we call the draw
method,
just that the value will have that method available for us to call.
To do this in a language with inheritance, we might define a class named
Component
that has a method named draw
on it. The other classes, such as
Button
, Image
, and SelectBox
, would inherit from Component
and thus
inherit the draw
method. They could each override the draw
method to define
their custom behavior, but the framework could treat all of the types as if
they were Component
instances and call draw
on them. But because Rust
doesn’t have inheritance, we need another way to structure the gui
library to
allow users to extend it with new types.
Defining a Trait for Common Behavior
To implement the behavior we want gui
to have, we’ll define a trait named
Draw
that will have one method named draw
. Then we can define a vector that
takes a trait object. A trait object points to both an instance of a type
implementing our specified trait as well as a table used to look up trait
methods on that type at runtime. We create a trait object by specifying some
sort of pointer, such as a &
reference or a Box<T>
smart pointer, then the
dyn
keyword, and then specifying the relevant trait. (We’ll talk about the
reason trait objects must use a pointer in Chapter 19 in the section
“Dynamically Sized Types and the Sized
Trait.”) We can use trait objects in place of a generic or concrete type.
Wherever we use a trait object, Rust’s type system will ensure at compile time
that any value used in that context will implement the trait object’s trait.
Consequently, we don’t need to know all the possible types at compile time.
We’ve mentioned that in Rust, we refrain from calling structs and enums
“objects” to distinguish them from other languages’ objects. In a struct or
enum, the data in the struct fields and the behavior in impl
blocks are
separated, whereas in other languages, the data and behavior combined into one
concept is often labeled an object. However, trait objects are more like
objects in other languages in the sense that they combine data and behavior.
But trait objects differ from traditional objects in that we can’t add data to
a trait object. Trait objects aren’t as generally useful as objects in other
languages: their specific purpose is to allow abstraction across common
behavior.
Listing 17-3 shows how to define a trait named Draw
with one method named
draw
:
Filename: src/lib.rs
pub trait Draw {
fn draw(&self);
}
Listing 17-3: Definition of the Draw
trait
This syntax should look familiar from our discussions on how to define traits
in Chapter 10. Next comes some new syntax: Listing 17-4 defines a struct named
Screen
that holds a vector named components
. This vector is of type
Box<dyn Draw>
, which is a trait object; it’s a stand-in for any type inside
a Box
that implements the Draw
trait.
Filename: src/lib.rs
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
Listing 17-4: Definition of the Screen
struct with a
components
field holding a vector of trait objects that implement the Draw
trait
On the Screen
struct, we’ll define a method named run
that will call the
draw
method on each of its components
, as shown in Listing 17-5:
Filename: src/lib.rs
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
Listing 17-5: A run
method on Screen
that calls the
draw
method on each component
This works differently from defining a struct that uses a generic type
parameter with trait bounds. A generic type parameter can only be substituted
with one concrete type at a time, whereas trait objects allow for multiple
concrete types to fill in for the trait object at runtime. For example, we
could have defined the Screen
struct using a generic type and a trait bound
as in Listing 17-6:
Filename: src/lib.rs
pub trait Draw {
fn draw(&self);
}
pub struct Screen<T: Draw> {
pub components: Vec<T>,
}
impl<T> Screen<T>
where
T: Draw,
{
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
Listing 17-6: An alternate implementation of the Screen
struct and its run
method using generics and trait bounds
This restricts us to a Screen
instance that has a list of components all of
type Button
or all of type TextField
. If you’ll only ever have homogeneous
collections, using generics and trait bounds is preferable because the
definitions will be monomorphized at compile time to use the concrete types.
On the other hand, with the method using trait objects, one Screen
instance
can hold a Vec<T>
that contains a Box<Button>
as well as a
Box<TextField>
. Let’s look at how this works, and then we’ll talk about the
runtime performance implications.
Implementing the Trait
Now we’ll add some types that implement the Draw
trait. We’ll provide the
Button
type. Again, actually implementing a GUI library is beyond the scope
of this book, so the draw
method won’t have any useful implementation in its
body. To imagine what the implementation might look like, a Button
struct
might have fields for width
, height
, and label
, as shown in Listing 17-7:
Filename: src/lib.rs
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
pub struct Button {
pub width: u32,
pub height: u32,
pub label: String,
}
impl Draw for Button {
fn draw(&self) {
// code to actually draw a button
}
}
Listing 17-7: A Button
struct that implements the
Draw
trait
The width
, height
, and label
fields on Button
will differ from the
fields on other components, such as a TextField
type, that might have those
fields plus a placeholder
field instead. Each of the types we want to draw on
the screen will implement the Draw
trait but will use different code in the
draw
method to define how to draw that particular type, as Button
has here
(without the actual GUI code, which is beyond the scope of this chapter). The
Button
type, for instance, might have an additional impl
block containing
methods related to what happens when a user clicks the button. These kinds of
methods won’t apply to types like TextField
.
If someone using our library decides to implement a SelectBox
struct that has
width
, height
, and options
fields, they implement the Draw
trait on the
SelectBox
type as well, as shown in Listing 17-8:
Filename: src/main.rs
use gui::Draw;
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// code to actually draw a select box
}
}
fn main() {}
Listing 17-8: Another crate using gui
and implementing
the Draw
trait on a SelectBox
struct
Our library’s user can now write their main
function to create a Screen
instance. To the Screen
instance, they can add a SelectBox
and a Button
by putting each in a Box<T>
to become a trait object. They can then call the
run
method on the Screen
instance, which will call draw
on each of the
components. Listing 17-9 shows this implementation:
Filename: src/main.rs
use gui::Draw;
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// code to actually draw a select box
}
}
use gui::{Button, Screen};
fn main() {
let screen = Screen {
components: vec![
Box::new(SelectBox {
width: 75,
height: 10,
options: vec![
String::from("Yes"),
String::from("Maybe"),
String::from("No"),
],
}),
Box::new(Button {
width: 50,
height: 10,
label: String::from("OK"),
}),
],
};
screen.run();
}
Listing 17-9: Using trait objects to store values of different types that implement the same trait
When we wrote the library, we didn’t know that someone might add the
SelectBox
type, but our Screen
implementation was able to operate on the
new type and draw it because SelectBox
implements the Draw
trait, which
means it implements the draw
method.
This concept—of being concerned only with the messages a value responds to
rather than the value’s concrete type—is similar to the concept of duck
typing in dynamically typed languages: if it walks like a duck and quacks
like a duck, then it must be a duck! In the implementation of run
on Screen
in Listing 17-5, run
doesn’t need to know what the concrete type of each
component is. It doesn’t check whether a component is an instance of a Button
or a SelectBox
, it just calls the draw
method on the component. By
specifying Box<dyn Draw>
as the type of the values in the components
vector, we’ve defined Screen
to need values that we can call the draw
method on.
The advantage of using trait objects and Rust’s type system to write code similar to code using duck typing is that we never have to check whether a value implements a particular method at runtime or worry about getting errors if a value doesn’t implement a method but we call it anyway. Rust won’t compile our code if the values don’t implement the traits that the trait objects need.
For example, Listing 17-10 shows what happens if we try to create a Screen
with a String
as a component:
Filename: src/main.rs
use gui::Screen;
fn main() {
let screen = Screen {
components: vec![Box::new(String::from("Hi"))],
};
screen.run();
}
Listing 17-10: Attempting to use a type that doesn’t implement the trait object’s trait
We’ll get this error because String
doesn’t implement the Draw
trait:
$ cargo run
Compiling gui v0.1.0 (file:///projects/gui)
error[E0277]: the trait bound `String: Draw` is not satisfied
--> src/main.rs:5:26
|
5 | components: vec![Box::new(String::from("Hi"))],
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Draw` is not implemented for `String`
|
= note: required for the cast to the object type `dyn Draw`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `gui` due to previous error
This error lets us know that either we’re passing something to Screen
we
didn’t mean to pass and we should pass a different type or we should implement
Draw
on String
so that Screen
is able to call draw
on it.
Trait Objects Perform Dynamic Dispatch
Recall in the “Performance of Code Using Generics” section in Chapter 10 our discussion on the monomorphization process performed by the compiler when we use trait bounds on generics: the compiler generates nongeneric implementations of functions and methods for each concrete type that we use in place of a generic type parameter. The code that results from monomorphization is doing static dispatch, which is when the compiler knows what method you’re calling at compile time. This is opposed to dynamic dispatch, which is when the compiler can’t tell at compile time which method you’re calling. In dynamic dispatch cases, the compiler emits code that at runtime will figure out which method to call.
When we use trait objects, Rust must use dynamic dispatch. The compiler doesn’t know all the types that might be used with the code that is using trait objects, so it doesn’t know which method implemented on which type to call. Instead, at runtime, Rust uses the pointers inside the trait object to know which method to call. There is a runtime cost when this lookup happens that doesn’t occur with static dispatch. Dynamic dispatch also prevents the compiler from choosing to inline a method’s code, which in turn prevents some optimizations. However, we did get extra flexibility in the code that we wrote in Listing 17-5 and were able to support in Listing 17-9, so it’s a trade-off to consider.
Implementing an Object-Oriented Design Pattern
The state pattern is an object-oriented design pattern. The crux of the pattern is that a value has some internal state, which is represented by a set of state objects, and the value’s behavior changes based on the internal state. The state objects share functionality: in Rust, of course, we use structs and traits rather than objects and inheritance. Each state object is responsible for its own behavior and for governing when it should change into another state. The value that holds a state object knows nothing about the different behavior of the states or when to transition between states.
Using the state pattern means when the business requirements of the program change, we won’t need to change the code of the value holding the state or the code that uses the value. We’ll only need to update the code inside one of the state objects to change its rules or perhaps add more state objects. Let’s look at an example of the state design pattern and how to use it in Rust.
We’ll implement a blog post workflow in an incremental way. The blog’s final functionality will look like this:
- A blog post starts as an empty draft.
- When the draft is done, a review of the post is requested.
- When the post is approved, it gets published.
- Only published blog posts return content to print, so unapproved posts can’t accidentally be published.
Any other changes attempted on a post should have no effect. For example, if we try to approve a draft blog post before we’ve requested a review, the post should remain an unpublished draft.
Listing 17-11 shows this workflow in code form: this is an example usage of the
API we’ll implement in a library crate named blog
. This won’t compile yet
because we haven’t implemented the blog
crate yet.
Filename: src/main.rs
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
Listing 17-11: Code that demonstrates the desired
behavior we want our blog
crate to have
We want to allow the user to create a new draft blog post with Post::new
. We
want to allow text to be added to the blog post. If we try to get the post’s
content immediately, before approval, we shouldn't get any text because the
post is still a draft. We’ve added assert_eq!
in the code for demonstration
purposes. An excellent unit test for this would be to assert that a draft blog
post returns an empty string from the content
method, but we’re not going to
write tests for this example.
Next, we want to enable a request for a review of the post, and we want
content
to return an empty string while waiting for the review. When the post
receives approval, it should get published, meaning the text of the post will
be returned when content
is called.
Notice that the only type we’re interacting with from the crate is the Post
type. This type will use the state pattern and will hold a value that will be
one of three state objects representing the various states a post can be
in—draft, waiting for review, or published. Changing from one state to another
will be managed internally within the Post
type. The states change in
response to the methods called by our library’s users on the Post
instance,
but they don’t have to manage the state changes directly. Also, users can’t
make a mistake with the states, like publishing a post before it’s reviewed.
Defining Post
and Creating a New Instance in the Draft State
Let’s get started on the implementation of the library! We know we need a
public Post
struct that holds some content, so we’ll start with the
definition of the struct and an associated public new
function to create an
instance of Post
, as shown in Listing 17-12. We’ll also make a private
State
trait. Then Post
will hold a trait object of Box<dyn State>
inside an Option<T>
in a private field named state
. You’ll see why the
Option<T>
is necessary in a bit.
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
}
trait State {}
struct Draft {}
impl State for Draft {}
Listing 17-12: Definition of a Post
struct and a new
function that creates a new Post
instance, a State
trait, and a Draft
struct
The State
trait defines the behavior shared by different post states, and the
Draft
, PendingReview
, and Published
states will all implement the State
trait. For now, the trait doesn’t have any methods, and we’ll start by defining
just the Draft
state because that is the state we want a post to start in.
When we create a new Post
, we set its state
field to a Some
value that
holds a Box
. This Box
points to a new instance of the Draft
struct. This
ensures whenever we create a new instance of Post
, it will start out as a
draft. Because the state
field of Post
is private, there is no way to
create a Post
in any other state! In the Post::new
function, we set the
content
field to a new, empty String
.
Storing the Text of the Post Content
Listing 17-11 showed that we want to be able to call a method named
add_text
and pass it a &str
that is then added to the text content of the
blog post. We implement this as a method rather than exposing the content
field as pub
. This means we can implement a method later that will control
how the content
field’s data is read. The add_text
method is pretty
straightforward, so let’s add the implementation in Listing 17-13 to the impl Post
block:
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
}
trait State {}
struct Draft {}
impl State for Draft {}
Listing 17-13: Implementing the add_text
method to add
text to a post’s content
The add_text
method takes a mutable reference to self
, because we’re
changing the Post
instance that we’re calling add_text
on. We then call
push_str
on the String
in content
and pass the text
argument to add to
the saved content
. This behavior doesn’t depend on the state the post is in,
so it’s not part of the state pattern. The add_text
method doesn’t interact
with the state
field at all, but it is part of the behavior we want to
support.
Ensuring the Content of a Draft Post Is Empty
Even after we’ve called add_text
and added some content to our post, we still
want the content
method to return an empty string slice because the post is
still in the draft state, as shown on line 7 of Listing 17-11. For now, let’s
implement the content
method with the simplest thing that will fulfill this
requirement: always returning an empty string slice. We’ll change this later
once we implement the ability to change a post’s state so it can be published.
So far, posts can only be in the draft state, so the post content should always
be empty. Listing 17-14 shows this placeholder implementation:
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
""
}
}
trait State {}
struct Draft {}
impl State for Draft {}
Listing 17-14: Adding a placeholder implementation for
the content
method on Post
that always returns an empty string slice
With this added content
method, everything in Listing 17-11 up to line 7
works as intended.
Requesting a Review of the Post Changes Its State
Next, we need to add functionality to request a review of a post, which should
change its state from Draft
to PendingReview
. Listing 17-15 shows this code:
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
""
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
}
Listing 17-15: Implementing request_review
methods on
Post
and the State
trait
We give Post
a public method named request_review
that will take a mutable
reference to self
. Then we call an internal request_review
method on the
current state of Post
, and this second request_review
method consumes the
current state and returns a new state.
We’ve added the request_review
method to the State
trait; all types that
implement the trait will now need to implement the request_review
method.
Note that rather than having self
, &self
, or &mut self
as the first
parameter of the method, we have self: Box<Self>
. This syntax means the
method is only valid when called on a Box
holding the type. This syntax takes
ownership of Box<Self>
, invalidating the old state so the state value of the
Post
can transform into a new state.
To consume the old state, the request_review
method needs to take ownership
of the state value. This is where the Option
in the state
field of Post
comes in: we call the take
method to take the Some
value out of the state
field and leave a None
in its place, because Rust doesn’t let us have
unpopulated fields in structs. This lets us move the state
value out of
Post
rather than borrowing it. Then we’ll set the post’s state
value to the
result of this operation.
We need to set state
to None
temporarily rather than setting it directly
with code like self.state = self.state.request_review();
to get ownership of
the state
value. This ensures Post
can’t use the old state
value after
we’ve transformed it into a new state.
The request_review
method on Draft
needs to return a new, boxed instance of
a new PendingReview
struct, which represents the state when a post is waiting
for a review. The PendingReview
struct also implements the request_review
method but doesn’t do any transformations. Rather, it returns itself, because
when we request a review on a post already in the PendingReview
state, it
should stay in the PendingReview
state.
Now we can start seeing the advantages of the state pattern: the
request_review
method on Post
is the same no matter its state
value. Each
state is responsible for its own rules.
We’ll leave the content
method on Post
as is, returning an empty string
slice. We can now have a Post
in the PendingReview
state as well as in the
Draft
state, but we want the same behavior in the PendingReview
state.
Listing 17-11 now works up to line 10!
Adding the approve
Method that Changes the Behavior of content
The approve
method will be similar to the request_review
method: it will
set state
to the value that the current state says it should have when that
state is approved, as shown in Listing 17-16:
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
""
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
}
struct Draft {}
impl State for Draft {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
Listing 17-16: Implementing the approve
method on
Post
and the State
trait
We add the approve
method to the State
trait and add a new struct that
implements State
, the Published
state.
Similar to the way request_review
on PendingReview
works, if we call the
approve
method on a Draft
, it will have no effect because approve
will
return self
. When we call approve
on PendingReview
, it returns a new,
boxed instance of the Published
struct. The Published
struct implements the
State
trait, and for both the request_review
method and the approve
method, it returns itself, because the post should stay in the Published
state in those cases.
Now we need to update the content
method on Post
. We want the value
returned from content
to depend on the current state of the Post
, so we're
going to have the Post
delegate to a content
method defined on its state
,
as shown in Listing 17-17:
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
self.state.as_ref().unwrap().content(self)
}
// --snip--
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
Listing 17-17: Updating the content
method on Post
to
delegate to a content
method on State
Because the goal is to keep all these rules inside the structs that implement
State
, we call a content
method on the value in state
and pass the post
instance (that is, self
) as an argument. Then we return the value that is
returned from using the content
method on the state
value.
We call the as_ref
method on the Option
because we want a reference to the
value inside the Option
rather than ownership of the value. Because state
is an Option<Box<dyn State>>
, when we call as_ref
, an Option<&Box<dyn State>>
is returned. If we didn’t call as_ref
, we would get an error because
we can’t move state
out of the borrowed &self
of the function parameter.
We then call the unwrap
method, which we know will never panic, because we
know the methods on Post
ensure that state
will always contain a Some
value when those methods are done. This is one of the cases we talked about in
the “Cases In Which You Have More Information Than the
Compiler” section of Chapter 9 when we
know that a None
value is never possible, even though the compiler isn’t able
to understand that.
At this point, when we call content
on the &Box<dyn State>
, deref coercion will
take effect on the &
and the Box
so the content
method will ultimately be
called on the type that implements the State
trait. That means we need to add
content
to the State
trait definition, and that is where we’ll put the
logic for what content to return depending on which state we have, as shown in
Listing 17-18:
Filename: src/lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
self.state.as_ref().unwrap().content(self)
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
fn content<'a>(&self, post: &'a Post) -> &'a str {
""
}
}
// --snip--
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
fn content<'a>(&self, post: &'a Post) -> &'a str {
&post.content
}
}
Listing 17-18: Adding the content
method to the State
trait
We add a default implementation for the content
method that returns an empty
string slice. That means we don’t need to implement content
on the Draft
and PendingReview
structs. The Published
struct will override the content
method and return the value in post.content
.
Note that we need lifetime annotations on this method, as we discussed in
Chapter 10. We’re taking a reference to a post
as an argument and returning a
reference to part of that post
, so the lifetime of the returned reference is
related to the lifetime of the post
argument.
And we’re done—all of Listing 17-11 now works! We’ve implemented the state
pattern with the rules of the blog post workflow. The logic related to the
rules lives in the state objects rather than being scattered throughout Post
.
Trade-offs of the State Pattern
We’ve shown that Rust is capable of implementing the object-oriented state
pattern to encapsulate the different kinds of behavior a post should have in
each state. The methods on Post
know nothing about the various behaviors. The
way we organized the code, we have to look in only one place to know the
different ways a published post can behave: the implementation of the State
trait on the Published
struct.
If we were to create an alternative implementation that didn’t use the state
pattern, we might instead use match
expressions in the methods on Post
or
even in the main
code that checks the state of the post and changes behavior
in those places. That would mean we would have to look in several places to
understand all the implications of a post being in the published state! This
would only increase the more states we added: each of those match
expressions
would need another arm.
With the state pattern, the Post
methods and the places we use Post
don’t
need match
expressions, and to add a new state, we would only need to add a
new struct and implement the trait methods on that one struct.
The implementation using the state pattern is easy to extend to add more functionality. To see the simplicity of maintaining code that uses the state pattern, try a few of these suggestions:
- Add a
reject
method that changes the post’s state fromPendingReview
back toDraft
. - Require two calls to
approve
before the state can be changed toPublished
. - Allow users to add text content only when a post is in the
Draft
state. Hint: have the state object responsible for what might change about the content but not responsible for modifying thePost
.
One downside of the state pattern is that, because the states implement the
transitions between states, some of the states are coupled to each other. If we
add another state between PendingReview
and Published
, such as Scheduled
,
we would have to change the code in PendingReview
to transition to
Scheduled
instead. It would be less work if PendingReview
didn’t need to
change with the addition of a new state, but that would mean switching to
another design pattern.
Another downside is that we’ve duplicated some logic. To eliminate some of the
duplication, we might try to make default implementations for the
request_review
and approve
methods on the State
trait that return self
;
however, this would violate object safety, because the trait doesn’t know what
the concrete self
will be exactly. We want to be able to use State
as a
trait object, so we need its methods to be object safe.
Other duplication includes the similar implementations of the request_review
and approve
methods on Post
. Both methods delegate to the implementation of
the same method on the value in the state
field of Option
and set the new
value of the state
field to the result. If we had a lot of methods on Post
that followed this pattern, we might consider defining a macro to eliminate the
repetition (see the “Macros” section in Chapter 19).
By implementing the state pattern exactly as it’s defined for object-oriented
languages, we’re not taking as full advantage of Rust’s strengths as we could.
Let’s look at some changes we can make to the blog
crate that can make
invalid states and transitions into compile time errors.
Encoding States and Behavior as Types
We’ll show you how to rethink the state pattern to get a different set of trade-offs. Rather than encapsulating the states and transitions completely so outside code has no knowledge of them, we’ll encode the states into different types. Consequently, Rust’s type checking system will prevent attempts to use draft posts where only published posts are allowed by issuing a compiler error.
Let’s consider the first part of main
in Listing 17-11:
Filename: src/main.rs
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
We still enable the creation of new posts in the draft state using Post::new
and the ability to add text to the post’s content. But instead of having a
content
method on a draft post that returns an empty string, we’ll make it so
draft posts don’t have the content
method at all. That way, if we try to get
a draft post’s content, we’ll get a compiler error telling us the method
doesn’t exist. As a result, it will be impossible for us to accidentally
display draft post content in production, because that code won’t even compile.
Listing 17-19 shows the definition of a Post
struct and a DraftPost
struct,
as well as methods on each:
Filename: src/lib.rs
pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -> DraftPost {
DraftPost {
content: String::new(),
}
}
pub fn content(&self) -> &str {
&self.content
}
}
impl DraftPost {
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
}
Listing 17-19: A Post
with a content
method and a
DraftPost
without a content
method
Both the Post
and DraftPost
structs have a private content
field that
stores the blog post text. The structs no longer have the state
field because
we’re moving the encoding of the state to the types of the structs. The Post
struct will represent a published post, and it has a content
method that
returns the content
.
We still have a Post::new
function, but instead of returning an instance of
Post
, it returns an instance of DraftPost
. Because content
is private
and there aren’t any functions that return Post
, it’s not possible to create
an instance of Post
right now.
The DraftPost
struct has an add_text
method, so we can add text to
content
as before, but note that DraftPost
does not have a content
method
defined! So now the program ensures all posts start as draft posts, and draft
posts don’t have their content available for display. Any attempt to get around
these constraints will result in a compiler error.
Implementing Transitions as Transformations into Different Types
So how do we get a published post? We want to enforce the rule that a draft
post has to be reviewed and approved before it can be published. A post in the
pending review state should still not display any content. Let’s implement
these constraints by adding another struct, PendingReviewPost
, defining the
request_review
method on DraftPost
to return a PendingReviewPost
, and
defining an approve
method on PendingReviewPost
to return a Post
, as
shown in Listing 17-20:
Filename: src/lib.rs
pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -> DraftPost {
DraftPost {
content: String::new(),
}
}
pub fn content(&self) -> &str {
&self.content
}
}
impl DraftPost {
// --snip--
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn request_review(self) -> PendingReviewPost {
PendingReviewPost {
content: self.content,
}
}
}
pub struct PendingReviewPost {
content: String,
}
impl PendingReviewPost {
pub fn approve(self) -> Post {
Post {
content: self.content,
}
}
}
Listing 17-20: A PendingReviewPost
that gets created by
calling request_review
on DraftPost
and an approve
method that turns a
PendingReviewPost
into a published Post
The request_review
and approve
methods take ownership of self
, thus
consuming the DraftPost
and PendingReviewPost
instances and transforming
them into a PendingReviewPost
and a published Post
, respectively. This way,
we won’t have any lingering DraftPost
instances after we’ve called
request_review
on them, and so forth. The PendingReviewPost
struct doesn’t
have a content
method defined on it, so attempting to read its content
results in a compiler error, as with DraftPost
. Because the only way to get a
published Post
instance that does have a content
method defined is to call
the approve
method on a PendingReviewPost
, and the only way to get a
PendingReviewPost
is to call the request_review
method on a DraftPost
,
we’ve now encoded the blog post workflow into the type system.
But we also have to make some small changes to main
. The request_review
and
approve
methods return new instances rather than modifying the struct they’re
called on, so we need to add more let post =
shadowing assignments to save
the returned instances. We also can’t have the assertions about the draft and
pending review posts’ contents be empty strings, nor do we need them: we can’t
compile code that tries to use the content of posts in those states any longer.
The updated code in main
is shown in Listing 17-21:
Filename: src/main.rs
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
let post = post.request_review();
let post = post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
Listing 17-21: Modifications to main
to use the new
implementation of the blog post workflow
The changes we needed to make to main
to reassign post
mean that this
implementation doesn’t quite follow the object-oriented state pattern anymore:
the transformations between the states are no longer encapsulated entirely
within the Post
implementation. However, our gain is that invalid states are
now impossible because of the type system and the type checking that happens at
compile time! This ensures that certain bugs, such as display of the content of
an unpublished post, will be discovered before they make it to production.
Try the tasks suggested for additional requirements that we mentioned at the
start of this section on the blog
crate as it is after Listing 17-20 to see
what you think about the design of this version of the code. Note that some of
the tasks might be completed already in this design.
We’ve seen that even though Rust is capable of implementing object-oriented design patterns, other patterns, such as encoding state into the type system, are also available in Rust. These patterns have different trade-offs. Although you might be very familiar with object-oriented patterns, rethinking the problem to take advantage of Rust’s features can provide benefits, such as preventing some bugs at compile time. Object-oriented patterns won’t always be the best solution in Rust due to certain features, like ownership, that object-oriented languages don’t have.
Summary
No matter whether or not you think Rust is an object-oriented language after reading this chapter, you now know that you can use trait objects to get some object-oriented features in Rust. Dynamic dispatch can give your code some flexibility in exchange for a bit of runtime performance. You can use this flexibility to implement object-oriented patterns that can help your code’s maintainability. Rust also has other features, like ownership, that object-oriented languages don’t have. An object-oriented pattern won’t always be the best way to take advantage of Rust’s strengths, but is an available option.
Next, we’ll look at patterns, which are another of Rust’s features that enable lots of flexibility. We’ve looked at them briefly throughout the book but haven’t seen their full capability yet. Let’s go!
Patterns and Matching
Patterns are a special syntax in Rust for matching against the structure of
types, both complex and simple. Using patterns in conjunction with match
expressions and other constructs gives you more control over a program’s
control flow. A pattern consists of some combination of the following:
- Literals
- Destructured arrays, enums, structs, or tuples
- Variables
- Wildcards
- Placeholders
These components describe the shape of the data we’re working with, which we then match against values to determine whether our program has the correct data to continue running a particular piece of code.
To use a pattern, we compare it to some value. If the pattern matches the
value, we use the value parts in our code. Recall the match
expressions in
Chapter 6 that used patterns, such as the coin-sorting machine example. If the
value fits the shape of the pattern, we can use the named pieces. If it
doesn’t, the code associated with the pattern won’t run.
This chapter is a reference on all things related to patterns. We’ll cover the valid places to use patterns, the difference between refutable and irrefutable patterns, and the different kinds of pattern syntax that you might see. By the end of the chapter, you’ll know how to use patterns to express many concepts in a clear way.
All the Places Patterns Can Be Used
Patterns pop up in a number of places in Rust, and you’ve been using them a lot without realizing it! This section discusses all the places where patterns are valid.
match
Arms
As discussed in Chapter 6, we use patterns in the arms of match
expressions.
Formally, match
expressions are defined as the keyword match
, a value to
match on, and one or more match arms that consist of a pattern and an
expression to run if the value matches that arm’s pattern, like this:
match VALUE {
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
}
One requirement for match
expressions is that they need to be exhaustive in
the sense that all possibilities for the value in the match
expression must
be accounted for. One way to ensure you’ve covered every possibility is to have
a catchall pattern for the last arm: for example, a variable name matching any
value can never fail and thus covers every remaining case.
A particular pattern _
will match anything, but it never binds to a variable,
so it’s often used in the last match arm. The _
pattern can be useful when
you want to ignore any value not specified, for example. We’ll cover the _
pattern in more detail in the “Ignoring Values in a
Pattern” section later in this
chapter.
Conditional if let
Expressions
In Chapter 6 we discussed how to use if let
expressions mainly as a shorter
way to write the equivalent of a match
that only matches one case.
Optionally, if let
can have a corresponding else
containing code to run if
the pattern in the if let
doesn’t match.
Listing 18-1 shows that it’s also possible to mix and match if let
, else if
, and else if let
expressions. Doing so gives us more flexibility than a
match
expression in which we can express only one value to compare with the
patterns. Also, the conditions in a series of if let
, else if
, else if let
arms aren’t required to relate to each other.
The code in Listing 18-1 shows a series of checks for several conditions that decide what the background color should be. For this example, we’ve created variables with hardcoded values that a real program might receive from user input.
Filename: src/main.rs
fn main() { let favorite_color: Option<&str> = None; let is_tuesday = false; let age: Result<u8, _> = "34".parse(); if let Some(color) = favorite_color { println!("Using your favorite color, {}, as the background", color); } else if is_tuesday { println!("Tuesday is green day!"); } else if let Ok(age) = age { if age > 30 { println!("Using purple as the background color"); } else { println!("Using orange as the background color"); } } else { println!("Using blue as the background color"); } }
Listing 18-1: Mixing if let
, else if
, else if let
,
and else
If the user specifies a favorite color, that color is the background color. If today is Tuesday, the background color is green. If the user specifies their age as a string and we can parse it as a number successfully, the color is either purple or orange depending on the value of the number. If none of these conditions apply, the background color is blue.
This conditional structure lets us support complex requirements. With the
hardcoded values we have here, this example will print Using purple as the background color
.
You can see that if let
can also introduce shadowed variables in the same way
that match
arms can: the line if let Ok(age) = age
introduces a new
shadowed age
variable that contains the value inside the Ok
variant. This
means we need to place the if age > 30
condition within that block: we can’t
combine these two conditions into if let Ok(age) = age && age > 30
. The
shadowed age
we want to compare to 30 isn’t valid until the new scope starts
with the curly bracket.
The downside of using if let
expressions is that the compiler doesn’t check
exhaustiveness, whereas with match
expressions it does. If we omitted the
last else
block and therefore missed handling some cases, the compiler would
not alert us to the possible logic bug.
while let
Conditional Loops
Similar in construction to if let
, the while let
conditional loop allows a
while
loop to run for as long as a pattern continues to match. The example in
Listing 18-2 shows a while let
loop that uses a vector as a stack and prints
the values in the vector in the opposite order in which they were pushed.
fn main() { let mut stack = Vec::new(); stack.push(1); stack.push(2); stack.push(3); while let Some(top) = stack.pop() { println!("{}", top); } }
Listing 18-2: Using a while let
loop to print values
for as long as stack.pop()
returns Some
This example prints 3, 2, and then 1. The pop
method takes the last element
out of the vector and returns Some(value)
. If the vector is empty, pop
returns None
. The while
loop continues running the code in its block as
long as pop
returns Some
. When pop
returns None
, the loop stops. We can
use while let
to pop every element off our stack.
for
Loops
In Chapter 3, we mentioned that the for
loop is the most common loop
construction in Rust code, but we haven’t yet discussed the pattern that for
takes. In a for
loop, the pattern is the value that directly follows the
keyword for
, so in for x in y
the x
is the pattern.
Listing 18-3 demonstrates how to use a pattern in a for
loop to destructure,
or break apart, a tuple as part of the for
loop.
fn main() { let v = vec!['a', 'b', 'c']; for (index, value) in v.iter().enumerate() { println!("{} is at index {}", value, index); } }
Listing 18-3: Using a pattern in a for
loop to
destructure a tuple
The code in Listing 18-3 will print the following:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
Finished dev [unoptimized + debuginfo] target(s) in 0.52s
Running `target/debug/patterns`
a is at index 0
b is at index 1
c is at index 2
We use the enumerate
method to adapt an iterator to produce a value and that
value’s index in the iterator, placed into a tuple. The first value produced is
the tuple (0, 'a')
. When this value is matched to the pattern (index, value)
, index
will be 0
and value
will be 'a'
, printing the first line
of the output.
let
Statements
Prior to this chapter, we had only explicitly discussed using patterns with
match
and if let
, but in fact, we’ve used patterns in other places as well,
including in let
statements. For example, consider this straightforward
variable assignment with let
:
#![allow(unused)] fn main() { let x = 5; }
Throughout this book, we’ve used let
like this hundreds of times, and
although you might not have realized it, you were using patterns! More
formally, a let
statement looks like this:
let PATTERN = EXPRESSION;
In statements like let x = 5;
with a variable name in the PATTERN
slot, the
variable name is just a particularly simple form of a pattern. Rust compares
the expression against the pattern and assigns any names it finds. So in the
let x = 5;
example, x
is a pattern that means “bind what matches here to
the variable x
.” Because the name x
is the whole pattern, this pattern
effectively means “bind everything to the variable x
, whatever the value is.”
To see the pattern matching aspect of let
more clearly, consider Listing
18-4, which uses a pattern with let
to destructure a tuple.
fn main() { let (x, y, z) = (1, 2, 3); }
Listing 18-4: Using a pattern to destructure a tuple and create three variables at once
Here, we match a tuple against a pattern. Rust compares the value (1, 2, 3)
to the pattern (x, y, z)
and sees that the value matches the pattern, so Rust
binds 1
to x
, 2
to y
, and 3
to z
. You can think of this tuple
pattern as nesting three individual variable patterns inside it.
If the number of elements in the pattern doesn’t match the number of elements in the tuple, the overall type won’t match and we’ll get a compiler error. For example, Listing 18-5 shows an attempt to destructure a tuple with three elements into two variables, which won’t work.
fn main() {
let (x, y) = (1, 2, 3);
}
Listing 18-5: Incorrectly constructing a pattern whose variables don’t match the number of elements in the tuple
Attempting to compile this code results in this type error:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0308]: mismatched types
--> src/main.rs:2:9
|
2 | let (x, y) = (1, 2, 3);
| ^^^^^^ expected a tuple with 3 elements, found one with 2 elements
|
= note: expected tuple `({integer}, {integer}, {integer})`
found tuple `(_, _)`
For more information about this error, try `rustc --explain E0308`.
error: could not compile `patterns` due to previous error
If we wanted to ignore one or more of the values in the tuple, we could use _
or ..
, as you’ll see in the “Ignoring Values in a
Pattern” section. If the problem
is that we have too many variables in the pattern, the solution is to make the
types match by removing variables so the number of variables equals the number
of elements in the tuple.
Function Parameters
Function parameters can also be patterns. The code in Listing 18-6, which
declares a function named foo
that takes one parameter named x
of type
i32
, should by now look familiar.
fn foo(x: i32) { // code goes here } fn main() {}
Listing 18-6: A function signature uses patterns in the parameters
The x
part is a pattern! As we did with let
, we could match a tuple in a
function’s arguments to the pattern. Listing 18-7 splits the values in a tuple
as we pass it to a function.
Filename: src/main.rs
fn print_coordinates(&(x, y): &(i32, i32)) { println!("Current location: ({}, {})", x, y); } fn main() { let point = (3, 5); print_coordinates(&point); }
Listing 18-7: A function with parameters that destructure a tuple
This code prints Current location: (3, 5)
. The values &(3, 5)
match the
pattern &(x, y)
, so x
is the value 3
and y
is the value 5
.
We can also use patterns in closure parameter lists in the same way as in function parameter lists, because closures are similar to functions, as discussed in Chapter 13.
At this point, you’ve seen several ways of using patterns, but patterns don’t work the same in every place we can use them. In some places, the patterns must be irrefutable; in other circumstances, they can be refutable. We’ll discuss these two concepts next.
Refutability: Whether a Pattern Might Fail to Match
Patterns come in two forms: refutable and irrefutable. Patterns that will match
for any possible value passed are irrefutable. An example would be x
in the
statement let x = 5;
because x
matches anything and therefore cannot fail
to match. Patterns that can fail to match for some possible value are
refutable. An example would be Some(x)
in the expression if let Some(x) = a_value
because if the value in the a_value
variable is None
rather than
Some
, the Some(x)
pattern will not match.
Function parameters, let
statements, and for
loops can only accept
irrefutable patterns, because the program cannot do anything meaningful when
values don’t match. The if let
and while let
expressions accept
refutable and irrefutable patterns, but the compiler warns against
irrefutable patterns because by definition they’re intended to handle possible
failure: the functionality of a conditional is in its ability to perform
differently depending on success or failure.
In general, you shouldn’t have to worry about the distinction between refutable and irrefutable patterns; however, you do need to be familiar with the concept of refutability so you can respond when you see it in an error message. In those cases, you’ll need to change either the pattern or the construct you’re using the pattern with, depending on the intended behavior of the code.
Let’s look at an example of what happens when we try to use a refutable pattern
where Rust requires an irrefutable pattern and vice versa. Listing 18-8 shows a
let
statement, but for the pattern we’ve specified Some(x)
, a refutable
pattern. As you might expect, this code will not compile.
fn main() {
let some_option_value: Option<i32> = None;
let Some(x) = some_option_value;
}
Listing 18-8: Attempting to use a refutable pattern with
let
If some_option_value
was a None
value, it would fail to match the pattern
Some(x)
, meaning the pattern is refutable. However, the let
statement can
only accept an irrefutable pattern because there is nothing valid the code can
do with a None
value. At compile time, Rust will complain that we’ve tried to
use a refutable pattern where an irrefutable pattern is required:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0005]: refutable pattern in local binding: `None` not covered
--> src/main.rs:3:9
|
3 | let Some(x) = some_option_value;
| ^^^^^^^ pattern `None` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
= note: the matched value is of type `Option<i32>`
help: you might want to use `if let` to ignore the variant that isn't matched
|
3 | if let Some(x) = some_option_value { /* */ }
|
For more information about this error, try `rustc --explain E0005`.
error: could not compile `patterns` due to previous error
Because we didn’t cover (and couldn’t cover!) every valid value with the
pattern Some(x)
, Rust rightfully produces a compiler error.
To fix the problem where we have a refutable pattern where an irrefutable
pattern is needed, we can change the code that uses the pattern: instead of
using let
, we can use if let
. Then if the pattern doesn’t match, the code
will just skip the code in the curly brackets, giving it a way to continue
validly. Listing 18-9 shows how to fix the code in Listing 18-8.
fn main() { let some_option_value: Option<i32> = None; if let Some(x) = some_option_value { println!("{}", x); } }
Listing 18-9: Using if let
and a block with refutable
patterns instead of let
We’ve given the code an out! This code is perfectly valid, although it means we
cannot use an irrefutable pattern without receiving an error. If we give if let
a pattern that will always match, such as x
, as shown in Listing 18-10,
the compiler will give a warning.
fn main() { if let x = 5 { println!("{}", x); }; }
Listing 18-10: Attempting to use an irrefutable pattern
with if let
Rust complains that it doesn’t make sense to use if let
with an irrefutable
pattern:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
warning: irrefutable `if let` pattern
--> src/main.rs:2:8
|
2 | if let x = 5 {
| ^^^^^^^^^
|
= note: `#[warn(irrefutable_let_patterns)]` on by default
= note: this pattern will always match, so the `if let` is useless
= help: consider replacing the `if let` with a `let`
warning: `patterns` (bin "patterns") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 0.39s
Running `target/debug/patterns`
5
For this reason, match arms must use refutable patterns, except for the last
arm, which should match any remaining values with an irrefutable pattern. Rust
allows us to use an irrefutable pattern in a match
with only one arm, but
this syntax isn’t particularly useful and could be replaced with a simpler
let
statement.
Now that you know where to use patterns and the difference between refutable and irrefutable patterns, let’s cover all the syntax we can use to create patterns.
Pattern Syntax
Throughout the book, you’ve seen examples of many kinds of patterns. In this section, we gather all the syntax valid in patterns and discuss why you might want to use each one.
Matching Literals
As you saw in Chapter 6, you can match patterns against literals directly. The following code gives some examples:
fn main() { let x = 1; match x { 1 => println!("one"), 2 => println!("two"), 3 => println!("three"), _ => println!("anything"), } }
This code prints one
because the value in x
is 1. This syntax is useful
when you want your code to take an action if it gets a particular concrete
value.
Matching Named Variables
Named variables are irrefutable patterns that match any value, and we’ve used
them many times in the book. However, there is a complication when you use
named variables in match
expressions. Because match
starts a new scope,
variables declared as part of a pattern inside the match
expression will
shadow those with the same name outside the match
construct, as is the case
with all variables. In Listing 18-11, we declare a variable named x
with the
value Some(5)
and a variable y
with the value 10
. We then create a
match
expression on the value x
. Look at the patterns in the match arms and
println!
at the end, and try to figure out what the code will print before
running this code or reading further.
Filename: src/main.rs
fn main() { let x = Some(5); let y = 10; match x { Some(50) => println!("Got 50"), Some(y) => println!("Matched, y = {:?}", y), _ => println!("Default case, x = {:?}", x), } println!("at the end: x = {:?}, y = {:?}", x, y); }
Listing 18-11: A match
expression with an arm that
introduces a shadowed variable y
Let’s walk through what happens when the match
expression runs. The pattern
in the first match arm doesn’t match the defined value of x
, so the code
continues.
The pattern in the second match arm introduces a new variable named y
that
will match any value inside a Some
value. Because we’re in a new scope inside
the match
expression, this is a new y
variable, not the y
we declared at
the beginning with the value 10. This new y
binding will match any value
inside a Some
, which is what we have in x
. Therefore, this new y
binds to
the inner value of the Some
in x
. That value is 5
, so the expression for
that arm executes and prints Matched, y = 5
.
If x
had been a None
value instead of Some(5)
, the patterns in the first
two arms wouldn’t have matched, so the value would have matched to the
underscore. We didn’t introduce the x
variable in the pattern of the
underscore arm, so the x
in the expression is still the outer x
that hasn’t
been shadowed. In this hypothetical case, the match
would print Default case, x = None
.
When the match
expression is done, its scope ends, and so does the scope of
the inner y
. The last println!
produces at the end: x = Some(5), y = 10
.
To create a match
expression that compares the values of the outer x
and
y
, rather than introducing a shadowed variable, we would need to use a match
guard conditional instead. We’ll talk about match guards later in the “Extra
Conditionals with Match Guards” section.
Multiple Patterns
In match
expressions, you can match multiple patterns using the |
syntax,
which means or. For example, the following code matches the value of x
against the match arms, the first of which has an or option, meaning if the
value of x
matches either of the values in that arm, that arm’s code will
run:
fn main() { let x = 1; match x { 1 | 2 => println!("one or two"), 3 => println!("three"), _ => println!("anything"), } }
This code prints one or two
.
Matching Ranges of Values with ..=
The ..=
syntax allows us to match to an inclusive range of values. In the
following code, when a pattern matches any of the values within the range, that
arm will execute:
fn main() { let x = 5; match x { 1..=5 => println!("one through five"), _ => println!("something else"), } }
If x
is 1, 2, 3, 4, or 5, the first arm will match. This syntax is more
convenient than using the |
operator to express the same idea; instead of
1..=5
, we would have to specify 1 | 2 | 3 | 4 | 5
if we used |
.
Specifying a range is much shorter, especially if we want to match, say, any
number between 1 and 1,000!
Ranges are only allowed with numeric values or char
values, because the
compiler checks that the range isn’t empty at compile time. The only types for
which Rust can tell if a range is empty or not are char
and numeric values.
Here is an example using ranges of char
values:
fn main() { let x = 'c'; match x { 'a'..='j' => println!("early ASCII letter"), 'k'..='z' => println!("late ASCII letter"), _ => println!("something else"), } }
Rust can tell that 'c'
is within the first pattern’s range and prints early ASCII letter
.
Destructuring to Break Apart Values
We can also use patterns to destructure structs, enums, and tuples to use different parts of these values. Let’s walk through each value.
Destructuring Structs
Listing 18-12 shows a Point
struct with two fields, x
and y
, that we can
break apart using a pattern with a let
statement.
Filename: src/main.rs
struct Point { x: i32, y: i32, } fn main() { let p = Point { x: 0, y: 7 }; let Point { x: a, y: b } = p; assert_eq!(0, a); assert_eq!(7, b); }
Listing 18-12: Destructuring a struct’s fields into separate variables
This code creates the variables a
and b
that match the values of the x
and y
fields of the p
struct. This example shows that the names of the
variables in the pattern don’t have to match the field names of the struct. But
it’s common to want the variable names to match the field names to make it
easier to remember which variables came from which fields.
Because having variable names match the fields is common and because writing
let Point { x: x, y: y } = p;
contains a lot of duplication, there is a
shorthand for patterns that match struct fields: you only need to list the name
of the struct field, and the variables created from the pattern will have the
same names. Listing 18-13 shows code that behaves in the same way as the code
in Listing 18-12, but the variables created in the let
pattern are x
and
y
instead of a
and b
.
Filename: src/main.rs
struct Point { x: i32, y: i32, } fn main() { let p = Point { x: 0, y: 7 }; let Point { x, y } = p; assert_eq!(0, x); assert_eq!(7, y); }
Listing 18-13: Destructuring struct fields using struct field shorthand
This code creates the variables x
and y
that match the x
and y
fields
of the p
variable. The outcome is that the variables x
and y
contain the
values from the p
struct.
We can also destructure with literal values as part of the struct pattern rather than creating variables for all the fields. Doing so allows us to test some of the fields for particular values while creating variables to destructure the other fields.
Listing 18-14 shows a match
expression that separates Point
values into
three cases: points that lie directly on the x
axis (which is true when y = 0
), on the y
axis (x = 0
), or neither.
Filename: src/main.rs
struct Point { x: i32, y: i32, } fn main() { let p = Point { x: 0, y: 7 }; match p { Point { x, y: 0 } => println!("On the x axis at {}", x), Point { x: 0, y } => println!("On the y axis at {}", y), Point { x, y } => println!("On neither axis: ({}, {})", x, y), } }
Listing 18-14: Destructuring and matching literal values in one pattern
The first arm will match any point that lies on the x
axis by specifying that
the y
field matches if its value matches the literal 0
. The pattern still
creates an x
variable that we can use in the code for this arm.
Similarly, the second arm matches any point on the y
axis by specifying that
the x
field matches if its value is 0
and creates a variable y
for the
value of the y
field. The third arm doesn’t specify any literals, so it
matches any other Point
and creates variables for both the x
and y
fields.
In this example, the value p
matches the second arm by virtue of x
containing a 0, so this code will print On the y axis at 7
.
Destructuring Enums
We’ve destructured enums earlier in this book, for example, when we
destructured Option<i32>
in Listing 6-5 in Chapter 6. One detail we haven’t
mentioned explicitly is that the pattern to destructure an enum should
correspond to the way the data stored within the enum is defined. As an
example, in Listing 18-15 we use the Message
enum from Listing 6-2 and write
a match
with patterns that will destructure each inner value.
Filename: src/main.rs
enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32), } fn main() { let msg = Message::ChangeColor(0, 160, 255); match msg { Message::Quit => { println!("The Quit variant has no data to destructure.") } Message::Move { x, y } => { println!( "Move in the x direction {} and in the y direction {}", x, y ); } Message::Write(text) => println!("Text message: {}", text), Message::ChangeColor(r, g, b) => println!( "Change the color to red {}, green {}, and blue {}", r, g, b ), } }
Listing 18-15: Destructuring enum variants that hold different kinds of values
This code will print Change the color to red 0, green 160, and blue 255
. Try
changing the value of msg
to see the code from the other arms run.
For enum variants without any data, like Message::Quit
, we can’t destructure
the value any further. We can only match on the literal Message::Quit
value,
and no variables are in that pattern.
For struct-like enum variants, such as Message::Move
, we can use a pattern
similar to the pattern we specify to match structs. After the variant name, we
place curly brackets and then list the fields with variables so we break apart
the pieces to use in the code for this arm. Here we use the shorthand form as
we did in Listing 18-13.
For tuple-like enum variants, like Message::Write
that holds a tuple with one
element and Message::ChangeColor
that holds a tuple with three elements, the
pattern is similar to the pattern we specify to match tuples. The number of
variables in the pattern must match the number of elements in the variant we’re
matching.
Destructuring Nested Structs and Enums
Until now, all our examples have been matching structs or enums that were one level deep. Matching can work on nested items too!
For example, we can refactor the code in Listing 18-15 to support RGB and HSV
colors in the ChangeColor
message, as shown in Listing 18-16.
enum Color { Rgb(i32, i32, i32), Hsv(i32, i32, i32), } enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(Color), } fn main() { let msg = Message::ChangeColor(Color::Hsv(0, 160, 255)); match msg { Message::ChangeColor(Color::Rgb(r, g, b)) => println!( "Change the color to red {}, green {}, and blue {}", r, g, b ), Message::ChangeColor(Color::Hsv(h, s, v)) => println!( "Change the color to hue {}, saturation {}, and value {}", h, s, v ), _ => (), } }
Listing 18-16: Matching on nested enums
The pattern of the first arm in the match
expression matches a
Message::ChangeColor
enum variant that contains a Color::Rgb
variant; then
the pattern binds to the three inner i32
values. The pattern of the second
arm also matches a Message::ChangeColor
enum variant, but the inner enum
matches the Color::Hsv
variant instead. We can specify these complex
conditions in one match
expression, even though two enums are involved.
Destructuring Structs and Tuples
We can mix, match, and nest destructuring patterns in even more complex ways. The following example shows a complicated destructure where we nest structs and tuples inside a tuple and destructure all the primitive values out:
fn main() { struct Point { x: i32, y: i32, } let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 }); }
This code lets us break complex types into their component parts so we can use the values we’re interested in separately.
Destructuring with patterns is a convenient way to use pieces of values, such as the value from each field in a struct, separately from each other.
Ignoring Values in a Pattern
You’ve seen that it’s sometimes useful to ignore values in a pattern, such as
in the last arm of a match
, to get a catchall that doesn’t actually do
anything but does account for all remaining possible values. There are a few
ways to ignore entire values or parts of values in a pattern: using the _
pattern (which you’ve seen), using the _
pattern within another pattern,
using a name that starts with an underscore, or using ..
to ignore remaining
parts of a value. Let’s explore how and why to use each of these patterns.
Ignoring an Entire Value with _
We’ve used the underscore (_
) as a wildcard pattern that will match any value
but not bind to the value. Although the underscore _
pattern is especially
useful as the last arm in a match
expression, we can use it in any pattern,
including function parameters, as shown in Listing 18-17.
Filename: src/main.rs
fn foo(_: i32, y: i32) { println!("This code only uses the y parameter: {}", y); } fn main() { foo(3, 4); }
Listing 18-17: Using _
in a function signature
This code will completely ignore the value passed as the first argument, 3
,
and will print This code only uses the y parameter: 4
.
In most cases when you no longer need a particular function parameter, you would change the signature so it doesn’t include the unused parameter. Ignoring a function parameter can be especially useful in some cases, for example, when implementing a trait when you need a certain type signature but the function body in your implementation doesn’t need one of the parameters. The compiler will then not warn about unused function parameters, as it would if you used a name instead.
Ignoring Parts of a Value with a Nested _
We can also use _
inside another pattern to ignore just part of a value, for
example, when we want to test for only part of a value but have no use for the
other parts in the corresponding code we want to run. Listing 18-18 shows code
responsible for managing a setting’s value. The business requirements are that
the user should not be allowed to overwrite an existing customization of a
setting but can unset the setting and give it a value if it is currently unset.
fn main() { let mut setting_value = Some(5); let new_setting_value = Some(10); match (setting_value, new_setting_value) { (Some(_), Some(_)) => { println!("Can't overwrite an existing customized value"); } _ => { setting_value = new_setting_value; } } println!("setting is {:?}", setting_value); }
Listing 18-18: Using an underscore within patterns that
match Some
variants when we don’t need to use the value inside the
Some
This code will print Can't overwrite an existing customized value
and then
setting is Some(5)
. In the first match arm, we don’t need to match on or use
the values inside either Some
variant, but we do need to test for the case
when setting_value
and new_setting_value
are the Some
variant. In that
case, we print why we’re not changing setting_value
, and it doesn’t get
changed.
In all other cases (if either setting_value
or new_setting_value
are
None
) expressed by the _
pattern in the second arm, we want to allow
new_setting_value
to become setting_value
.
We can also use underscores in multiple places within one pattern to ignore particular values. Listing 18-19 shows an example of ignoring the second and fourth values in a tuple of five items.
fn main() { let numbers = (2, 4, 8, 16, 32); match numbers { (first, _, third, _, fifth) => { println!("Some numbers: {}, {}, {}", first, third, fifth) } } }
Listing 18-19: Ignoring multiple parts of a tuple
This code will print Some numbers: 2, 8, 32
, and the values 4 and 16 will be
ignored.
Ignoring an Unused Variable by Starting Its Name with _
If you create a variable but don’t use it anywhere, Rust will usually issue a warning because that could be a bug. But sometimes it’s useful to create a variable you won’t use yet, such as when you’re prototyping or just starting a project. In this situation, you can tell Rust not to warn you about the unused variable by starting the name of the variable with an underscore. In Listing 18-20, we create two unused variables, but when we compile this code, we should only get a warning about one of them.
Filename: src/main.rs
fn main() { let _x = 5; let y = 10; }
Listing 18-20: Starting a variable name with an underscore to avoid getting unused variable warnings
Here we get a warning about not using the variable y
, but we don’t get a
warning about not using the variable preceded by the underscore.
Note that there is a subtle difference between using only _
and using a name
that starts with an underscore. The syntax _x
still binds the value to the
variable, whereas _
doesn’t bind at all. To show a case where this
distinction matters, Listing 18-21 will provide us with an error.
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_s) = s {
println!("found a string");
}
println!("{:?}", s);
}
Listing 18-21: An unused variable starting with an underscore still binds the value, which might take ownership of the value
We’ll receive an error because the s
value will still be moved into _s
,
which prevents us from using s
again. However, using the underscore by itself
doesn’t ever bind to the value. Listing 18-22 will compile without any errors
because s
doesn’t get moved into _
.
fn main() { let s = Some(String::from("Hello!")); if let Some(_) = s { println!("found a string"); } println!("{:?}", s); }
Listing 18-22: Using an underscore does not bind the value
This code works just fine because we never bind s
to anything; it isn’t moved.
Ignoring Remaining Parts of a Value with ..
With values that have many parts, we can use the ..
syntax to use only a few
parts and ignore the rest, avoiding the need to list underscores for each
ignored value. The ..
pattern ignores any parts of a value that we haven’t
explicitly matched in the rest of the pattern. In Listing 18-23, we have a
Point
struct that holds a coordinate in three-dimensional space. In the
match
expression, we want to operate only on the x
coordinate and ignore
the values in the y
and z
fields.
fn main() { struct Point { x: i32, y: i32, z: i32, } let origin = Point { x: 0, y: 0, z: 0 }; match origin { Point { x, .. } => println!("x is {}", x), } }
Listing 18-23: Ignoring all fields of a Point
except
for x
by using ..
We list the x
value and then just include the ..
pattern. This is quicker
than having to list y: _
and z: _
, particularly when we’re working with
structs that have lots of fields in situations where only one or two fields are
relevant.
The syntax ..
will expand to as many values as it needs to be. Listing 18-24
shows how to use ..
with a tuple.
Filename: src/main.rs
fn main() { let numbers = (2, 4, 8, 16, 32); match numbers { (first, .., last) => { println!("Some numbers: {}, {}", first, last); } } }
Listing 18-24: Matching only the first and last values in a tuple and ignoring all other values
In this code, the first and last value are matched with first
and last
. The
..
will match and ignore everything in the middle.
However, using ..
must be unambiguous. If it is unclear which values are
intended for matching and which should be ignored, Rust will give us an error.
Listing 18-25 shows an example of using ..
ambiguously, so it will not
compile.
Filename: src/main.rs
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(.., second, ..) => {
println!("Some numbers: {}", second)
},
}
}
Listing 18-25: An attempt to use ..
in an ambiguous
way
When we compile this example, we get this error:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error: `..` can only be used once per tuple pattern
--> src/main.rs:5:22
|
5 | (.., second, ..) => {
| -- ^^ can only be used once per tuple pattern
| |
| previously used here
error: could not compile `patterns` due to previous error
It’s impossible for Rust to determine how many values in the tuple to ignore
before matching a value with second
and then how many further values to
ignore thereafter. This code could mean that we want to ignore 2
, bind
second
to 4
, and then ignore 8
, 16
, and 32
; or that we want to ignore
2
and 4
, bind second
to 8
, and then ignore 16
and 32
; and so forth.
The variable name second
doesn’t mean anything special to Rust, so we get a
compiler error because using ..
in two places like this is ambiguous.
Extra Conditionals with Match Guards
A match guard is an additional if
condition specified after the pattern in
a match
arm that must also match, along with the pattern matching, for that
arm to be chosen. Match guards are useful for expressing more complex ideas
than a pattern alone allows.
The condition can use variables created in the pattern. Listing 18-26 shows a
match
where the first arm has the pattern Some(x)
and also has a match
guard of if x % 2 == 0
(which will be true if the number is even).
fn main() { let num = Some(4); match num { Some(x) if x % 2 == 0 => println!("The number {} is even", x), Some(x) => println!("The number {} is odd", x), None => (), } }
Listing 18-26: Adding a match guard to a pattern
This example will print The number 4 is even
. When num
is compared to the
pattern in the first arm, it matches, because Some(4)
matches Some(x)
. Then
the match guard checks whether the remainder of dividing x
by 2 is equal to
0, and because it is, the first arm is selected.
If num
had been Some(5)
instead, the match guard in the first arm would
have been false because the remainder of 5 divided by 2 is 1, which is not
equal to 0. Rust would then go to the second arm, which would match because the
second arm doesn’t have a match guard and therefore matches any Some
variant.
There is no way to express the if x % 2 == 0
condition within a pattern, so
the match guard gives us the ability to express this logic. The downside of
this additional expressiveness is that the compiler doesn't try to check for
exhaustiveness when match guard expressions are involved.
In Listing 18-11, we mentioned that we could use match guards to solve our
pattern-shadowing problem. Recall that a new variable was created inside the
pattern in the match
expression instead of using the variable outside the
match
. That new variable meant we couldn’t test against the value of the
outer variable. Listing 18-27 shows how we can use a match guard to fix this
problem.
Filename: src/main.rs
fn main() { let x = Some(5); let y = 10; match x { Some(50) => println!("Got 50"), Some(n) if n == y => println!("Matched, n = {}", n), _ => println!("Default case, x = {:?}", x), } println!("at the end: x = {:?}, y = {}", x, y); }
Listing 18-27: Using a match guard to test for equality with an outer variable
This code will now print Default case, x = Some(5)
. The pattern in the second
match arm doesn’t introduce a new variable y
that would shadow the outer y
,
meaning we can use the outer y
in the match guard. Instead of specifying the
pattern as Some(y)
, which would have shadowed the outer y
, we specify
Some(n)
. This creates a new variable n
that doesn’t shadow anything because
there is no n
variable outside the match
.
The match guard if n == y
is not a pattern and therefore doesn’t introduce
new variables. This y
is the outer y
rather than a new shadowed y
, and
we can look for a value that has the same value as the outer y
by comparing
n
to y
.
You can also use the or operator |
in a match guard to specify multiple
patterns; the match guard condition will apply to all the patterns. Listing
18-28 shows the precedence of combining a match guard with a pattern that uses
|
. The important part of this example is that the if y
match guard applies
to 4
, 5
, and 6
, even though it might look like if y
only applies to
6
.
fn main() { let x = 4; let y = false; match x { 4 | 5 | 6 if y => println!("yes"), _ => println!("no"), } }
Listing 18-28: Combining multiple patterns with a match guard
The match condition states that the arm only matches if the value of x
is
equal to 4
, 5
, or 6
and if y
is true
. When this code runs, the
pattern of the first arm matches because x
is 4
, but the match guard if y
is false, so the first arm is not chosen. The code moves on to the second arm,
which does match, and this program prints no
. The reason is that the if
condition applies to the whole pattern 4 | 5 | 6
, not only to the last value
6
. In other words, the precedence of a match guard in relation to a pattern
behaves like this:
(4 | 5 | 6) if y => ...
rather than this:
4 | 5 | (6 if y) => ...
After running the code, the precedence behavior is evident: if the match guard
were applied only to the final value in the list of values specified using the
|
operator, the arm would have matched and the program would have printed
yes
.
@
Bindings
The at operator (@
) lets us create a variable that holds a value at the
same time we’re testing that value to see whether it matches a pattern. Listing
18-29 shows an example where we want to test that a Message::Hello
id
field
is within the range 3..=7
. But we also want to bind the value to the variable
id_variable
so we can use it in the code associated with the arm. We could
name this variable id
, the same as the field, but for this example we’ll use
a different name.
fn main() { enum Message { Hello { id: i32 }, } let msg = Message::Hello { id: 5 }; match msg { Message::Hello { id: id_variable @ 3..=7, } => println!("Found an id in range: {}", id_variable), Message::Hello { id: 10..=12 } => { println!("Found an id in another range") } Message::Hello { id } => println!("Found some other id: {}", id), } }
Listing 18-29: Using @
to bind to a value in a pattern
while also testing it
This example will print Found an id in range: 5
. By specifying id_variable @
before the range 3..=7
, we’re capturing whatever value matched the range
while also testing that the value matched the range pattern.
In the second arm, where we only have a range specified in the pattern, the code
associated with the arm doesn’t have a variable that contains the actual value
of the id
field. The id
field’s value could have been 10, 11, or 12, but
the code that goes with that pattern doesn’t know which it is. The pattern code
isn’t able to use the value from the id
field, because we haven’t saved the
id
value in a variable.
In the last arm, where we’ve specified a variable without a range, we do have
the value available to use in the arm’s code in a variable named id
. The
reason is that we’ve used the struct field shorthand syntax. But we haven’t
applied any test to the value in the id
field in this arm, as we did with the
first two arms: any value would match this pattern.
Using @
lets us test a value and save it in a variable within one pattern.
Summary
Rust’s patterns are very useful in that they help distinguish between different
kinds of data. When used in match
expressions, Rust ensures your patterns
cover every possible value, or your program won’t compile. Patterns in let
statements and function parameters make those constructs more useful, enabling
the destructuring of values into smaller parts at the same time as assigning to
variables. We can create simple or complex patterns to suit our needs.
Next, for the penultimate chapter of the book, we’ll look at some advanced aspects of a variety of Rust’s features.
Các tính năng nâng cao
Đến thời điểm hiện tại, ta đã đi qua phần lớn các nội dung trong lập trình Rust. Trước khi đến với chương 20, hãy tiếp cận một vài khía cạnh mới của ngôn ngữ này mà chắc chắn bạn sẽ gặp phải trong quá trình lập trình Rust. Chương này giới thiệu các khái niệm khó và nâng cao khi sử dụng Rust, bạn có thể dùng nó như tài liệu tham khảo khi bắt gặp các vấn đề phức tạp. Mặc dù có thể sẽ không thường xuyên gặp phải chúng, nhưng hãy đảm bảo rằng bạn luôn có đủ kiến thức cần thiết để giải quyết vấn đề.
Chương này sẽ nói đến các vấn đề như sau:
- Unsafe Rust: làm sao để đưa Rust ra khỏi vùng an toàn
- Advanced traits: các khái niệm associated types, default type parameters, fully qualified syntax, supertraits trong quá trình sử dụng traits
- Advanced types: newtype pattern, type aliases, never type, và dynamically sized types
- Advanced functions và closures: con trỏ hàm và cách trả về một closures
Unsafe Rust
Tất cả các đoạn code đã trình bày trước đó đều được Rust bảo vệ và ngăn chặn nếu gặp lỗi ngay từ compile time (Rust's memory safety guarantees). Tuy nhiên, Rust cũng có một tính năng ẩn khác mà không hề được compiler kiểm định và soát lỗi khi biên dịch: đó là unsafe Rust. Nó cũng giống như Rust thông thường, tuy nhiên unsafe Rust tự do và khó kiểm soát hơn Rust.
Tại sao phải sinh ra unsafe rust! Lý do là Rust compiler đôi khi tỏ ra quá an toàn khi thực hiện biên dịch chương trình. Khi code của bạn rơi vào trường hợp không chắc chắn an toàn hay không, thì mặc định compiler sẽ từ chối và coi đây là một lỗi, mặc dù có thể không phải như vậy. Cơ chế này giúp ta ngăn ngừa các lỗi tiềm ẩn, tuy nhiên nếu lập trình viên cố tình muốn thực hiện các đoạn code này thì sao? Ta sẽ nói với compiler, "Hãy tin ở tôi, tôi hiểu mình đang làm gì". Đây là một sự đánh đổi, code của bạn sẽ được thực thi với một tỉ lệ rủi ro nào đó, tính toán sai có thể dẫn đến các lỗi về bộ nhớ (memory) như truy cập vào con trỏ null (null pointer), rò rỉ bộ nhớ (leaked memory), ...
Một lí do khác khiến cơ chế unsafe được tạo ra là Rust muốn tiếp cận với phần cứng của hệ điều hành giống như những ngôn ngữ lập trình bậc thấp, mà bản chất các ngôn ngữ này đều chạy cơ chế unsafe. Nếu Rust không cũng cấp unsafe, sẽ rất khó để bạn có thể làm được những điều này. Hãy cùng khám phá những điều có thê làm với unsafe Rust.
Sức mạnh của Unsafe
Để sử dụng unsafe Rust, dùng keyword unsafe
và tạo một block chứa các unsafe code mà bạn muốn. Có 5 điều mà unsafe Rust có thể làm mà bạn sẽ không thể có được ở Rust thông thường:
- Dereference một raw pointer (các khái niệm Dereference và raw pointer sẽ được giải thích sau)
- Gọi unsafe function hoặc unsafe method
- Truy cập và chỉnh sửa một mutable static variable
- Implement unsafe trait
- Truy cập vào trường dữ liệu bên trong
union
Việc sử dụng unsafe
hoàn toàn không loại bỏ việc sử dụng borrow checker (dùng để quản lí quyền sở hữu của dữ liệu) hay các công cụ quan lí bộ nhớ khác của Rust: nếu bạn sử dụng tham chiếu trong unsafe code, tham chiếu này vẫn sẽ được kiểm tra. Từ khóa unsafe
chỉ làm cho compiler không quản lí các tác vụ liên quan đến vùng nhớ nằm trong 5 tính năng đã đề cập ở trên.
Hơn nữa, unsafe
không có nghĩa là đoạn code đó lúc nào cũng gây lỗi bộ nhớ: nó chỉ chuyển quyền quyết định từ compiler cho người lập trình. Lập trình viên chính là người quản lí những rủi ro đó.
Con người thì luôn mắc sai lầm, tuy nhiên việc giới hạn ở 5 tính năng trên sẽ giúp bạn khoanh vùng lỗi một cách dễ dàng hơn (nếu có lỗi xảy ra), unsafe
block càng nhỏ thì bạn sẽ debug càng dễ dàng.
Để tách bạch phần unsafe code, ta nên bao bên ngoài chúng một safe API để có thể ngăn ngừa việc mất kiểm soát chương trình nếu đoạn unsafe đó xảy ra lỗi.
Bây giờ hãy xem xét lần lượt 5 tính năng trên
Dereferencing một Raw Pointer
Phần “Dangling References” trong chương 4, đề cập đến việc compiler luôn luôn kiểm tra tham chiếu có hợp lệ hay không. Unsafe Rust cung cấp kiểu tham chiếu mới có tên là raw pointers, tương tự như tham chiếu trong safe Rust. Raw pointers có thể thay đổi được (mutable) hoặc không (immutable), cú pháp tương ứng ở đây là *mut T
và *const T
. Dấu *
không phải là toán tử dereference mà chỉ đơn giản là cú pháp bắt buộc của raw pointer. Chú ý rằng, immutable nghĩa là con trỏ đó sẽ không thể trực tiếp thay đổi giá trị của biến mà nó trỏ tới.
Sự khác biệt của raw pointers với tham chiếu (references) và smart pointers:
- Cho phép có nhiều mutable pointers cùng trỏ vào một vùng nhớ
- Không kiểm tra tham chiếu có hợp lệ hay không
- Cho phép sử dụng con trỏ null
- Không tự động giải phóng vùng nhớ
Với việc bỏ qua các rules về tham chiếu, con trỏ mà safe Rust cung cấp, ta có thể nâng cao được hiệu năng hoạt động của chương trình cũng như việc tương tác với phần cứng máy tính.
Listing 19-1 cho ta thấy cách tạo một immutable và mutable raw pointer.
fn main() { let mut num = 5; let r1 = &num as *const i32; let r2 = &mut num as *mut i32; }
Listing 19-1: Cách tạo một immutable và mutable raw pointer.
Raw pointer khá giống với con trỏ trong C/C++, sẽ rất đơn giản cho những ai đã có nền tảng về lập trình hệ thống, lập trình nhúng... sử dụng C/C++. Ở đây ta không cần sử dụng từ khóa unsafe khi khởi tạo raw pointers vì đây là một hành động chưa gây hại cho hệ thống, unsafe chỉ cần thiết khi ta truy cập vào giá trị mà con trỏ đó trỏ đến (dereference).
Tiếp theo, ta sẽ tạo một raw pointer mà không biết được nó có hợp lệ hay không. Listing 19-2 là một ví dụ: tạo một raw pointer để trỏ đến một địa chỉ ô nhớ bất kì trong memory. Compiler sẽ không biết được tại địa chỉ này có dữ liệu hay không, vì vậy ta có thể sẽ gặp lỗi segmentation fault (khá giống trong C/C++). Mặc dù không nên viết code như vậy, nó vẫn được chấp nhận trong unsafe Rust.
fn main() { let address = 0x012345usize; let r = address as *const i32; }
Listing 19-2: Tạo raw pointer để trỏ đến vùng nhớ bất kì
Nhớ rằng ta có thể tạo một raw pointer trong safe code, nhưng không thể truy cập vào giá trị mà nó trỏ đến (dereference). Ở Listing 19-3 là một ví dụ sử dụng toán tử dereference *
trong unsafe code.
fn main() { let mut num = 5; let r1 = &num as *const i32; let r2 = &mut num as *mut i32; unsafe { println!("r1 is: {}", *r1); println!("r2 is: {}", *r2); } }
Listing 19-3: Truy cập vào giá trị mà raw pointer trỏ đến (dereference) trong unsafe block
Khởi tạo một con trỏ sẽ không gây hại cho hệ thống; nó chỉ nguy hiểm khi ta cố gắng truy cập vào vùng nhớ không hợp lệ mà nó trỏ đến
Chú ý rằng ở Listing 19-1 và 19-3, ta sử dụng immutable và mutable raw pointers để trỏ đến cùng một vùng nhớ của biến num
. Nếu sử dụng immutable và mutable reference thay vì raw pointer, khi compile sẽ xảy ra lỗi vì liên quan đến quyền sở hữu trong Rust (Rust's ownership). Tuy nhiên với raw pointer, ta hoàn toàn có thể làm được điều này, chỉ có điều việc này có thể sẽ tiềm tàng lỗi liên quan đến data race. Hãy cần trọng khi sử dụng!
Với những nguy hiểm tiềm tàng như vậy, tại sao raw pointer vẫn được sinh ra? Câu trả lời sẽ có trong phần tiếp theo, “Calling an Unsafe Function or Method.”.
Gọi đến Unsafe Function hoặc Unsafe Method
Tạo một unsafe function hay unsafe method cũng giống như tạo function hay method thông thường, chỉ khác ở từ khóa unsafe ở phía trước.
Đây là một ví dụ về việc tạo unsafe function có tên dangerous
fn main() { unsafe fn dangerous() {} unsafe { dangerous(); } }
Phải gọi hàm dangerous
này trong một unsafe block riêng biệt. Nếu không khi compile chương trình sẽ báo lỗi.
$ cargo run
Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
--> src/main.rs:4:5
|
4 | dangerous();
| ^^^^^^^^^^^ call to unsafe function
|
= note: consult the function's documentation for information on how to avoid undefined behavior
For more information about this error, try `rustc --explain E0133`.
error: could not compile `unsafe-example` due to previous error
Phần thân của unsafe function hoạt động giống như unsafe
blocks, vì vậy ta không cần phải dùng từ khóa unsafe
cho thân hàm nữa.
Tạo một Safe Abstraction bằng Unsafe Code
Hàm có chưa một đoạn unsafe code không đồng nghĩa với việc cả hàm đó là unsafe. Trong thực tế, bọc unsafe code bởi một safe function là một việc làm rất phổ biến. Xét ví dụ sau, safe method split_at_mut
sẽ bao bên ngoài của unsafe code. Chức năng của hàm này là chia một mutable slice thành hai phần và trả về 2 slices đó.
fn main() { let mut v = vec![1, 2, 3, 4, 5, 6]; let r = &mut v[..]; let (a, b) = r.split_at_mut(3); assert_eq!(a, &mut [1, 2, 3]); assert_eq!(b, &mut [4, 5, 6]); }
Listing 19-4: Sử dụng safe function split_at_mut
Nếu bạn chỉ viết hàm này ở safe code, chương trình sẽ báo lỗi vào không thể biên dịch (listing 19-5). Để đơn giản, ta sẽ dùng function thay vì method và dùng slice kiểu i32
thay cho generic type T
.
fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
let len = values.len();
assert!(mid <= len);
(&mut values[..mid], &mut values[mid..])
}
fn main() {
let mut vector = vec![1, 2, 3, 4, 5, 6];
let (left, right) = split_at_mut(&mut vector, 3);
}
Listing 19-5: Viết hàm split_at_mut
sử dụng safe Rust
Hàm này đầu tiên sẽ lấy được tổng số phần tử của slice. Sau đó sẽ kiểm tra xem phần tử có index truyền vào có thuộc slice đó không qua việc so sánh với length. Nếu không chương trình sẽ panic.
Sau đó hàm sẽ return 2 mutable slices ở trong một tuple: slice thứ nhất sẽ bắt đầu từ phần tử 0 đến phần tử mid
của slice gốc và slice thứ 2 sẽ là phần còn lại.
Nếu compile chương trình ở Listing 19-5, ta sẽ gặp lỗi như sau:
$ cargo run
Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
error[E0499]: cannot borrow `*values` as mutable more than once at a time
--> src/main.rs:6:31
|
1 | fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
| - let's call the lifetime of this reference `'1`
...
6 | (&mut values[..mid], &mut values[mid..])
| --------------------------^^^^^^--------
| | | |
| | | second mutable borrow occurs here
| | first mutable borrow occurs here
| returning this value requires that `*values` is borrowed for `'1`
For more information about this error, try `rustc --explain E0499`.
error: could not compile `unsafe-example` due to previous error
Rust's borrow checker (dùng để kiểm tra quyền sở hữu của các biến) không thể biết được ta đang mượn 2 slice tách biệt; nó chỉ biết rằng ta đang mượn từ cùng một slice gốc. Do đó để tránh rủi ro, Rust sẽ coi đây là một lỗi và không cho chương trình được biên dịch, lúc này ta phải cần đến unsafe code.
Listing 19-6 cho ta thấy cách sử dụng unsafe
block, raw pointer, unsafe function để viết hàm split_at_mut
.
use std::slice; fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) { let len = values.len(); let ptr = values.as_mut_ptr(); assert!(mid <= len); unsafe { ( slice::from_raw_parts_mut(ptr, mid), slice::from_raw_parts_mut(ptr.add(mid), len - mid), ) } } fn main() { let mut vector = vec![1, 2, 3, 4, 5, 6]; let (left, right) = split_at_mut(&mut vector, 3); }
Listing 19-6: Sử dụng unsafe code để viết hàm split_at_mut
Slice thực chất là con trỏ trỏ tới một vùng nhớ có kích thước xác định (xem thêm “The Slice Type”). Dùng method len
để lấy ra kích thước của slice và method as_mut_ptr
để tạo ra raw pointer của slice đó.
Sau đó là phần unsafe code, hàm slice::from_raw_parts_mut
sẽ tạo ra một slice mới dựa trên raw pointer truyền vào và kích thước mong muốn. Method add
với tham số mid
có nhiệm vụ đưa con trỏ trỏ tới vị trí mid
của slice gốc.
Hàm slice::from_raw_parts_mut
là một unsafe function bởi nó sử dụng raw pointer và không biết được con trỏ đó có hợp lệ hay không. Method add
cũng vậy, vì nó hoàn toàn không biết index được truyền vào có nằm trong slice hay không. Do đó, ta phải đưa những đoạn code này vào trong unsafe block.
Chú ý rằng ta không cần phải đánh dấu hàm split_at_mut
là unsafe bởi nó chỉ return các con trỏ hoàn toàn hợp lệ. Nhớ rằng việc tạo con trỏ không hề nguy hiểm, nó chỉ nguy hiểm khi truy cập đến giá trị của con trỏ đó mà thôi.
Ngược lại, việc dùng hàm slice:from_raw_parts_mut
ở Listing 19-7 có thể xảy ra lỗi khi chạy chương trình. Đoạn code này sẽ truy cập vào một vùng nhớ bất kì và tạo một slice có 10000 phần tử.
fn main() { use std::slice; let address = 0x01234usize; let r = address as *mut i32; let values: &[i32] = unsafe { slice::from_raw_parts_mut(r, 10000) }; }
Listing 19-7: Tạo slice từ một vùng nhớ bất kì
Ta không chắc rằng mình có quyền sở hữu vùng nhớ đó, nên không thể chắc chắn rằng vùng nhớ đó chỉ chứa các giá trị i32
. Cố gắng sử dụng các giá trị đó làm một hành động không được phép (undefined behavior).
Sử dụng extern
để gọi tới External Code
Trong một vài trường hợp, ta muốn sử dụng Rust để tương tác với một ngôn ngữ lập trình khác. Trong trường hợp này, Rust cung cấp từ khóa extern
, giúp ta có thể dễ dàng hơn trong việc sử dụng Foreign Function Interface (FFI). FFI là cách để một ngôn ngữ lập trình có thể định nghĩa các hàm để ngôn ngữ khác có thể gọi tới.
Listing 19-8 giải thích cách thực hiện với hàm abs
từ thư viện của ngôn ngữ C. Hàm này được định nghĩa ở trong extern
blocks và được coi như là unsafe code trong Rust. Lý do là vì các ngôn ngữ khác không có cơ chế về bảo vệ và quản lí vùng nhớ như Rust, do đó Rust không thể kiểm soát chúng một cách thông thường được.
Filename: src/main.rs
extern "C" { fn abs(input: i32) -> i32; } fn main() { unsafe { println!("Absolute value of -3 according to C: {}", abs(-3)); } }
Listing 19-8: Khai báo và gọi một extern
function được định nghĩa bởi ngôn ngữ khác
Gọi Rust Functions từ ngôn ngữ khác
Ta hoàn toàn có thể sử dụng
extern
để tạo một interface cho phép các ngôn ngữ lập trình khác gọi đến hàm của Rust. Thay vì mộtextern
block, ta sẽ sử dụng từ khóaextern
kèm theo ABI (application binary interface) cụ thể ngay phía trước từ khóafn
. Annotation#[no_mangle]
sẽ được sử dụng để chỉ dẫn cho compiler không biến đổi (mangle) tên hàm. Mangling xảy ra khi compiler thay đổi tên của hàm phục vụ cho quá trình biên dịch nhưng sẽ khó nhìn hơn cho lập trình viên. Mỗi ngôn ngữ sẽ có cách biến đổi tên của riêng mình, vì vậy ta phải disable cách biến đổi tên của Rust (Rust compiler's name mangling).Ở ví dụ sau đây, hàm
call_from_c
sẽ được gọi từ code C, sau khi đã được biên dịch và liên kết các thư viện cần thiết.#![allow(unused)] fn main() { #[no_mangle] pub extern "C" fn call_from_c() { println!("Just called a Rust function from C!"); } }
Trường hợp này không bắt buộc dùng từ khóa
unsafe
.
Truy cập hoặc thay đổi một Mutable Static Variable
Rust không định nghĩa kiểu biến global, lí do là bởi quyền sở hữu (ownership rules). Nếu 2 threads cùng truy cập một biến global, có thể sẽ dẫn đến hiện tượng data race.
Trong Rust, biến global được gọi là biến static. Listing 19-9 là một ví dụ về cách sử dụng biến static.
Filename: src/main.rs
static HELLO_WORLD: &str = "Hello, world!"; fn main() { println!("name is: {}", HELLO_WORLD); }
Listing 19-9: Định nghĩa và sử dụng một immutable static variable
Biến static có nhiều điểm tương đồng với hằng số (constants), điều đã được nhắc đến trong phần “Differences Between Variables and Constants” ở chương 3. Biến static chỉ được tham chiếu với lifetime là static
, nghĩa là Rust có thể biết được lifetime của biến đó ngay từ đầu và ta không có cách nào thay đổi. Truy cập vào một immutable static variable là một hành động an toàn.
Constants và immutable static variable có nhiều điểm tưởng đồng, nhưng chúng khác nhau ở chỗ giá trị của biến static có địa chỉ cố định. Sử dụng giá trị này, ta sẽ luôn truy cập đến một vùng nhớ duy nhất. Đối với contants, dữ liệu sẽ được sao chép tới một vùng nhớ khác mỗi khi ta truy cập vào hằng số đó.
Một điểm khác biệt nữa giữa contants và static variable là biến static có thể thay đổi được. Tuy nhiên việc truy cập và thay đổi một mutable static variable là một hành động unsafe. Listing 19-10 chỉ ra cách khai báo, truy cập và thay đổi một mutable static variable có tên là COUNTER
.
Filename: src/main.rs
static mut COUNTER: u32 = 0; fn add_to_count(inc: u32) { unsafe { COUNTER += inc; } } fn main() { add_to_count(3); unsafe { println!("COUNTER: {}", COUNTER); } }
Listing 19-10: Đọc và ghi một mutable static variable là một hành động unsafe
Sử dụng từ khóa mut
để khai báo một mutable static variable. Các đoạn code liên quan đến việc đọc à ghi biến COUNTER
đều phải được đặt trong unsafe
block. Đoạn code trên sẽ in ra màn hình COUNTER: 3
như kì vọng bởi đây là chương trình single threaded. Đa luồng với chương trình trên có thể sẽ dẫn tới hiện tượng data races.
Với việc thay đổi dữ liệu với quyền truy cập toàn cục, rất khó để đảm bảo rằng không có data race xảy ra, đó là lý do Rust phải đưa chúng vào trong unsafe. Nếu có thể, hay sử dụng các kĩ thuật về đa luồng và lập trình song song được nhắc đến trong chương 16 để giúp cho chương trình an toàn hơn.
Implementing một Unsafe Trait
Một trường hợp khác phải dùng unsafe
là khi implement một unsafe trait. Trait được gọi là unsafe khi ít nhất một method trong nó khiến compiler không thể chắc chắn rằng method đó an toàn. Ta có thể khai báo một unsafe
trait bằng cách thêm từ khóa unsafe
trước trait đó đồng thời đánh dấu unsafe
cho trait khi implement. Ví dụ:
unsafe trait Foo { // methods go here } unsafe impl Foo for i32 { // method implementations go here } fn main() {}
Listing 19-11: Định nghĩa và implement một unsafe trait
Ta sẽ giao kèo với compiler rằng sẽ chịu trách nhiệm cho các unsafe method bằng cách sử dụng unsafe impl
.
Truy cập vào các trường trong một Union
Một union
tương tự như một struct
, nhưng chỉ có một trường dữ liệu được sử dụng trong một instance ở một thời điểm. Truy cập vào các trường trong union là một hành động unsafe. Bạn có thể đọc thêm tại đây the Rust Reference.
Khi nào thì sử dụng Unsafe Code
Sử dụng unsafe
khi muốn có một trong 5 hành động (superpowers) đã nhắc đến ở phía trên. Hãy sử dụng chỉ khi thực sự cần thiết, bởi bạn chứ không phải compiler sẽ là người phải chịu trách nhiệm nếu cho các lỗi phát sinh sau này.
Advanced Traits
Traits đã được nhắc đến trong chương 10 “Traits: Defining Shared Behavior”, tuy nhiên đó chỉ là những kiến thức cơ bản nhất của traits mà thôi. Trong chương này, ta sẽ đi sâu hơn vào những tính năng nâng cao của traits.
Sử dụng Associated Types khi định nghĩa Trait
Associated types có thể được sử dụng khi định nghĩa Trait mà khi implement nó ta hoàn toàn biết trước được kiểu dữ liệu mà trait đó muốn sử dụng.
Các tính năng nâng cao khác ở chương này đa số đều ít khi được sử dụng, tuy nhiên associated types lại ở khoảng giữa: nó không được sử dụng quá nhiều như những tính năng khác được mô tả ở trong cuốn sách này nhưng lại được sử dụng phổ biến hơn các tính năng nâng cao khác.
Một ví dụ điển hình của việc sử dụng associated type trong trait là Iterator
của thư viện chuẩn trong Rust. Associated type có tên là Item
ở trong trường hợp này. Trong phần “The Iterator
Trait and the next
Method”, ta đã đề cập đến định nghĩa của Iterator
trait
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
Listing 19-12: Định nghĩa Iterator
trait sử dụng associated type Item
Kiểu Item
còn được gọi là placeholder type, next
method sẽ trả về một kiểu Option<Self::Item>
. Các struct implement Iterator
này đều sẽ có một kiểu dữ liệu duy nhất và cố định là Item
, next
method làm nhiệm vụ trả về Option
chứa Item đó.
Đến đây ta có thể thấy khá nhiều điểm tương đồng giữa associated type và generics type, vậy tại sao phải sử dụng associated types?
Ví dụ sau sẽ cho ta thấy sự khác biệt giữa 2 cách dùng. Ở chương 13, listing 13-21 sử dụng associated type Item
bằng u32
:
Filename: src/lib.rs
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
// --snip--
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
Và cú pháp dùng generics được mô tả trong listing 19-13?
pub trait Iterator<T> {
fn next(&mut self) -> Option<T>;
}
Listing 19-13: Đinh nghĩa Iterator
trait sử dụng generics
Sự khác biệt ở đây là khi dùng generics, ta phải chú thích kiểu dữ liệu cho mỗi lần implement; hoàn toàn có thể implement Iterator<String> for Counter
hoặc bất kì kiểu dữ liệu nào khác ngoài u32
, do đó ta có thể có rất nhiều các phiên bản khác nhau của Iterator
cho Counter
. Nói một cách khác, khi một trait sử dụng generics parameter, nó có thể implement rất nhiều lần, thay đổi kiểu dữ liệu cho mỗi lần đó. Khi sử dụng method next
, ta bắt buộc phải cung cấp kiểu dữ liệu để thể hiện Iterator
nào được sử dụng.
Với associated types, ta không cần phải chú thích kiểu dữ liệu như vậy bởi trait này không thể implement nhiều lần, Iterator
chỉ có Item
với kiểu dữ liệu duy nhất là u32
mà thôi.
Tham số Generic Type mặc định và nạp chồng toán tử (Operator Overloading)
Khi sử dụng generic type, ta có thể chỉ định tham số mặc định cho nó. Cú pháp ở đây là <PlaceholderType=ConcreteType>
.
Một ví dụ tuyệt vời nhất cho trường hợp này là khi dùng đến nạp chồng toán tử (operator overloading). Operator overloading dùng để biến tấu hành vi của một toán tử (như là +
) trong vài trường hợp cụ thể.
Rust không cho phép bạn tạo mới một toán tử hay nạp chồng một toán tử bất kì. Tuy nhiên, bạn có thể nạp chồng một toán tử nếu toán tử đó nằm trong thư viện std::ops
bằng cách implement toán tử nằm trong chính thư viện này. Ví dụ trong listing 19-4, ta sẽ nạp chồng toán tử +
để cộng 2 Point
với nhau. Để làm được điều này, ta phải implement Add
trait cho Point
struct:
Filename: src/main.rs
use std::ops::Add; #[derive(Debug, Copy, Clone, PartialEq)] struct Point { x: i32, y: i32, } impl Add for Point { type Output = Point; fn add(self, other: Point) -> Point { Point { x: self.x + other.x, y: self.y + other.y, } } } fn main() { assert_eq!( Point { x: 1, y: 0 } + Point { x: 2, y: 3 }, Point { x: 3, y: 3 } ); }
Listing 19-14: Implementing Add
trait để nạp chồng toán tử +
cho instances Point
Method add
sẽ cộng hoành độ và tung độ tương ứng của 2 Point
. Trait Add
lúc này sẽ có một associated type là Output
.
Generic type mặc định được nằm trong phần định nghĩa Add
trait, như sau:
#![allow(unused)] fn main() { trait Add<Rhs=Self> { type Output; fn add(self, rhs: Rhs) -> Self::Output; } }
Ta có thể thấy phần khác biệt ở đây là Rhs=Self
: cú pháp này được gọi là default type parameters. Rhs
(viết tắt của "right hand side") sẽ định nghĩa kiểu dữ liệu cho biến rhs
được dùng trong method add
. Nếu ta không chỉ định kiểu dữ liệu cho Rhs
khi implement, Rhs
khi đó sẽ mặc định có kiểu Self
.
Khi implement Add
cho Point
, ta sẽ sử dụng kiểu mặc định cho Rhs
vì mục đích cuối cùng là cộng 2 Point
instances. Cùng xem ví dụ mà ở đây ta sẽ implement Add
trait và không sử dụng kiểu mặc định cho Rhs
nữa.
Ở đây có 2 structs, Millimeters
và Meters
, thể hiện giá trị ở các đơn vị đo khác nhau. Các struct này sẽ bao bên ngoài của kiểu dữ liệu đã tồn tại (u32
), cách làm này được gọi là newtype pattern (xem thêm trong phần “Using the Newtype Pattern to Implement External Traits on External Types”). Ở đây ta sẽ cộng giá trị ở đơn vị millimeters với giá trị ở đơn vị meters với việc bắt buộc phải chuyển đổi đơn vị đo.
Filename: src/lib.rs
use std::ops::Add;
struct Millimeters(u32);
struct Meters(u32);
impl Add<Meters> for Millimeters {
type Output = Millimeters;
fn add(self, other: Meters) -> Millimeters {
Millimeters(self.0 + (other.0 * 1000))
}
}
Listing 19-15: Implementing Add
trait cho Millimeters
để cộng Millimeters
với Meters
Để làm được điều này, ta sẽ chỉ định impl Add<Meters>
để set giá trị cho tham số Rhs
thay vì dùng tham số mặc định Self
.
Gọi các method có cùng tên
Rust không ngăn cản việc bạn tạo method có cùng tên với method của trait khác, cũng như cấm việc implement 2 trait có cùng một kiểu. Ta hoàn toàn có thể implement một method có cùng tên với các method của các traits khác.
Khi gọi các methods có cùng tên , bạn sẽ cần chỉ ra đâu là method mà bạn cần. Xem xét Listing 19-16 sau đây, có 2 trait là Pilot
và Wizard
đều định nghĩa method fly
. Sau đó implement cả 2 cho kiểu Human
cũng đã có sẵn method là fly
.
Filename: src/main.rs
trait Pilot { fn fly(&self); } trait Wizard { fn fly(&self); } struct Human; impl Pilot for Human { fn fly(&self) { println!("This is your captain speaking."); } } impl Wizard for Human { fn fly(&self) { println!("Up!"); } } impl Human { fn fly(&self) { println!("*waving arms furiously*"); } } fn main() {}
Listing 19-16: Định nghĩa method fly
Khi gọi fly
ở Human
instance, compiler sẽ mặc định gọi method nào được implement trực tiếp, được thể hiện trong Listing 19-17.
Filename: src/main.rs
trait Pilot { fn fly(&self); } trait Wizard { fn fly(&self); } struct Human; impl Pilot for Human { fn fly(&self) { println!("This is your captain speaking."); } } impl Wizard for Human { fn fly(&self) { println!("Up!"); } } impl Human { fn fly(&self) { println!("*waving arms furiously*"); } } fn main() { let person = Human; person.fly(); }
Listing 19-17: Gọi fly
ở instance Human
Kết quả là dòng chữ *waving arms furiously*
được in ra, thể hiện rằng Rust đã gọi fly
trực tiếp từ Human
.
Nếu muốn gọi methods fly
từ Pilot
hoặc Wizard
, ta cần phải khai báo rõ ràng hơn bằng một cú pháp khác trong Listing 19-18.
Filename: src/main.rs
trait Pilot { fn fly(&self); } trait Wizard { fn fly(&self); } struct Human; impl Pilot for Human { fn fly(&self) { println!("This is your captain speaking."); } } impl Wizard for Human { fn fly(&self) { println!("Up!"); } } impl Human { fn fly(&self) { println!("*waving arms furiously*"); } } fn main() { let person = Human; Pilot::fly(&person); Wizard::fly(&person); person.fly(); }
Listing 19-18: Chỉ định method fly
nào sẽ được gọi
Sau khi chạy, ta sẽ được kết quả:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.46s
Running `target/debug/traits-example`
This is your captain speaking.
Up!
*waving arms furiously*
Ở đây, method fly
có tham số self
, vì vậy ta có thể truyền person
vào và Rust có thể tìm ra trait nào cần sử dụng trong trường hợp này.
Vậy trong trường hợp sử dụng associated functions (không có tham số self
) thì sao? Rust sẽ không thể biết được bạn cần gọi method của trait nào nếu không sử dụng fully qualified syntax. Xét ví dụ dưới đây:
Filename: src/main.rs
trait Animal { fn baby_name() -> String; } struct Dog; impl Dog { fn baby_name() -> String { String::from("Spot") } } impl Animal for Dog { fn baby_name() -> String { String::from("puppy") } } fn main() { println!("A baby dog is called a {}", Dog::baby_name()); }
Listing 19-19: Gọi một associated function có cùng tên với các associated function của traits khác
Trong hàm main
, hàm Dog::baby_name
được gọi, khi đó ta sẽ có kết quả:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.54s
Running `target/debug/traits-example`
A baby dog is called a Spot
Kết quả này không phải cái ta mong muốn. Hàm baby_name
phải in ra dòng chữ A baby dog is called a puppy
. Do vậy, kĩ thuật được sử dụng trong Listing 19-18 không áp dụng được trong trường hợp này; nếu thay đổi code như là Listing 19-20 thì sao:
Filename: src/main.rs
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", Animal::baby_name());
}
Listing 19-20: Gọi hàm baby_name
từ trait Animal
Vì Animal::baby_name
không có tham số self
, và có thể có các struct khác cũng sẽ implement Animal
trait, do đó Rust không thể biết được hàm Animal::baby_name
sẽ sử dụng implementation nào. Lỗi sẽ như sau:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0283]: type annotations needed
--> src/main.rs:20:43
|
20 | println!("A baby dog is called a {}", Animal::baby_name());
| ^^^^^^^^^^^^^^^^^ cannot infer type
|
= note: cannot satisfy `_: Animal`
For more information about this error, try `rustc --explain E0283`.
error: could not compile `traits-example` due to previous error
Vậy để pass qua được lỗi này, cùng xem Listing 19-21:
Filename: src/main.rs
trait Animal { fn baby_name() -> String; } struct Dog; impl Dog { fn baby_name() -> String { String::from("Spot") } } impl Animal for Dog { fn baby_name() -> String { String::from("puppy") } } fn main() { println!("A baby dog is called a {}", <Dog as Animal>::baby_name()); }
Listing 19-21: Sử dụng fully qualified syntax để chỉ định hàm baby_name
được implement từ Dog
sẽ được gọi
Ta sẽ cung cấp cho Rust một kiểu chú thích trong cặp ngoặc <>
, trong đó sẽ chỉ rõ rằng phương thức baby_name
của Animal
trait được implement từ Dog
. Khi đó kết quả sẽ như ta mong muốn:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/traits-example`
A baby dog is called a puppy
Một cách tổng quát, fully qualified syntax được định nghĩa như sau:
<Type as Trait>::function(receiver_if_method, next_arg, ...);
Sẽ không có receiver
trong trường hợp đó là một associated functions chứ không phải methods. Bạn có thể sẽ phải sử dụng fully qualified syntax, tuy nhiên hoàn toàn có thể bỏ qua một phải phần nếu Rust có đủ thông tin để tự mình tìm ra được bạn sẽ muốn gọi hàm nào, giống như các ví dụ đã bàn ở trên.
Sử dụng Supertraits để gọi hàm của một trait từ trait khác.
Trong một vài trường hợp, ta cần sử dụng hàm của một trait từ trait khác. Khi đó, bạn cần phải dựa vào supertrait!
Ví dụ, ta có một trait là OutlinePrint
với method outline_print
sẽ in ra màn hình một giá trị với khung bao quanh. Nếu có một struct Point
implement Display
trait, khi gọi method outline_print
với đầu vào x bằng 1 và y bằng 3, ta sẽ có kết quả:
**********
* *
* (1, 3) *
* *
**********
Trong phần cài đặt hàm outline_print
, ta sẽ cần đến hàm ở bên trong Display
trait. Cú pháp ở đây là OutlinePrint::Display
. Xem thêm ở listing 19-22:
Filename: src/main.rs
use std::fmt; trait OutlinePrint: fmt::Display { fn outline_print(&self) { let output = self.to_string(); let len = output.len(); println!("{}", "*".repeat(len + 4)); println!("*{}*", " ".repeat(len + 2)); println!("* {} *", output); println!("*{}*", " ".repeat(len + 2)); println!("{}", "*".repeat(len + 4)); } } fn main() {}
Listing 19-22: Implementing OutlinePrint
trait sử dụng hàm của Display
Do OutlinePrint
yêu cầu sử dụng Display
, ta có thể sử dụng hàm to_string
của Display
trait. Nếu không sử dụng cú pháp :Display
như trên, ta sẽ gặp lỗi no method named to_string
was found for the types &Self
in current scope.
Tuy nhiên, hãy xem điều gì xảy ra nếu ta implement OutlinePrint
cho một struct không implement Display
, ví dụ như Point
:
Filename: src/main.rs
use std::fmt;
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {} *", output);
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
struct Point {
x: i32,
y: i32,
}
impl OutlinePrint for Point {}
fn main() {
let p = Point { x: 1, y: 3 };
p.outline_print();
}
Lỗi ở đây do Display
là bắt buộc phải được implement, nhưng Point chưa làm điều đó:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0277]: `Point` doesn't implement `std::fmt::Display`
--> src/main.rs:20:6
|
20 | impl OutlinePrint for Point {}
| ^^^^^^^^^^^^ `Point` cannot be formatted with the default formatter
|
= help: the trait `std::fmt::Display` is not implemented for `Point`
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
note: required by a bound in `OutlinePrint`
--> src/main.rs:3:21
|
3 | trait OutlinePrint: fmt::Display {
| ^^^^^^^^^^^^ required by this bound in `OutlinePrint`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `traits-example` due to previous error
Vì vậy, hãy implement Display
cho struct Point
:
Filename: src/main.rs
trait OutlinePrint: fmt::Display { fn outline_print(&self) { let output = self.to_string(); let len = output.len(); println!("{}", "*".repeat(len + 4)); println!("*{}*", " ".repeat(len + 2)); println!("* {} *", output); println!("*{}*", " ".repeat(len + 2)); println!("{}", "*".repeat(len + 4)); } } struct Point { x: i32, y: i32, } impl OutlinePrint for Point {} use std::fmt; impl fmt::Display for Point { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "({}, {})", self.x, self.y) } } fn main() { let p = Point { x: 1, y: 3 }; p.outline_print(); }
Sử dụng Newtype Pattern để bỏ qua Orphan rule
Trong chương 10 phần “Implementing a Trait on a Type”, ta đã đề cập đến orphan rule, đó là một quy tắc cho phép implement trait cho một type miễn là trait hoặc type đó thuộc crate mà ta đang implement. Tuy nhiên ta hoàn toàn có thể lách luật bằng cách sử dụng newtype pattern, liên quan đến việc tạo một kiểu mới bằng tuple struct. (Đã đề cập đến trong phần “Using Tuple Structs without Named Fields to Create Different Types” của chương 5). Tuple struct này sẽ có 1 trường duy nhất và bọc bên ngoài kiểu mà ta muốn implement (wrapper type). Khi đó wrapper type này sẽ thuộc local của crate và ta hoàn toàn có thể implement trait cho wrapper type này.
Ví dụ, giả sử ta muốn implement Display
cho Vec<T>
, trait và type này đều mắc phải orphan rule (vì đều không nằm trong local của crate), vì vậy ta không thể implement Display
cho Vec<T>
một cách trực tiếp. Ta cần phải tạo một wapper type có tên Wrapper
bao bên ngoài của Vev<T>
; sau đó implement Display
cho Wrapper
, như listing 19-23.
Filename: src/main.rs
use std::fmt; struct Wrapper(Vec<String>); impl fmt::Display for Wrapper { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "[{}]", self.0.join(", ")) } } fn main() { let w = Wrapper(vec![String::from("hello"), String::from("world")]); println!("w = {}", w); }
Listing 19-23: Tạo Wrapper
type bao bên ngoài Vec<String>
để implement Display
Ta sẽ sử dụng self.0
để truy cập vào biến Vec<T>
như ví dụ trên.
Với việc sử dụng Wrapper
, ta có thể implement mọi method cho Vec<T>
một cách gián tiếp. Nếu bạn muốn Wapper
có mọi method mà Vec<T>
có, hãy implement Deref
trait (được nói đến ở chương 15 “Treating Smart Pointers Like Regular References with the Deref
Trait”).
Bây giờ bạn đã hiểu về newtype pattern trong Rust rồi đó, nó thực sự hữu dụng khi đừng bên cạnh trait. Và bây giờ, hãy chuyển qua các phần khác trong chương nhé.
Advanced Types
The Rust type system has some features that we’ve mentioned in this book but
haven’t yet discussed. We’ll start by discussing newtypes in general as we
examine why newtypes are useful as types. Then we’ll move on to type aliases, a
feature similar to newtypes but with slightly different semantics. We’ll also
discuss the !
type and dynamically sized types.
Using the Newtype Pattern for Type Safety and Abstraction
Note: This section assumes you’ve read the earlier section “Using the Newtype Pattern to Implement External Traits on External Types.”
The newtype pattern is useful for tasks beyond those we’ve discussed so far,
including statically enforcing that values are never confused and indicating
the units of a value. You saw an example of using newtypes to indicate units in
Listing 19-15: recall that the Millimeters
and Meters
structs wrapped u32
values in a newtype. If we wrote a function with a parameter of type
Millimeters
, we couldn’t compile a program that accidentally tried to call
that function with a value of type Meters
or a plain u32
.
Another use of the newtype pattern is in abstracting away some implementation details of a type: the new type can expose a public API that is different from the API of the private inner type.
Newtypes can also hide internal implementation. For example, we could provide a
People
type to wrap a HashMap<i32, String>
that stores a person’s ID
associated with their name. Code using People
would only interact with the
public API we provide, such as a method to add a name string to the People
collection; that code wouldn’t need to know that we assign an i32
ID to names
internally. The newtype pattern is a lightweight way to achieve encapsulation
to hide implementation details, which we discussed in the “Encapsulation that
Hides Implementation
Details”
section of Chapter 17.
Creating Type Synonyms with Type Aliases
Along with the newtype pattern, Rust provides the ability to declare a type
alias to give an existing type another name. For this we use the type
keyword. For example, we can create the alias Kilometers
to i32
like so:
fn main() { type Kilometers = i32; let x: i32 = 5; let y: Kilometers = 5; println!("x + y = {}", x + y); }
Now, the alias Kilometers
is a synonym for i32
; unlike the Millimeters
and Meters
types we created in Listing 19-15, Kilometers
is not a separate,
new type. Values that have the type Kilometers
will be treated the same as
values of type i32
:
fn main() { type Kilometers = i32; let x: i32 = 5; let y: Kilometers = 5; println!("x + y = {}", x + y); }
Because Kilometers
and i32
are the same type, we can add values of both
types and we can pass Kilometers
values to functions that take i32
parameters. However, using this method, we don’t get the type checking benefits
that we get from the newtype pattern discussed earlier.
The main use case for type synonyms is to reduce repetition. For example, we might have a lengthy type like this:
Box<dyn Fn() + Send + 'static>
Writing this lengthy type in function signatures and as type annotations all over the code can be tiresome and error prone. Imagine having a project full of code like that in Listing 19-24.
fn main() { let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi")); fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) { // --snip-- } fn returns_long_type() -> Box<dyn Fn() + Send + 'static> { // --snip-- Box::new(|| ()) } }
Listing 19-24: Using a long type in many places
A type alias makes this code more manageable by reducing the repetition. In
Listing 19-25, we’ve introduced an alias named Thunk
for the verbose type and
can replace all uses of the type with the shorter alias Thunk
.
fn main() { type Thunk = Box<dyn Fn() + Send + 'static>; let f: Thunk = Box::new(|| println!("hi")); fn takes_long_type(f: Thunk) { // --snip-- } fn returns_long_type() -> Thunk { // --snip-- Box::new(|| ()) } }
Listing 19-25: Introducing a type alias Thunk
to reduce
repetition
This code is much easier to read and write! Choosing a meaningful name for a type alias can help communicate your intent as well (thunk is a word for code to be evaluated at a later time, so it’s an appropriate name for a closure that gets stored).
Type aliases are also commonly used with the Result<T, E>
type for reducing
repetition. Consider the std::io
module in the standard library. I/O
operations often return a Result<T, E>
to handle situations when operations
fail to work. This library has a std::io::Error
struct that represents all
possible I/O errors. Many of the functions in std::io
will be returning
Result<T, E>
where the E
is std::io::Error
, such as these functions in
the Write
trait:
use std::fmt;
use std::io::Error;
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
fn flush(&mut self) -> Result<(), Error>;
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;
}
The Result<..., Error>
is repeated a lot. As such, std::io
has this type
alias declaration:
use std::fmt;
type Result<T> = std::result::Result<T, std::io::Error>;
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize>;
fn flush(&mut self) -> Result<()>;
fn write_all(&mut self, buf: &[u8]) -> Result<()>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}
Because this declaration is in the std::io
module, we can use the fully
qualified alias std::io::Result<T>
—that is, a Result<T, E>
with the E
filled in as std::io::Error
. The Write
trait function signatures end up
looking like this:
use std::fmt;
type Result<T> = std::result::Result<T, std::io::Error>;
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize>;
fn flush(&mut self) -> Result<()>;
fn write_all(&mut self, buf: &[u8]) -> Result<()>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}
The type alias helps in two ways: it makes code easier to write and it gives
us a consistent interface across all of std::io
. Because it’s an alias, it’s
just another Result<T, E>
, which means we can use any methods that work on
Result<T, E>
with it, as well as special syntax like the ?
operator.
The Never Type that Never Returns
Rust has a special type named !
that’s known in type theory lingo as the
empty type because it has no values. We prefer to call it the never type
because it stands in the place of the return type when a function will never
return. Here is an example:
fn bar() -> ! {
// --snip--
panic!();
}
This code is read as “the function bar
returns never.” Functions that return
never are called diverging functions. We can’t create values of the type !
so bar
can never possibly return.
But what use is a type you can never create values for? Recall the code from Listing 2-5; we’ve reproduced part of it here in Listing 19-26.
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
let mut guess = String::new();
// --snip--
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
Listing 19-26: A match
with an arm that ends in
continue
At the time, we skipped over some details in this code. In Chapter 6 in “The
match
Control Flow Operator” section, we discussed that match
arms must all return the same type. So,
for example, the following code doesn’t work:
fn main() {
let guess = "3";
let guess = match guess.trim().parse() {
Ok(_) => 5,
Err(_) => "hello",
};
}
The type of guess
in this code would have to be an integer and a string,
and Rust requires that guess
have only one type. So what does continue
return? How were we allowed to return a u32
from one arm and have another arm
that ends with continue
in Listing 19-26?
As you might have guessed, continue
has a !
value. That is, when Rust
computes the type of guess
, it looks at both match arms, the former with a
value of u32
and the latter with a !
value. Because !
can never have a
value, Rust decides that the type of guess
is u32
.
The formal way of describing this behavior is that expressions of type !
can
be coerced into any other type. We’re allowed to end this match
arm with
continue
because continue
doesn’t return a value; instead, it moves control
back to the top of the loop, so in the Err
case, we never assign a value to
guess
.
The never type is useful with the panic!
macro as well. Remember the unwrap
function that we call on Option<T>
values to produce a value or panic? Here
is its definition:
enum Option<T> {
Some(T),
None,
}
use crate::Option::*;
impl<T> Option<T> {
pub fn unwrap(self) -> T {
match self {
Some(val) => val,
None => panic!("called `Option::unwrap()` on a `None` value"),
}
}
}
In this code, the same thing happens as in the match
in Listing 19-26: Rust
sees that val
has the type T
and panic!
has the type !
, so the result
of the overall match
expression is T
. This code works because panic!
doesn’t produce a value; it ends the program. In the None
case, we won’t be
returning a value from unwrap
, so this code is valid.
One final expression that has the type !
is a loop
:
fn main() {
print!("forever ");
loop {
print!("and ever ");
}
}
Here, the loop never ends, so !
is the value of the expression. However, this
wouldn’t be true if we included a break
, because the loop would terminate
when it got to the break
.
Dynamically Sized Types and the Sized
Trait
Due to Rust’s need to know certain details, such as how much space to allocate for a value of a particular type, there is a corner of its type system that can be confusing: the concept of dynamically sized types. Sometimes referred to as DSTs or unsized types, these types let us write code using values whose size we can know only at runtime.
Let’s dig into the details of a dynamically sized type called str
, which
we’ve been using throughout the book. That’s right, not &str
, but str
on
its own, is a DST. We can’t know how long the string is until runtime, meaning
we can’t create a variable of type str
, nor can we take an argument of type
str
. Consider the following code, which does not work:
fn main() {
let s1: str = "Hello there!";
let s2: str = "How's it going?";
}
Rust needs to know how much memory to allocate for any value of a particular
type, and all values of a type must use the same amount of memory. If Rust
allowed us to write this code, these two str
values would need to take up the
same amount of space. But they have different lengths: s1
needs 12 bytes of
storage and s2
needs 15. This is why it’s not possible to create a variable
holding a dynamically sized type.
So what do we do? In this case, you already know the answer: we make the types
of s1
and s2
a &str
rather than a str
. Recall that in the “String
Slices” section of Chapter 4, we said the slice
data structure stores the starting position and the length of the slice.
So although a &T
is a single value that stores the memory address of where
the T
is located, a &str
is two values: the address of the str
and its
length. As such, we can know the size of a &str
value at compile time: it’s
twice the length of a usize
. That is, we always know the size of a &str
, no
matter how long the string it refers to is. In general, this is the way in
which dynamically sized types are used in Rust: they have an extra bit of
metadata that stores the size of the dynamic information. The golden rule of
dynamically sized types is that we must always put values of dynamically sized
types behind a pointer of some kind.
We can combine str
with all kinds of pointers: for example, Box<str>
or
Rc<str>
. In fact, you’ve seen this before but with a different dynamically
sized type: traits. Every trait is a dynamically sized type we can refer to by
using the name of the trait. In Chapter 17 in the “Using Trait Objects That
Allow for Values of Different
Types” section, we mentioned that to use traits as trait objects, we must
put them behind a pointer, such as &dyn Trait
or Box<dyn Trait>
(Rc<dyn Trait>
would work too).
To work with DSTs, Rust has a particular trait called the Sized
trait to
determine whether or not a type’s size is known at compile time. This trait is
automatically implemented for everything whose size is known at compile time.
In addition, Rust implicitly adds a bound on Sized
to every generic function.
That is, a generic function definition like this:
fn generic<T>(t: T) {
// --snip--
}
is actually treated as though we had written this:
fn generic<T: Sized>(t: T) {
// --snip--
}
By default, generic functions will work only on types that have a known size at compile time. However, you can use the following special syntax to relax this restriction:
fn generic<T: ?Sized>(t: &T) {
// --snip--
}
A trait bound on ?Sized
means “T
may or may not be Sized
” and this
notation overrides the default that generic types must have a known size at
compile time. The ?Trait
syntax with this meaning is only available for
Sized
, not any other traits.
Also note that we switched the type of the t
parameter from T
to &T
.
Because the type might not be Sized
, we need to use it behind some kind of
pointer. In this case, we’ve chosen a reference.
Next, we’ll talk about functions and closures!
Advanced Functions and Closures
This section explores some advanced features related to functions and closures, including function pointers and returning closures.
Function Pointers
We’ve talked about how to pass closures to functions; you can also pass regular
functions to functions! This technique is useful when you want to pass a
function you’ve already defined rather than defining a new closure. Doing this
with function pointers will allow you to use functions as arguments to other
functions. Functions coerce to the type fn
(with a lowercase f), not to be
confused with the Fn
closure trait. The fn
type is called a function
pointer. The syntax for specifying that a parameter is a function pointer is
similar to that of closures, as shown in Listing 19-27.
Filename: src/main.rs
fn add_one(x: i32) -> i32 { x + 1 } fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 { f(arg) + f(arg) } fn main() { let answer = do_twice(add_one, 5); println!("The answer is: {}", answer); }
Listing 19-27: Using the fn
type to accept a function
pointer as an argument
This code prints The answer is: 12
. We specify that the parameter f
in
do_twice
is an fn
that takes one parameter of type i32
and returns an
i32
. We can then call f
in the body of do_twice
. In main
, we can pass
the function name add_one
as the first argument to do_twice
.
Unlike closures, fn
is a type rather than a trait, so we specify fn
as the
parameter type directly rather than declaring a generic type parameter with one
of the Fn
traits as a trait bound.
Function pointers implement all three of the closure traits (Fn
, FnMut
, and
FnOnce
), so you can always pass a function pointer as an argument for a
function that expects a closure. It’s best to write functions using a generic
type and one of the closure traits so your functions can accept either
functions or closures.
An example of where you would want to only accept fn
and not closures is when
interfacing with external code that doesn’t have closures: C functions can
accept functions as arguments, but C doesn’t have closures.
As an example of where you could use either a closure defined inline or a named
function, let’s look at a use of map
. To use the map
function to turn a
vector of numbers into a vector of strings, we could use a closure, like this:
fn main() { let list_of_numbers = vec![1, 2, 3]; let list_of_strings: Vec<String> = list_of_numbers.iter().map(|i| i.to_string()).collect(); }
Or we could name a function as the argument to map
instead of the closure,
like this:
fn main() { let list_of_numbers = vec![1, 2, 3]; let list_of_strings: Vec<String> = list_of_numbers.iter().map(ToString::to_string).collect(); }
Note that we must use the fully qualified syntax that we talked about earlier
in the “Advanced Traits” section because
there are multiple functions available named to_string
. Here, we’re using the
to_string
function defined in the ToString
trait, which the standard
library has implemented for any type that implements Display
.
Recall from the “Enum values” section of Chapter 6 that the name of each enum variant that we define also becomes an initializer function. We can use these initializer functions as function pointers that implement the closure traits, which means we can specify the initializer functions as arguments for methods that take closures, like so:
fn main() { enum Status { Value(u32), Stop, } let list_of_statuses: Vec<Status> = (0u32..20).map(Status::Value).collect(); }
Here we create Status::Value
instances using each u32
value in the range
that map
is called on by using the initializer function of Status::Value
.
Some people prefer this style, and some people prefer to use closures. They
compile to the same code, so use whichever style is clearer to you.
Returning Closures
Closures are represented by traits, which means you can’t return closures
directly. In most cases where you might want to return a trait, you can instead
use the concrete type that implements the trait as the return value of the
function. But you can’t do that with closures because they don’t have a
concrete type that is returnable; you’re not allowed to use the function
pointer fn
as a return type, for example.
The following code tries to return a closure directly, but it won’t compile:
fn returns_closure() -> dyn Fn(i32) -> i32 {
|x| x + 1
}
The compiler error is as follows:
$ cargo build
Compiling functions-example v0.1.0 (file:///projects/functions-example)
error[E0746]: return type cannot have an unboxed trait object
--> src/lib.rs:1:25
|
1 | fn returns_closure() -> dyn Fn(i32) -> i32 {
| ^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
|
= note: for information on `impl Trait`, see <https://doc.rust-lang.org/book/ch10-02-traits.html#returning-types-that-implement-traits>
help: use `impl Fn(i32) -> i32` as the return type, as all return paths are of type `[closure@src/lib.rs:2:5: 2:14]`, which implements `Fn(i32) -> i32`
|
1 | fn returns_closure() -> impl Fn(i32) -> i32 {
| ~~~~~~~~~~~~~~~~~~~
For more information about this error, try `rustc --explain E0746`.
error: could not compile `functions-example` due to previous error
The error references the Sized
trait again! Rust doesn’t know how much space
it will need to store the closure. We saw a solution to this problem earlier.
We can use a trait object:
fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
Box::new(|x| x + 1)
}
This code will compile just fine. For more about trait objects, refer to the section “Using Trait Objects That Allow for Values of Different Types” in Chapter 17.
Next, let’s look at macros!
Macros
We’ve used macros like println!
throughout this book, but we haven’t fully
explored what a macro is and how it works. The term macro refers to a family
of features in Rust: declarative macros with macro_rules!
and three kinds
of procedural macros:
- Custom
#[derive]
macros that specify code added with thederive
attribute used on structs and enums - Attribute-like macros that define custom attributes usable on any item
- Function-like macros that look like function calls but operate on the tokens specified as their argument
We’ll talk about each of these in turn, but first, let’s look at why we even need macros when we already have functions.
The Difference Between Macros and Functions
Fundamentally, macros are a way of writing code that writes other code, which
is known as metaprogramming. In Appendix C, we discuss the derive
attribute, which generates an implementation of various traits for you. We’ve
also used the println!
and vec!
macros throughout the book. All of these
macros expand to produce more code than the code you’ve written manually.
Metaprogramming is useful for reducing the amount of code you have to write and maintain, which is also one of the roles of functions. However, macros have some additional powers that functions don’t.
A function signature must declare the number and type of parameters the
function has. Macros, on the other hand, can take a variable number of
parameters: we can call println!("hello")
with one argument or
println!("hello {}", name)
with two arguments. Also, macros are expanded
before the compiler interprets the meaning of the code, so a macro can, for
example, implement a trait on a given type. A function can’t, because it gets
called at runtime and a trait needs to be implemented at compile time.
The downside to implementing a macro instead of a function is that macro definitions are more complex than function definitions because you’re writing Rust code that writes Rust code. Due to this indirection, macro definitions are generally more difficult to read, understand, and maintain than function definitions.
Another important difference between macros and functions is that you must define macros or bring them into scope before you call them in a file, as opposed to functions you can define anywhere and call anywhere.
Declarative Macros with macro_rules!
for General Metaprogramming
The most widely used form of macros in Rust is declarative macros. These are
also sometimes referred to as “macros by example,” “macro_rules!
macros,” or
just plain “macros.” At their core, declarative macros allow you to write
something similar to a Rust match
expression. As discussed in Chapter 6,
match
expressions are control structures that take an expression, compare the
resulting value of the expression to patterns, and then run the code associated
with the matching pattern. Macros also compare a value to patterns that are
associated with particular code: in this situation, the value is the literal
Rust source code passed to the macro; the patterns are compared with the
structure of that source code; and the code associated with each pattern, when
matched, replaces the code passed to the macro. This all happens during
compilation.
To define a macro, you use the macro_rules!
construct. Let’s explore how to
use macro_rules!
by looking at how the vec!
macro is defined. Chapter 8
covered how we can use the vec!
macro to create a new vector with particular
values. For example, the following macro creates a new vector containing three
integers:
#![allow(unused)] fn main() { let v: Vec<u32> = vec![1, 2, 3]; }
We could also use the vec!
macro to make a vector of two integers or a vector
of five string slices. We wouldn’t be able to use a function to do the same
because we wouldn’t know the number or type of values up front.
Listing 19-28 shows a slightly simplified definition of the vec!
macro.
Filename: src/lib.rs
#[macro_export]
macro_rules! vec {
( $( $x:expr ),* ) => {
{
let mut temp_vec = Vec::new();
$(
temp_vec.push($x);
)*
temp_vec
}
};
}
Listing 19-28: A simplified version of the vec!
macro
definition
Note: The actual definition of the
vec!
macro in the standard library includes code to preallocate the correct amount of memory up front. That code is an optimization that we don’t include here to make the example simpler.
The #[macro_export]
annotation indicates that this macro should be made
available whenever the crate in which the macro is defined is brought into
scope. Without this annotation, the macro can’t be brought into scope.
We then start the macro definition with macro_rules!
and the name of the
macro we’re defining without the exclamation mark. The name, in this case
vec
, is followed by curly brackets denoting the body of the macro definition.
The structure in the vec!
body is similar to the structure of a match
expression. Here we have one arm with the pattern ( $( $x:expr ),* )
,
followed by =>
and the block of code associated with this pattern. If the
pattern matches, the associated block of code will be emitted. Given that this
is the only pattern in this macro, there is only one valid way to match; any
other pattern will result in an error. More complex macros will have more than
one arm.
Valid pattern syntax in macro definitions is different than the pattern syntax covered in Chapter 18 because macro patterns are matched against Rust code structure rather than values. Let’s walk through what the pattern pieces in Listing 19-28 mean; for the full macro pattern syntax, see the reference.
First, a set of parentheses encompasses the whole pattern. A dollar sign ($
)
is next, followed by a set of parentheses that captures values that match the
pattern within the parentheses for use in the replacement code. Within $()
is
$x:expr
, which matches any Rust expression and gives the expression the name
$x
.
The comma following $()
indicates that a literal comma separator character
could optionally appear after the code that matches the code in $()
. The *
specifies that the pattern matches zero or more of whatever precedes the *
.
When we call this macro with vec![1, 2, 3];
, the $x
pattern matches three
times with the three expressions 1
, 2
, and 3
.
Now let’s look at the pattern in the body of the code associated with this arm:
temp_vec.push()
within $()*
is generated for each part that matches $()
in the pattern zero or more times depending on how many times the pattern
matches. The $x
is replaced with each expression matched. When we call this
macro with vec![1, 2, 3];
, the code generated that replaces this macro call
will be the following:
{
let mut temp_vec = Vec::new();
temp_vec.push(1);
temp_vec.push(2);
temp_vec.push(3);
temp_vec
}
We’ve defined a macro that can take any number of arguments of any type and can generate code to create a vector containing the specified elements.
There are some strange edge cases with macro_rules!
. In the future, Rust will
have a second kind of declarative macro that will work in a similar fashion but
fix some of these edge cases. After that update, macro_rules!
will be
effectively deprecated. With this in mind, as well as the fact that most Rust
programmers will use macros more than write macros, we won’t discuss
macro_rules!
any further. To learn more about how to write macros, consult
the online documentation or other resources, such as “The Little Book of Rust
Macros” started by Daniel Keep and continued by Lukas Wirth.
Procedural Macros for Generating Code from Attributes
The second form of macros is procedural macros, which act more like functions (and are a type of procedure). Procedural macros accept some code as an input, operate on that code, and produce some code as an output rather than matching against patterns and replacing the code with other code as declarative macros do.
The three kinds of procedural macros (custom derive, attribute-like, and function-like) all work in a similar fashion.
When creating procedural macros, the definitions must reside in their own crate
with a special crate type. This is for complex technical reasons that we hope
to eliminate in the future. Defining procedural macros looks like the code in
Listing 19-29, where some_attribute
is a placeholder for using a specific
macro variety.
Filename: src/lib.rs
use proc_macro;
#[some_attribute]
pub fn some_name(input: TokenStream) -> TokenStream {
}
Listing 19-29: An example of defining a procedural macro
The function that defines a procedural macro takes a TokenStream
as an input
and produces a TokenStream
as an output. The TokenStream
type is defined by
the proc_macro
crate that is included with Rust and represents a sequence of
tokens. This is the core of the macro: the source code that the macro is
operating on makes up the input TokenStream
, and the code the macro produces
is the output TokenStream
. The function also has an attribute attached to it
that specifies which kind of procedural macro we’re creating. We can have
multiple kinds of procedural macros in the same crate.
Let’s look at the different kinds of procedural macros. We’ll start with a custom derive macro and then explain the small dissimilarities that make the other forms different.
How to Write a Custom derive
Macro
Let’s create a crate named hello_macro
that defines a trait named
HelloMacro
with one associated function named hello_macro
. Rather than
making our crate users implement the HelloMacro
trait for each of their
types, we’ll provide a procedural macro so users can annotate their type with
#[derive(HelloMacro)]
to get a default implementation of the hello_macro
function. The default implementation will print Hello, Macro! My name is TypeName!
where TypeName
is the name of the type on which this trait has
been defined. In other words, we’ll write a crate that enables another
programmer to write code like Listing 19-30 using our crate.
Filename: src/main.rs
use hello_macro::HelloMacro;
use hello_macro_derive::HelloMacro;
#[derive(HelloMacro)]
struct Pancakes;
fn main() {
Pancakes::hello_macro();
}
Listing 19-30: The code a user of our crate will be able to write when using our procedural macro
This code will print Hello, Macro! My name is Pancakes!
when we’re done. The
first step is to make a new library crate, like this:
$ cargo new hello_macro --lib
Next, we’ll define the HelloMacro
trait and its associated function:
Filename: src/lib.rs
pub trait HelloMacro {
fn hello_macro();
}
We have a trait and its function. At this point, our crate user could implement the trait to achieve the desired functionality, like so:
use hello_macro::HelloMacro;
struct Pancakes;
impl HelloMacro for Pancakes {
fn hello_macro() {
println!("Hello, Macro! My name is Pancakes!");
}
}
fn main() {
Pancakes::hello_macro();
}
However, they would need to write the implementation block for each type they
wanted to use with hello_macro
; we want to spare them from having to do this
work.
Additionally, we can’t yet provide the hello_macro
function with default
implementation that will print the name of the type the trait is implemented
on: Rust doesn’t have reflection capabilities, so it can’t look up the type’s
name at runtime. We need a macro to generate code at compile time.
The next step is to define the procedural macro. At the time of this writing,
procedural macros need to be in their own crate. Eventually, this restriction
might be lifted. The convention for structuring crates and macro crates is as
follows: for a crate named foo
, a custom derive procedural macro crate is
called foo_derive
. Let’s start a new crate called hello_macro_derive
inside
our hello_macro
project:
$ cargo new hello_macro_derive --lib
Our two crates are tightly related, so we create the procedural macro crate
within the directory of our hello_macro
crate. If we change the trait
definition in hello_macro
, we’ll have to change the implementation of the
procedural macro in hello_macro_derive
as well. The two crates will need to
be published separately, and programmers using these crates will need to add
both as dependencies and bring them both into scope. We could instead have the
hello_macro
crate use hello_macro_derive
as a dependency and re-export the
procedural macro code. However, the way we’ve structured the project makes it
possible for programmers to use hello_macro
even if they don’t want the
derive
functionality.
We need to declare the hello_macro_derive
crate as a procedural macro crate.
We’ll also need functionality from the syn
and quote
crates, as you’ll see
in a moment, so we need to add them as dependencies. Add the following to the
Cargo.toml file for hello_macro_derive
:
Filename: hello_macro_derive/Cargo.toml
[lib]
proc-macro = true
[dependencies]
syn = "1.0"
quote = "1.0"
To start defining the procedural macro, place the code in Listing 19-31 into
your src/lib.rs file for the hello_macro_derive
crate. Note that this code
won’t compile until we add a definition for the impl_hello_macro
function.
Filename: hello_macro_derive/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn;
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
// Construct a representation of Rust code as a syntax tree
// that we can manipulate
let ast = syn::parse(input).unwrap();
// Build the trait implementation
impl_hello_macro(&ast)
}
Listing 19-31: Code that most procedural macro crates will require in order to process Rust code
Notice that we’ve split the code into the hello_macro_derive
function, which
is responsible for parsing the TokenStream
, and the impl_hello_macro
function, which is responsible for transforming the syntax tree: this makes
writing a procedural macro more convenient. The code in the outer function
(hello_macro_derive
in this case) will be the same for almost every
procedural macro crate you see or create. The code you specify in the body of
the inner function (impl_hello_macro
in this case) will be different
depending on your procedural macro’s purpose.
We’ve introduced three new crates: proc_macro
, syn
, and quote
. The
proc_macro
crate comes with Rust, so we didn’t need to add that to the
dependencies in Cargo.toml. The proc_macro
crate is the compiler’s API that
allows us to read and manipulate Rust code from our code.
The syn
crate parses Rust code from a string into a data structure that we
can perform operations on. The quote
crate turns syn
data structures back
into Rust code. These crates make it much simpler to parse any sort of Rust
code we might want to handle: writing a full parser for Rust code is no simple
task.
The hello_macro_derive
function will be called when a user of our library
specifies #[derive(HelloMacro)]
on a type. This is possible because we’ve
annotated the hello_macro_derive
function here with proc_macro_derive
and
specified the name, HelloMacro
, which matches our trait name; this is the
convention most procedural macros follow.
The hello_macro_derive
function first converts the input
from a
TokenStream
to a data structure that we can then interpret and perform
operations on. This is where syn
comes into play. The parse
function in
syn
takes a TokenStream
and returns a DeriveInput
struct representing the
parsed Rust code. Listing 19-32 shows the relevant parts of the DeriveInput
struct we get from parsing the struct Pancakes;
string:
DeriveInput {
// --snip--
ident: Ident {
ident: "Pancakes",
span: #0 bytes(95..103)
},
data: Struct(
DataStruct {
struct_token: Struct,
fields: Unit,
semi_token: Some(
Semi
)
}
)
}
Listing 19-32: The DeriveInput
instance we get when
parsing the code that has the macro’s attribute in Listing 19-30
The fields of this struct show that the Rust code we’ve parsed is a unit struct
with the ident
(identifier, meaning the name) of Pancakes
. There are more
fields on this struct for describing all sorts of Rust code; check the syn
documentation for DeriveInput
for more information.
Soon we’ll define the impl_hello_macro
function, which is where we’ll build
the new Rust code we want to include. But before we do, note that the output
for our derive macro is also a TokenStream
. The returned TokenStream
is
added to the code that our crate users write, so when they compile their crate,
they’ll get the extra functionality that we provide in the modified
TokenStream
.
You might have noticed that we’re calling unwrap
to cause the
hello_macro_derive
function to panic if the call to the syn::parse
function
fails here. It’s necessary for our procedural macro to panic on errors because
proc_macro_derive
functions must return TokenStream
rather than Result
to
conform to the procedural macro API. We’ve simplified this example by using
unwrap
; in production code, you should provide more specific error messages
about what went wrong by using panic!
or expect
.
Now that we have the code to turn the annotated Rust code from a TokenStream
into a DeriveInput
instance, let’s generate the code that implements the
HelloMacro
trait on the annotated type, as shown in Listing 19-33.
Filename: hello_macro_derive/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn;
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
// Construct a representation of Rust code as a syntax tree
// that we can manipulate
let ast = syn::parse(input).unwrap();
// Build the trait implementation
impl_hello_macro(&ast)
}
fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
let name = &ast.ident;
let gen = quote! {
impl HelloMacro for #name {
fn hello_macro() {
println!("Hello, Macro! My name is {}!", stringify!(#name));
}
}
};
gen.into()
}
Listing 19-33: Implementing the HelloMacro
trait using
the parsed Rust code
We get an Ident
struct instance containing the name (identifier) of the
annotated type using ast.ident
. The struct in Listing 19-32 shows that when
we run the impl_hello_macro
function on the code in Listing 19-30, the
ident
we get will have the ident
field with a value of "Pancakes"
. Thus,
the name
variable in Listing 19-33 will contain an Ident
struct instance
that, when printed, will be the string "Pancakes"
, the name of the struct in
Listing 19-30.
The quote!
macro lets us define the Rust code that we want to return. The
compiler expects something different to the direct result of the quote!
macro’s execution, so we need to convert it to a TokenStream
. We do this by
calling the into
method, which consumes this intermediate representation and
returns a value of the required TokenStream
type.
The quote!
macro also provides some very cool templating mechanics: we can
enter #name
, and quote!
will replace it with the value in the variable
name
. You can even do some repetition similar to the way regular macros work.
Check out the quote
crate’s docs for a thorough introduction.
We want our procedural macro to generate an implementation of our HelloMacro
trait for the type the user annotated, which we can get by using #name
. The
trait implementation has one function, hello_macro
, whose body contains the
functionality we want to provide: printing Hello, Macro! My name is
and then
the name of the annotated type.
The stringify!
macro used here is built into Rust. It takes a Rust
expression, such as 1 + 2
, and at compile time turns the expression into a
string literal, such as "1 + 2"
. This is different than format!
or
println!
, macros which evaluate the expression and then turn the result into
a String
. There is a possibility that the #name
input might be an
expression to print literally, so we use stringify!
. Using stringify!
also
saves an allocation by converting #name
to a string literal at compile time.
At this point, cargo build
should complete successfully in both hello_macro
and hello_macro_derive
. Let’s hook up these crates to the code in Listing
19-30 to see the procedural macro in action! Create a new binary project in
your projects directory using cargo new pancakes
. We need to add
hello_macro
and hello_macro_derive
as dependencies in the pancakes
crate’s Cargo.toml. If you’re publishing your versions of hello_macro
and
hello_macro_derive
to crates.io, they would be regular
dependencies; if not, you can specify them as path
dependencies as follows:
hello_macro = { path = "../hello_macro" }
hello_macro_derive = { path = "../hello_macro/hello_macro_derive" }
Put the code in Listing 19-30 into src/main.rs, and run cargo run
: it
should print Hello, Macro! My name is Pancakes!
The implementation of the
HelloMacro
trait from the procedural macro was included without the
pancakes
crate needing to implement it; the #[derive(HelloMacro)]
added the
trait implementation.
Next, let’s explore how the other kinds of procedural macros differ from custom derive macros.
Attribute-like macros
Attribute-like macros are similar to custom derive macros, but instead of
generating code for the derive
attribute, they allow you to create new
attributes. They’re also more flexible: derive
only works for structs and
enums; attributes can be applied to other items as well, such as functions.
Here’s an example of using an attribute-like macro: say you have an attribute
named route
that annotates functions when using a web application framework:
#[route(GET, "/")]
fn index() {
This #[route]
attribute would be defined by the framework as a procedural
macro. The signature of the macro definition function would look like this:
#[proc_macro_attribute]
pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
Here, we have two parameters of type TokenStream
. The first is for the
contents of the attribute: the GET, "/"
part. The second is the body of the
item the attribute is attached to: in this case, fn index() {}
and the rest
of the function’s body.
Other than that, attribute-like macros work the same way as custom derive
macros: you create a crate with the proc-macro
crate type and implement a
function that generates the code you want!
Function-like macros
Function-like macros define macros that look like function calls. Similarly to
macro_rules!
macros, they’re more flexible than functions; for example, they
can take an unknown number of arguments. However, macro_rules!
macros can be
defined only using the match-like syntax we discussed in the section
“Declarative Macros with macro_rules!
for General
Metaprogramming” earlier. Function-like macros take a
TokenStream
parameter and their definition manipulates that TokenStream
using Rust code as the other two types of procedural macros do. An example of a
function-like macro is an sql!
macro that might be called like so:
let sql = sql!(SELECT * FROM posts WHERE id=1);
This macro would parse the SQL statement inside it and check that it’s
syntactically correct, which is much more complex processing than a
macro_rules!
macro can do. The sql!
macro would be defined like this:
#[proc_macro]
pub fn sql(input: TokenStream) -> TokenStream {
This definition is similar to the custom derive macro’s signature: we receive the tokens that are inside the parentheses and return the code we wanted to generate.
Summary
Whew! Now you have some Rust features in your toolbox that you won’t use often, but you’ll know they’re available in very particular circumstances. We’ve introduced several complex topics so that when you encounter them in error message suggestions or in other peoples’ code, you’ll be able to recognize these concepts and syntax. Use this chapter as a reference to guide you to solutions.
Next, we’ll put everything we’ve discussed throughout the book into practice and do one more project!
Final Project: Building a Multithreaded Web Server
It’s been a long journey, but we’ve reached the end of the book. In this chapter, we’ll build one more project together to demonstrate some of the concepts we covered in the final chapters, as well as recap some earlier lessons.
For our final project, we’ll make a web server that says “hello” and looks like Figure 20-1 in a web browser.
Figure 20-1: Our final shared project
Here is the plan to build the web server:
- Learn a bit about TCP and HTTP.
- Listen for TCP connections on a socket.
- Parse a small number of HTTP requests.
- Create a proper HTTP response.
- Improve the throughput of our server with a thread pool.
But before we get started, we should mention one detail: the method we’ll use won’t be the best way to build a web server with Rust. A number of production-ready crates are available on crates.io that provide more complete web server and thread pool implementations than we’ll build.
However, our intention in this chapter is to help you learn, not to take the easy route. Because Rust is a systems programming language, we can choose the level of abstraction we want to work with and can go to a lower level than is possible or practical in other languages. We’ll write the basic HTTP server and thread pool manually so you can learn the general ideas and techniques behind the crates you might use in the future.
Building a Single-Threaded Web Server
We’ll start by getting a single-threaded web server working. Before we begin, let’s look at a quick overview of the protocols involved in building web servers. The details of these protocols are beyond the scope of this book, but a brief overview will give you the information you need.
The two main protocols involved in web servers are the Hypertext Transfer Protocol (HTTP) and the Transmission Control Protocol (TCP). Both protocols are request-response protocols, meaning a client initiates requests and a server listens to the requests and provides a response to the client. The contents of those requests and responses are defined by the protocols.
TCP is the lower-level protocol that describes the details of how information gets from one server to another but doesn’t specify what that information is. HTTP builds on top of TCP by defining the contents of the requests and responses. It’s technically possible to use HTTP with other protocols, but in the vast majority of cases, HTTP sends its data over TCP. We’ll work with the raw bytes of TCP and HTTP requests and responses.
Listening to the TCP Connection
Our web server needs to listen to a TCP connection, so that’s the first part
we’ll work on. The standard library offers a std::net
module that lets us do
this. Let’s make a new project in the usual fashion:
$ cargo new hello
Created binary (application) `hello` project
$ cd hello
Now enter the code in Listing 20-1 in src/main.rs to start. This code will
listen at the address 127.0.0.1:7878
for incoming TCP streams. When it gets
an incoming stream, it will print Connection established!
.
Filename: src/main.rs
use std::net::TcpListener; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); println!("Connection established!"); } }
Listing 20-1: Listening for incoming streams and printing a message when we receive a stream
Using TcpListener
, we can listen for TCP connections at the address
127.0.0.1:7878
. In the address, the section before the colon is an IP address
representing your computer (this is the same on every computer and doesn’t
represent the authors’ computer specifically), and 7878
is the port. We’ve
chosen this port for two reasons: HTTP isn’t normally accepted on this port, and
7878 is rust typed on a telephone.
The bind
function in this scenario works like the new
function in that it
will return a new TcpListener
instance. The reason the function is called
bind
is that in networking, connecting to a port to listen to is known as
“binding to a port.”
The bind
function returns a Result<T, E>
, which indicates that binding
might fail. For example, connecting to port 80 requires administrator
privileges (nonadministrators can listen only on ports higher than 1023), so if
we tried to connect to port 80 without being an administrator, binding wouldn’t
work. As another example, binding wouldn’t work if we ran two instances of our
program and so had two programs listening to the same port. Because we’re
writing a basic server just for learning purposes, we won’t worry about
handling these kinds of errors; instead, we use unwrap
to stop the program if
errors happen.
The incoming
method on TcpListener
returns an iterator that gives us a
sequence of streams (more specifically, streams of type TcpStream
). A single
stream represents an open connection between the client and the server. A
connection is the name for the full request and response process in which a
client connects to the server, the server generates a response, and the server
closes the connection. As such, TcpStream
will read from itself to see what
the client sent and then allow us to write our response to the stream. Overall,
this for
loop will process each connection in turn and produce a series of
streams for us to handle.
For now, our handling of the stream consists of calling unwrap
to terminate
our program if the stream has any errors; if there aren’t any errors, the
program prints a message. We’ll add more functionality for the success case in
the next listing. The reason we might receive errors from the incoming
method
when a client connects to the server is that we’re not actually iterating over
connections. Instead, we’re iterating over connection attempts. The
connection might not be successful for a number of reasons, many of them
operating system specific. For example, many operating systems have a limit to
the number of simultaneous open connections they can support; new connection
attempts beyond that number will produce an error until some of the open
connections are closed.
Let’s try running this code! Invoke cargo run
in the terminal and then load
127.0.0.1:7878 in a web browser. The browser should show an error message
like “Connection reset,” because the server isn’t currently sending back any
data. But when you look at your terminal, you should see several messages that
were printed when the browser connected to the server!
Running `target/debug/hello`
Connection established!
Connection established!
Connection established!
Sometimes, you’ll see multiple messages printed for one browser request; the reason might be that the browser is making a request for the page as well as a request for other resources, like the favicon.ico icon that appears in the browser tab.
It could also be that the browser is trying to connect to the server multiple
times because the server isn’t responding with any data. When stream
goes out
of scope and is dropped at the end of the loop, the connection is closed as
part of the drop
implementation. Browsers sometimes deal with closed
connections by retrying, because the problem might be temporary. The important
factor is that we’ve successfully gotten a handle to a TCP connection!
Remember to stop the program by pressing ctrl-c
when you’re done running a particular version of the code. Then restart cargo run
after you’ve made each set of code changes to make sure you’re running the
newest code.
Reading the Request
Let’s implement the functionality to read the request from the browser! To
separate the concerns of first getting a connection and then taking some action
with the connection, we’ll start a new function for processing connections. In
this new handle_connection
function, we’ll read data from the TCP stream and
print it so we can see the data being sent from the browser. Change the code to
look like Listing 20-2.
Filename: src/main.rs
use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } fn handle_connection(mut stream: TcpStream) { let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); println!("Request: {}", String::from_utf8_lossy(&buffer[..])); }
Listing 20-2: Reading from the TcpStream
and printing
the data
We bring std::io::prelude
into scope to get access to certain traits that let
us read from and write to the stream. In the for
loop in the main
function,
instead of printing a message that says we made a connection, we now call the
new handle_connection
function and pass the stream
to it.
In the handle_connection
function, we’ve made the stream
parameter mutable.
The reason is that the TcpStream
instance keeps track of what data it returns
to us internally. It might read more data than we asked for and save that data
for the next time we ask for data. It therefore needs to be mut
because its
internal state might change; usually, we think of “reading” as not needing
mutation, but in this case we need the mut
keyword.
Next, we need to actually read from the stream. We do this in two steps:
first, we declare a buffer
on the stack to hold the data that is read in.
We’ve made the buffer 1024 bytes in size, which is big enough to hold the
data of a basic request and sufficient for our purposes in this chapter. If
we wanted to handle requests of an arbitrary size, buffer management would
need to be more complicated; we’ll keep it simple for now. We pass the buffer
to stream.read
, which will read bytes from the TcpStream
and put them in
the buffer.
Second, we convert the bytes in the buffer to a string and print that string.
The String::from_utf8_lossy
function takes a &[u8]
and produces a String
from it. The “lossy” part of the name indicates the behavior of this function
when it sees an invalid UTF-8 sequence: it will replace the invalid sequence
with �
, the U+FFFD REPLACEMENT CHARACTER
. You might see replacement
characters for characters in the buffer that aren’t filled by request data.
Let’s try this code! Start the program and make a request in a web browser again. Note that we’ll still get an error page in the browser, but our program’s output in the terminal will now look similar to this:
$ cargo run
Compiling hello v0.1.0 (file:///projects/hello)
Finished dev [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/hello`
Request: GET / HTTP/1.1
Host: 127.0.0.1:7878
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101
Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
������������������������������������
Depending on your browser, you might get slightly different output. Now that
we’re printing the request data, we can see why we get multiple connections
from one browser request by looking at the path after Request: GET
. If the
repeated connections are all requesting /, we know the browser is trying to
fetch / repeatedly because it’s not getting a response from our program.
Let’s break down this request data to understand what the browser is asking of our program.
A Closer Look at an HTTP Request
HTTP is a text-based protocol, and a request takes this format:
Method Request-URI HTTP-Version CRLF
headers CRLF
message-body
The first line is the request line that holds information about what the
client is requesting. The first part of the request line indicates the method
being used, such as GET
or POST
, which describes how the client is making
this request. Our client used a GET
request.
The next part of the request line is /, which indicates the Uniform Resource Identifier (URI) the client is requesting: a URI is almost, but not quite, the same as a Uniform Resource Locator (URL). The difference between URIs and URLs isn’t important for our purposes in this chapter, but the HTTP spec uses the term URI, so we can just mentally substitute URL for URI here.
The last part is the HTTP version the client uses, and then the request line
ends in a CRLF sequence. (CRLF stands for carriage return and line feed,
which are terms from the typewriter days!) The CRLF sequence can also be
written as \r\n
, where \r
is a carriage return and \n
is a line feed. The
CRLF sequence separates the request line from the rest of the request data.
Note that when the CRLF is printed, we see a new line start rather than \r\n
.
Looking at the request line data we received from running our program so far,
we see that GET
is the method, / is the request URI, and HTTP/1.1
is the
version.
After the request line, the remaining lines starting from Host:
onward are
headers. GET
requests have no body.
Try making a request from a different browser or asking for a different address, such as 127.0.0.1:7878/test, to see how the request data changes.
Now that we know what the browser is asking for, let’s send back some data!
Writing a Response
Now we’ll implement sending data in response to a client request. Responses have the following format:
HTTP-Version Status-Code Reason-Phrase CRLF
headers CRLF
message-body
The first line is a status line that contains the HTTP version used in the response, a numeric status code that summarizes the result of the request, and a reason phrase that provides a text description of the status code. After the CRLF sequence are any headers, another CRLF sequence, and the body of the response.
Here is an example response that uses HTTP version 1.1, has a status code of 200, an OK reason phrase, no headers, and no body:
HTTP/1.1 200 OK\r\n\r\n
The status code 200 is the standard success response. The text is a tiny
successful HTTP response. Let’s write this to the stream as our response to a
successful request! From the handle_connection
function, remove the
println!
that was printing the request data and replace it with the code in
Listing 20-3.
Filename: src/main.rs
use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } fn handle_connection(mut stream: TcpStream) { let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let response = "HTTP/1.1 200 OK\r\n\r\n"; stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); }
Listing 20-3: Writing a tiny successful HTTP response to the stream
The first new line defines the response
variable that holds the success
message’s data. Then we call as_bytes
on our response
to convert the string
data to bytes. The write
method on stream
takes a &[u8]
and sends those
bytes directly down the connection.
Because the write
operation could fail, we use unwrap
on any error result
as before. Again, in a real application you would add error handling here.
Finally, flush
will wait and prevent the program from continuing until all
the bytes are written to the connection; TcpStream
contains an internal
buffer to minimize calls to the underlying operating system.
With these changes, let’s run our code and make a request. We’re no longer printing any data to the terminal, so we won’t see any output other than the output from Cargo. When you load 127.0.0.1:7878 in a web browser, you should get a blank page instead of an error. You’ve just hand-coded an HTTP request and response!
Returning Real HTML
Let’s implement the functionality for returning more than a blank page. Create a new file, hello.html, in the root of your project directory, not in the src directory. You can input any HTML you want; Listing 20-4 shows one possibility.
Filename: hello.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello!</title>
</head>
<body>
<h1>Hello!</h1>
<p>Hi from Rust</p>
</body>
</html>
Listing 20-4: A sample HTML file to return in a response
This is a minimal HTML5 document with a heading and some text. To return this
from the server when a request is received, we’ll modify handle_connection
as
shown in Listing 20-5 to read the HTML file, add it to the response as a body,
and send it.
Filename: src/main.rs
use std::fs; // --snip-- use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } fn handle_connection(mut stream: TcpStream) { let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let contents = fs::read_to_string("hello.html").unwrap(); let response = format!( "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}", contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); }
Listing 20-5: Sending the contents of hello.html as the body of the response
We’ve added a line at the top to bring the standard library’s filesystem module into scope. The code for reading the contents of a file to a string should look familiar; we used it in Chapter 12 when we read the contents of a file for our I/O project in Listing 12-4.
Next, we use format!
to add the file’s contents as the body of the success
response. To ensure a valid HTTP response, we add the Content-Length
header
which is set to the size of our response body, in this case the size of hello.html
.
Run this code with cargo run
and load 127.0.0.1:7878 in your browser; you
should see your HTML rendered!
Currently, we’re ignoring the request data in buffer
and just sending back
the contents of the HTML file unconditionally. That means if you try requesting
127.0.0.1:7878/something-else in your browser, you’ll still get back this
same HTML response. Our server is very limited and is not what most web servers
do. We want to customize our responses depending on the request and only send
back the HTML file for a well-formed request to /.
Validating the Request and Selectively Responding
Right now, our web server will return the HTML in the file no matter what the
client requested. Let’s add functionality to check that the browser is
requesting / before returning the HTML file and return an error if the
browser requests anything else. For this we need to modify handle_connection
,
as shown in Listing 20-6. This new code checks the content of the request
received against what we know a request for / looks like and adds if
and
else
blocks to treat requests differently.
Filename: src/main.rs
use std::fs; use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } // --snip-- fn handle_connection(mut stream: TcpStream) { let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let get = b"GET / HTTP/1.1\r\n"; if buffer.starts_with(get) { let contents = fs::read_to_string("hello.html").unwrap(); let response = format!( "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}", contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); } else { // some other request } }
Listing 20-6: Matching the request and handling requests to / differently from other requests
First, we hardcode the data corresponding to the / request into the get
variable. Because we’re reading raw bytes into the buffer, we transform get
into a byte string by adding the b""
byte string syntax at the start of the
content data. Then we check whether buffer
starts with the bytes in get
. If
it does, it means we’ve received a well-formed request to /, which is the
success case we’ll handle in the if
block that returns the contents of our
HTML file.
If buffer
does not start with the bytes in get
, it means we’ve received
some other request. We’ll add code to the else
block in a moment to respond
to all other requests.
Run this code now and request 127.0.0.1:7878; you should get the HTML in hello.html. If you make any other request, such as 127.0.0.1:7878/something-else, you’ll get a connection error like those you saw when running the code in Listing 20-1 and Listing 20-2.
Now let’s add the code in Listing 20-7 to the else
block to return a response
with the status code 404, which signals that the content for the request was
not found. We’ll also return some HTML for a page to render in the browser
indicating the response to the end user.
Filename: src/main.rs
use std::fs; use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } fn handle_connection(mut stream: TcpStream) { let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let get = b"GET / HTTP/1.1\r\n"; if buffer.starts_with(get) { let contents = fs::read_to_string("hello.html").unwrap(); let response = format!( "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}", contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); // --snip-- } else { let status_line = "HTTP/1.1 404 NOT FOUND"; let contents = fs::read_to_string("404.html").unwrap(); let response = format!( "{}\r\nContent-Length: {}\r\n\r\n{}", status_line, contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); } }
Listing 20-7: Responding with status code 404 and an error page if anything other than / was requested
Here, our response has a status line with status code 404 and the reason
phrase NOT FOUND
. The body of the response will be the HTML in the file
404.html. You’ll need to create a 404.html file next to hello.html for
the error page; again feel free to use any HTML you want or use the example
HTML in Listing 20-8.
Filename: 404.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello!</title>
</head>
<body>
<h1>Oops!</h1>
<p>Sorry, I don't know what you're asking for.</p>
</body>
</html>
Listing 20-8: Sample content for the page to send back with any 404 response
With these changes, run your server again. Requesting 127.0.0.1:7878 should return the contents of hello.html, and any other request, like 127.0.0.1:7878/foo, should return the error HTML from 404.html.
A Touch of Refactoring
At the moment the if
and else
blocks have a lot of repetition: they’re both
reading files and writing the contents of the files to the stream. The only
differences are the status line and the filename. Let’s make the code more
concise by pulling out those differences into separate if
and else
lines
that will assign the values of the status line and the filename to variables;
we can then use those variables unconditionally in the code to read the file
and write the response. Listing 20-9 shows the resulting code after replacing
the large if
and else
blocks.
Filename: src/main.rs
use std::fs; use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } // --snip-- fn handle_connection(mut stream: TcpStream) { // --snip-- let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let get = b"GET / HTTP/1.1\r\n"; let (status_line, filename) = if buffer.starts_with(get) { ("HTTP/1.1 200 OK", "hello.html") } else { ("HTTP/1.1 404 NOT FOUND", "404.html") }; let contents = fs::read_to_string(filename).unwrap(); let response = format!( "{}\r\nContent-Length: {}\r\n\r\n{}", status_line, contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); }
Listing 20-9: Refactoring the if
and else
blocks to
contain only the code that differs between the two cases
Now the if
and else
blocks only return the appropriate values for the
status line and filename in a tuple; we then use destructuring to assign these
two values to status_line
and filename
using a pattern in the let
statement, as discussed in Chapter 18.
The previously duplicated code is now outside the if
and else
blocks and
uses the status_line
and filename
variables. This makes it easier to see
the difference between the two cases, and it means we have only one place to
update the code if we want to change how the file reading and response writing
work. The behavior of the code in Listing 20-9 will be the same as that in
Listing 20-8.
Awesome! We now have a simple web server in approximately 40 lines of Rust code that responds to one request with a page of content and responds to all other requests with a 404 response.
Currently, our server runs in a single thread, meaning it can only serve one request at a time. Let’s examine how that can be a problem by simulating some slow requests. Then we’ll fix it so our server can handle multiple requests at once.
Turning Our Single-Threaded Server into a Multithreaded Server
Right now, the server will process each request in turn, meaning it won’t process a second connection until the first is finished processing. If the server received more and more requests, this serial execution would be less and less optimal. If the server receives a request that takes a long time to process, subsequent requests will have to wait until the long request is finished, even if the new requests can be processed quickly. We’ll need to fix this, but first, we’ll look at the problem in action.
Simulating a Slow Request in the Current Server Implementation
We’ll look at how a slow-processing request can affect other requests made to our current server implementation. Listing 20-10 implements handling a request to /sleep with a simulated slow response that will cause the server to sleep for 5 seconds before responding.
Filename: src/main.rs
use std::fs; use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; use std::thread; use std::time::Duration; // --snip-- fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); } } fn handle_connection(mut stream: TcpStream) { // --snip-- let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let get = b"GET / HTTP/1.1\r\n"; let sleep = b"GET /sleep HTTP/1.1\r\n"; let (status_line, filename) = if buffer.starts_with(get) { ("HTTP/1.1 200 OK", "hello.html") } else if buffer.starts_with(sleep) { thread::sleep(Duration::from_secs(5)); ("HTTP/1.1 200 OK", "hello.html") } else { ("HTTP/1.1 404 NOT FOUND", "404.html") }; // --snip-- let contents = fs::read_to_string(filename).unwrap(); let response = format!( "{}\r\nContent-Length: {}\r\n\r\n{}", status_line, contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); }
Listing 20-10: Simulating a slow request by recognizing /sleep and sleeping for 5 seconds
This code is a bit messy, but it’s good enough for simulation purposes. We
created a second request sleep
, whose data our server recognizes. We added an
else if
after the if
block to check for the request to /sleep. When that
request is received, the server will sleep for 5 seconds before rendering the
successful HTML page.
You can see how primitive our server is: real libraries would handle the recognition of multiple requests in a much less verbose way!
Start the server using cargo run
. Then open two browser windows: one for
http://127.0.0.1:7878/ and the other for http://127.0.0.1:7878/sleep. If
you enter the / URI a few times, as before, you’ll see it respond quickly.
But if you enter /sleep and then load /, you’ll see that / waits until
sleep
has slept for its full 5 seconds before loading.
There are multiple ways we could change how our web server works to avoid having more requests back up behind a slow request; the one we’ll implement is a thread pool.
Improving Throughput with a Thread Pool
A thread pool is a group of spawned threads that are waiting and ready to handle a task. When the program receives a new task, it assigns one of the threads in the pool to the task, and that thread will process the task. The remaining threads in the pool are available to handle any other tasks that come in while the first thread is processing. When the first thread is done processing its task, it’s returned to the pool of idle threads, ready to handle a new task. A thread pool allows you to process connections concurrently, increasing the throughput of your server.
We’ll limit the number of threads in the pool to a small number to protect us from Denial of Service (DoS) attacks; if we had our program create a new thread for each request as it came in, someone making 10 million requests to our server could create havoc by using up all our server’s resources and grinding the processing of requests to a halt.
Rather than spawning unlimited threads, we’ll have a fixed number of threads
waiting in the pool. As requests come in, they’ll be sent to the pool for
processing. The pool will maintain a queue of incoming requests. Each of the
threads in the pool will pop off a request from this queue, handle the request,
and then ask the queue for another request. With this design, we can process
N
requests concurrently, where N
is the number of threads. If each thread
is responding to a long-running request, subsequent requests can still back up
in the queue, but we’ve increased the number of long-running requests we can
handle before reaching that point.
This technique is just one of many ways to improve the throughput of a web server. Other options you might explore are the fork/join model and the single-threaded async I/O model. If you’re interested in this topic, you can read more about other solutions and try to implement them in Rust; with a low-level language like Rust, all of these options are possible.
Before we begin implementing a thread pool, let’s talk about what using the pool should look like. When you’re trying to design code, writing the client interface first can help guide your design. Write the API of the code so it’s structured in the way you want to call it; then implement the functionality within that structure rather than implementing the functionality and then designing the public API.
Similar to how we used test-driven development in the project in Chapter 12, we’ll use compiler-driven development here. We’ll write the code that calls the functions we want, and then we’ll look at errors from the compiler to determine what we should change next to get the code to work.
Code Structure If We Could Spawn a Thread for Each Request
First, let’s explore how our code might look if it did create a new thread for
every connection. As mentioned earlier, this isn’t our final plan due to the
problems with potentially spawning an unlimited number of threads, but it is a
starting point. Listing 20-11 shows the changes to make to main
to spawn a
new thread to handle each stream within the for
loop.
Filename: src/main.rs
use std::fs; use std::io::prelude::*; use std::net::TcpListener; use std::net::TcpStream; use std::thread; use std::time::Duration; fn main() { let listener = TcpListener::bind("127.0.0.1:7878").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); thread::spawn(|| { handle_connection(stream); }); } } fn handle_connection(mut stream: TcpStream) { let mut buffer = [0; 1024]; stream.read(&mut buffer).unwrap(); let get = b"GET / HTTP/1.1\r\n"; let sleep = b"GET /sleep HTTP/1.1\r\n"; let (status_line, filename) = if buffer.starts_with(get) { ("HTTP/1.1 200 OK", "hello.html") } else if buffer.starts_with(sleep) { thread::sleep(Duration::from_secs(5)); ("HTTP/1.1 200 OK", "hello.html") } else { ("HTTP/1.1 404 NOT FOUND", "404.html") }; let contents = fs::read_to_string(filename).unwrap(); let response = format!( "{}\r\nContent-Length: {}\r\n\r\n{}", status_line, contents.len(), contents ); stream.write(response.as_bytes()).unwrap(); stream.flush().unwrap(); }
Listing 20-11: Spawning a new thread for each stream
As you learned in Chapter 16, thread::spawn
will create a new thread and then
run the code in the closure in the new thread. If you run this code and load
/sleep in your browser, then / in two more browser tabs, you’ll indeed see
that the requests to / don’t have to wait for /sleep to finish. But as we
mentioned, this will eventually overwhelm the system because you’d be making
new threads without any limit.
Creating a Similar Interface for a Finite Number of Threads
We want our thread pool to work in a similar, familiar way so switching from
threads to a thread pool doesn’t require large changes to the code that uses
our API. Listing 20-12 shows the hypothetical interface for a ThreadPool
struct we want to use instead of thread::spawn
.
Filename: src/main.rs
use std::fs;
use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;
use std::thread;
use std::time::Duration;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let pool = ThreadPool::new(4);
for stream in listener.incoming() {
let stream = stream.unwrap();
pool.execute(|| {
handle_connection(stream);
});
}
}
fn handle_connection(mut stream: TcpStream) {
let mut buffer = [0; 1024];
stream.read(&mut buffer).unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK", "hello.html")
} else if buffer.starts_with(sleep) {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!(
"{}\r\nContent-Length: {}\r\n\r\n{}",
status_line,
contents.len(),
contents
);
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
}
Listing 20-12: Our ideal ThreadPool
interface
We use ThreadPool::new
to create a new thread pool with a configurable number
of threads, in this case four. Then, in the for
loop, pool.execute
has a
similar interface as thread::spawn
in that it takes a closure the pool should
run for each stream. We need to implement pool.execute
so it takes the
closure and gives it to a thread in the pool to run. This code won’t yet
compile, but we’ll try so the compiler can guide us in how to fix it.
Building the ThreadPool
Struct Using Compiler Driven Development
Make the changes in Listing 20-12 to src/main.rs, and then let’s use the
compiler errors from cargo check
to drive our development. Here is the first
error we get:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0433]: failed to resolve: use of undeclared type `ThreadPool`
--> src/main.rs:10:16
|
10 | let pool = ThreadPool::new(4);
| ^^^^^^^^^^ use of undeclared type `ThreadPool`
For more information about this error, try `rustc --explain E0433`.
error: could not compile `hello` due to previous error
Great! This error tells us we need a ThreadPool
type or module, so we’ll
build one now. Our ThreadPool
implementation will be independent of the kind
of work our web server is doing. So, let’s switch the hello
crate from a
binary crate to a library crate to hold our ThreadPool
implementation. After
we change to a library crate, we could also use the separate thread pool
library for any work we want to do using a thread pool, not just for serving
web requests.
Create a src/lib.rs that contains the following, which is the simplest
definition of a ThreadPool
struct that we can have for now:
Filename: src/lib.rs
pub struct ThreadPool;
Then create a new directory, src/bin, and move the binary crate rooted in
src/main.rs into src/bin/main.rs. Doing so will make the library crate the
primary crate in the hello directory; we can still run the binary in
src/bin/main.rs using cargo run
. After moving the main.rs file, edit it
to bring the library crate in and bring ThreadPool
into scope by adding the
following code to the top of src/bin/main.rs:
Filename: src/bin/main.rs
use hello::ThreadPool;
use std::fs;
use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;
use std::thread;
use std::time::Duration;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let pool = ThreadPool::new(4);
for stream in listener.incoming() {
let stream = stream.unwrap();
pool.execute(|| {
handle_connection(stream);
});
}
}
fn handle_connection(mut stream: TcpStream) {
let mut buffer = [0; 1024];
stream.read(&mut buffer).unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK", "hello.html")
} else if buffer.starts_with(sleep) {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!(
"{}\r\nContent-Length: {}\r\n\r\n{}",
status_line,
contents.len(),
contents
);
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
}
This code still won’t work, but let’s check it again to get the next error that we need to address:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0599]: no function or associated item named `new` found for struct `ThreadPool` in the current scope
--> src/bin/main.rs:11:28
|
11 | let pool = ThreadPool::new(4);
| ^^^ function or associated item not found in `ThreadPool`
For more information about this error, try `rustc --explain E0599`.
error: could not compile `hello` due to previous error
This error indicates that next we need to create an associated function named
new
for ThreadPool
. We also know that new
needs to have one parameter
that can accept 4
as an argument and should return a ThreadPool
instance.
Let’s implement the simplest new
function that will have those
characteristics:
Filename: src/lib.rs
pub struct ThreadPool;
impl ThreadPool {
pub fn new(size: usize) -> ThreadPool {
ThreadPool
}
}
We chose usize
as the type of the size
parameter, because we know that a
negative number of threads doesn’t make any sense. We also know we’ll use this
4 as the number of elements in a collection of threads, which is what the
usize
type is for, as discussed in the “Integer Types” section of Chapter 3.
Let’s check the code again:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0599]: no method named `execute` found for struct `ThreadPool` in the current scope
--> src/bin/main.rs:16:14
|
16 | pool.execute(|| {
| ^^^^^^^ method not found in `ThreadPool`
For more information about this error, try `rustc --explain E0599`.
error: could not compile `hello` due to previous error
Now the error occurs because we don’t have an execute
method on ThreadPool
.
Recall from the “Creating a Similar Interface for a Finite Number of
Threads” section that we decided our thread pool should have an interface
similar to thread::spawn
. In addition, we’ll implement the execute
function
so it takes the closure it’s given and gives it to an idle thread in the pool
to run.
We’ll define the execute
method on ThreadPool
to take a closure as a
parameter. Recall from the “Storing Closures Using Generic Parameters and the
Fn
Traits” section in Chapter 13 that we can take closures as parameters with
three different traits: Fn
, FnMut
, and FnOnce
. We need to decide which
kind of closure to use here. We know we’ll end up doing something similar to
the standard library thread::spawn
implementation, so we can look at what
bounds the signature of thread::spawn
has on its parameter. The documentation
shows us the following:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
The F
type parameter is the one we’re concerned with here; the T
type
parameter is related to the return value, and we’re not concerned with that. We
can see that spawn
uses FnOnce
as the trait bound on F
. This is probably
what we want as well, because we’ll eventually pass the argument we get in
execute
to spawn
. We can be further confident that FnOnce
is the trait we
want to use because the thread for running a request will only execute that
request’s closure one time, which matches the Once
in FnOnce
.
The F
type parameter also has the trait bound Send
and the lifetime bound
'static
, which are useful in our situation: we need Send
to transfer the
closure from one thread to another and 'static
because we don’t know how long
the thread will take to execute. Let’s create an execute
method on
ThreadPool
that will take a generic parameter of type F
with these bounds:
Filename: src/lib.rs
pub struct ThreadPool;
impl ThreadPool {
// --snip--
pub fn new(size: usize) -> ThreadPool {
ThreadPool
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
We still use the ()
after FnOnce
because this FnOnce
represents a closure
that takes no parameters and returns the unit type ()
. Just like function
definitions, the return type can be omitted from the signature, but even if we
have no parameters, we still need the parentheses.
Again, this is the simplest implementation of the execute
method: it does
nothing, but we’re trying only to make our code compile. Let’s check it again:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
Finished dev [unoptimized + debuginfo] target(s) in 0.24s
It compiles! But note that if you try cargo run
and make a request in the
browser, you’ll see the errors in the browser that we saw at the beginning of
the chapter. Our library isn’t actually calling the closure passed to execute
yet!
Note: A saying you might hear about languages with strict compilers, such as Haskell and Rust, is “if the code compiles, it works.” But this saying is not universally true. Our project compiles, but it does absolutely nothing! If we were building a real, complete project, this would be a good time to start writing unit tests to check that the code compiles and has the behavior we want.
Validating the Number of Threads in new
We aren’t doing anything with the parameters to new
and execute
. Let’s
implement the bodies of these functions with the behavior we want. To start,
let’s think about new
. Earlier we chose an unsigned type for the size
parameter, because a pool with a negative number of threads makes no sense.
However, a pool with zero threads also makes no sense, yet zero is a perfectly
valid usize
. We’ll add code to check that size
is greater than zero before
we return a ThreadPool
instance and have the program panic if it receives a
zero by using the assert!
macro, as shown in Listing 20-13.
Filename: src/lib.rs
pub struct ThreadPool;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
ThreadPool
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
Listing 20-13: Implementing ThreadPool::new
to panic if
size
is zero
We’ve added some documentation for our ThreadPool
with doc comments. Note
that we followed good documentation practices by adding a section that calls
out the situations in which our function can panic, as discussed in Chapter 14.
Try running cargo doc --open
and clicking the ThreadPool
struct to see what
the generated docs for new
look like!
Instead of adding the assert!
macro as we’ve done here, we could make new
return a Result
like we did with Config::new
in the I/O project in Listing
12-9. But we’ve decided in this case that trying to create a thread pool
without any threads should be an unrecoverable error. If you’re feeling
ambitious, try to write a version of new
with the following signature to
compare both versions:
pub fn new(size: usize) -> Result<ThreadPool, PoolCreationError> {
Creating Space to Store the Threads
Now that we have a way to know we have a valid number of threads to store in
the pool, we can create those threads and store them in the ThreadPool
struct
before returning it. But how do we “store” a thread? Let’s take another look at
the thread::spawn
signature:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
The spawn
function returns a JoinHandle<T>
, where T
is the type that the
closure returns. Let’s try using JoinHandle
too and see what happens. In our
case, the closures we’re passing to the thread pool will handle the connection
and not return anything, so T
will be the unit type ()
.
The code in Listing 20-14 will compile but doesn’t create any threads yet.
We’ve changed the definition of ThreadPool
to hold a vector of
thread::JoinHandle<()>
instances, initialized the vector with a capacity of
size
, set up a for
loop that will run some code to create the threads, and
returned a ThreadPool
instance containing them.
Filename: src/lib.rs
use std::thread;
pub struct ThreadPool {
threads: Vec<thread::JoinHandle<()>>,
}
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let mut threads = Vec::with_capacity(size);
for _ in 0..size {
// create some threads and store them in the vector
}
ThreadPool { threads }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
Listing 20-14: Creating a vector for ThreadPool
to hold
the threads
We’ve brought std::thread
into scope in the library crate, because we’re
using thread::JoinHandle
as the type of the items in the vector in
ThreadPool
.
Once a valid size is received, our ThreadPool
creates a new vector that can
hold size
items. We haven’t used the with_capacity
function in this book
yet, which performs the same task as Vec::new
but with an important
difference: it preallocates space in the vector. Because we know we need to
store size
elements in the vector, doing this allocation up front is slightly
more efficient than using Vec::new
, which resizes itself as elements are
inserted.
When you run cargo check
again, you’ll get a few more warnings, but it should
succeed.
A Worker
Struct Responsible for Sending Code from the ThreadPool
to a Thread
We left a comment in the for
loop in Listing 20-14 regarding the creation of
threads. Here, we’ll look at how we actually create threads. The standard
library provides thread::spawn
as a way to create threads, and
thread::spawn
expects to get some code the thread should run as soon as the
thread is created. However, in our case, we want to create the threads and have
them wait for code that we’ll send later. The standard library’s
implementation of threads doesn’t include any way to do that; we have to
implement it manually.
We’ll implement this behavior by introducing a new data structure between the
ThreadPool
and the threads that will manage this new behavior. We’ll call
this data structure Worker
, which is a common term in pooling
implementations. Think of people working in the kitchen at a restaurant: the
workers wait until orders come in from customers, and then they’re responsible
for taking those orders and filling them.
Instead of storing a vector of JoinHandle<()>
instances in the thread pool,
we’ll store instances of the Worker
struct. Each Worker
will store a single
JoinHandle<()>
instance. Then we’ll implement a method on Worker
that will
take a closure of code to run and send it to the already running thread for
execution. We’ll also give each worker an id
so we can distinguish between
the different workers in the pool when logging or debugging.
Let’s make the following changes to what happens when we create a ThreadPool
.
We’ll implement the code that sends the closure to the thread after we have
Worker
set up in this way:
- Define a
Worker
struct that holds anid
and aJoinHandle<()>
. - Change
ThreadPool
to hold a vector ofWorker
instances. - Define a
Worker::new
function that takes anid
number and returns aWorker
instance that holds theid
and a thread spawned with an empty closure. - In
ThreadPool::new
, use thefor
loop counter to generate anid
, create a newWorker
with thatid
, and store the worker in the vector.
If you’re up for a challenge, try implementing these changes on your own before looking at the code in Listing 20-15.
Ready? Here is Listing 20-15 with one way to make the preceding modifications.
Filename: src/lib.rs
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
}
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id));
}
ThreadPool { workers }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize) -> Worker {
let thread = thread::spawn(|| {});
Worker { id, thread }
}
}
Listing 20-15: Modifying ThreadPool
to hold Worker
instances instead of holding threads directly
We’ve changed the name of the field on ThreadPool
from threads
to workers
because it’s now holding Worker
instances instead of JoinHandle<()>
instances. We use the counter in the for
loop as an argument to
Worker::new
, and we store each new Worker
in the vector named workers
.
External code (like our server in src/bin/main.rs) doesn’t need to know the
implementation details regarding using a Worker
struct within ThreadPool
,
so we make the Worker
struct and its new
function private. The
Worker::new
function uses the id
we give it and stores a JoinHandle<()>
instance that is created by spawning a new thread using an empty closure.
This code will compile and will store the number of Worker
instances we
specified as an argument to ThreadPool::new
. But we’re still not processing
the closure that we get in execute
. Let’s look at how to do that next.
Sending Requests to Threads via Channels
Now we’ll tackle the problem that the closures given to thread::spawn
do
absolutely nothing. Currently, we get the closure we want to execute in the
execute
method. But we need to give thread::spawn
a closure to run when we
create each Worker
during the creation of the ThreadPool
.
We want the Worker
structs that we just created to fetch code to run from a
queue held in the ThreadPool
and send that code to its thread to run.
In Chapter 16, you learned about channels—a simple way to communicate between
two threads—that would be perfect for this use case. We’ll use a channel to
function as the queue of jobs, and execute
will send a job from the
ThreadPool
to the Worker
instances, which will send the job to its thread.
Here is the plan:
- The
ThreadPool
will create a channel and hold on to the sending side of the channel. - Each
Worker
will hold on to the receiving side of the channel. - We’ll create a new
Job
struct that will hold the closures we want to send down the channel. - The
execute
method will send the job it wants to execute down the sending side of the channel. - In its thread, the
Worker
will loop over its receiving side of the channel and execute the closures of any jobs it receives.
Let’s start by creating a channel in ThreadPool::new
and holding the sending
side in the ThreadPool
instance, as shown in Listing 20-16. The Job
struct
doesn’t hold anything for now but will be the type of item we’re sending down
the channel.
Filename: src/lib.rs
use std::thread;
// --snip--
use std::sync::mpsc;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
struct Job;
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id));
}
ThreadPool { workers, sender }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize) -> Worker {
let thread = thread::spawn(|| {});
Worker { id, thread }
}
}
Listing 20-16: Modifying ThreadPool
to store the
sending end of a channel that sends Job
instances
In ThreadPool::new
, we create our new channel and have the pool hold the
sending end. This will successfully compile, still with warnings.
Let’s try passing a receiving end of the channel into each worker as the thread
pool creates the channel. We know we want to use the receiving end in the
thread that the workers spawn, so we’ll reference the receiver
parameter in
the closure. The code in Listing 20-17 won’t quite compile yet.
Filename: src/lib.rs
use std::sync::mpsc;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
struct Job;
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, receiver));
}
ThreadPool { workers, sender }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
// --snip--
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Worker {
let thread = thread::spawn(|| {
receiver;
});
Worker { id, thread }
}
}
Listing 20-17: Passing the receiving end of the channel to the workers
We’ve made some small and straightforward changes: we pass the receiving end of
the channel into Worker::new
, and then we use it inside the closure.
When we try to check this code, we get this error:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0382]: use of moved value: `receiver`
--> src/lib.rs:27:42
|
22 | let (sender, receiver) = mpsc::channel();
| -------- move occurs because `receiver` has type `std::sync::mpsc::Receiver<Job>`, which does not implement the `Copy` trait
...
27 | workers.push(Worker::new(id, receiver));
| ^^^^^^^^ value moved here, in previous iteration of loop
For more information about this error, try `rustc --explain E0382`.
error: could not compile `hello` due to previous error
The code is trying to pass receiver
to multiple Worker
instances. This
won’t work, as you’ll recall from Chapter 16: the channel implementation that
Rust provides is multiple producer, single consumer. This means we can’t
just clone the consuming end of the channel to fix this code. Even if we could,
that is not the technique we would want to use; instead, we want to distribute
the jobs across threads by sharing the single receiver
among all the workers.
Additionally, taking a job off the channel queue involves mutating the
receiver
, so the threads need a safe way to share and modify receiver
;
otherwise, we might get race conditions (as covered in Chapter 16).
Recall the thread-safe smart pointers discussed in Chapter 16: to share
ownership across multiple threads and allow the threads to mutate the value, we
need to use Arc<Mutex<T>>
. The Arc
type will let multiple workers own the
receiver, and Mutex
will ensure that only one worker gets a job from the
receiver at a time. Listing 20-18 shows the changes we need to make.
Filename: src/lib.rs
use std::sync::mpsc;
use std::thread;
use std::sync::Arc;
use std::sync::Mutex;
// --snip--
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
struct Job;
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
// --snip--
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
}
}
// --snip--
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
// --snip--
let thread = thread::spawn(|| {
receiver;
});
Worker { id, thread }
}
}
Listing 20-18: Sharing the receiving end of the channel
among the workers using Arc
and Mutex
In ThreadPool::new
, we put the receiving end of the channel in an Arc
and a
Mutex
. For each new worker, we clone the Arc
to bump the reference count so
the workers can share ownership of the receiving end.
With these changes, the code compiles! We’re getting there!
Implementing the execute
Method
Let’s finally implement the execute
method on ThreadPool
. We’ll also change
Job
from a struct to a type alias for a trait object that holds the type of
closure that execute
receives. As discussed in the “Creating Type Synonyms
with Type Aliases”
section of Chapter 19, type aliases allow us to make long types shorter. Look
at Listing 20-19.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
// --snip--
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
// --snip--
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(|| {
receiver;
});
Worker { id, thread }
}
}
Listing 20-19: Creating a Job
type alias for a Box
that holds each closure and then sending the job down the channel
After creating a new Job
instance using the closure we get in execute
, we
send that job down the sending end of the channel. We’re calling unwrap
on
send
for the case that sending fails. This might happen if, for example, we
stop all our threads from executing, meaning the receiving end has stopped
receiving new messages. At the moment, we can’t stop our threads from
executing: our threads continue executing as long as the pool exists. The
reason we use unwrap
is that we know the failure case won’t happen, but the
compiler doesn’t know that.
But we’re not quite done yet! In the worker, our closure being passed to
thread::spawn
still only references the receiving end of the channel.
Instead, we need the closure to loop forever, asking the receiving end of the
channel for a job and running the job when it gets one. Let’s make the change
shown in Listing 20-20 to Worker::new
.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
// --snip--
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} got a job; executing.", id);
job();
});
Worker { id, thread }
}
}
Listing 20-20: Receiving and executing the jobs in the worker’s thread
Here, we first call lock
on the receiver
to acquire the mutex, and then we
call unwrap
to panic on any errors. Acquiring a lock might fail if the mutex
is in a poisoned state, which can happen if some other thread panicked while
holding the lock rather than releasing the lock. In this situation, calling
unwrap
to have this thread panic is the correct action to take. Feel free to
change this unwrap
to an expect
with an error message that is meaningful to
you.
If we get the lock on the mutex, we call recv
to receive a Job
from the
channel. A final unwrap
moves past any errors here as well, which might occur
if the thread holding the sending side of the channel has shut down, similar to
how the send
method returns Err
if the receiving side shuts down.
The call to recv
blocks, so if there is no job yet, the current thread will
wait until a job becomes available. The Mutex<T>
ensures that only one
Worker
thread at a time is trying to request a job.
Our thread pool is now in a working state! Give it a cargo run
and make some
requests:
$ cargo run
Compiling hello v0.1.0 (file:///projects/hello)
warning: field is never read: `workers`
--> src/lib.rs:7:5
|
7 | workers: Vec<Worker>,
| ^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(dead_code)]` on by default
warning: field is never read: `id`
--> src/lib.rs:48:5
|
48 | id: usize,
| ^^^^^^^^^
warning: field is never read: `thread`
--> src/lib.rs:49:5
|
49 | thread: thread::JoinHandle<()>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: 3 warnings emitted
Finished dev [unoptimized + debuginfo] target(s) in 1.40s
Running `target/debug/main`
Worker 0 got a job; executing.
Worker 2 got a job; executing.
Worker 1 got a job; executing.
Worker 3 got a job; executing.
Worker 0 got a job; executing.
Worker 2 got a job; executing.
Worker 1 got a job; executing.
Worker 3 got a job; executing.
Worker 0 got a job; executing.
Worker 2 got a job; executing.
Success! We now have a thread pool that executes connections asynchronously. There are never more than four threads created, so our system won’t get overloaded if the server receives a lot of requests. If we make a request to /sleep, the server will be able to serve other requests by having another thread run them.
Note: if you open /sleep in multiple browser windows simultaneously, they might load one at a time in 5 second intervals. Some web browsers execute multiple instances of the same request sequentially for caching reasons. This limitation is not caused by our web server.
After learning about the while let
loop in Chapter 18, you might be wondering
why we didn’t write the worker thread code as shown in Listing 20-21.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
// --snip--
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || {
while let Ok(job) = receiver.lock().unwrap().recv() {
println!("Worker {} got a job; executing.", id);
job();
}
});
Worker { id, thread }
}
}
Listing 20-21: An alternative implementation of
Worker::new
using while let
This code compiles and runs but doesn’t result in the desired threading
behavior: a slow request will still cause other requests to wait to be
processed. The reason is somewhat subtle: the Mutex
struct has no public
unlock
method because the ownership of the lock is based on the lifetime of
the MutexGuard<T>
within the LockResult<MutexGuard<T>>
that the lock
method returns. At compile time, the borrow checker can then enforce the rule
that a resource guarded by a Mutex
cannot be accessed unless we hold the
lock. But this implementation can also result in the lock being held longer
than intended if we don’t think carefully about the lifetime of the
MutexGuard<T>
.
The code in Listing 20-20 that uses let job = receiver.lock().unwrap().recv().unwrap();
works because with let
, any
temporary values used in the expression on the right hand side of the equals
sign are immediately dropped when the let
statement ends. However, while let
(and if let
and match
) does not drop temporary values until the end of
the associated block. In Listing 20-21, the lock remains held for the duration
of the call to job()
, meaning other workers cannot receive jobs.
Graceful Shutdown and Cleanup
The code in Listing 20-20 is responding to requests asynchronously through the
use of a thread pool, as we intended. We get some warnings about the workers
,
id
, and thread
fields that we’re not using in a direct way that reminds us
we’re not cleaning up anything. When we use the less elegant ctrl-c method to halt the main thread, all other
threads are stopped immediately as well, even if they’re in the middle of
serving a request.
Now we’ll implement the Drop
trait to call join
on each of the threads in
the pool so they can finish the requests they’re working on before closing.
Then we’ll implement a way to tell the threads they should stop accepting new
requests and shut down. To see this code in action, we’ll modify our server to
accept only two requests before gracefully shutting down its thread pool.
Implementing the Drop
Trait on ThreadPool
Let’s start with implementing Drop
on our thread pool. When the pool is
dropped, our threads should all join to make sure they finish their work.
Listing 20-22 shows a first attempt at a Drop
implementation; this code won’t
quite work yet.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
worker.thread.join().unwrap();
}
}
}
struct Worker {
id: usize,
thread: thread::JoinHandle<()>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} got a job; executing.", id);
job();
});
Worker { id, thread }
}
}
Listing 20-22: Joining each thread when the thread pool goes out of scope
First, we loop through each of the thread pool workers
. We use &mut
for
this because self
is a mutable reference, and we also need to be able to
mutate worker
. For each worker, we print a message saying that this
particular worker is shutting down, and then we call join
on that worker’s
thread. If the call to join
fails, we use unwrap
to make Rust panic and go
into an ungraceful shutdown.
Here is the error we get when we compile this code:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0507]: cannot move out of `worker.thread` which is behind a mutable reference
--> src/lib.rs:52:13
|
52 | worker.thread.join().unwrap();
| ^^^^^^^^^^^^^ move occurs because `worker.thread` has type `JoinHandle<()>`, which does not implement the `Copy` trait
For more information about this error, try `rustc --explain E0507`.
error: could not compile `hello` due to previous error
The error tells us we can’t call join
because we only have a mutable borrow
of each worker
and join
takes ownership of its argument. To solve this
issue, we need to move the thread out of the Worker
instance that owns
thread
so join
can consume the thread. We did this in Listing 17-15: if
Worker
holds an Option<thread::JoinHandle<()>>
instead, we can call the
take
method on the Option
to move the value out of the Some
variant and
leave a None
variant in its place. In other words, a Worker
that is running
will have a Some
variant in thread
, and when we want to clean up a
Worker
, we’ll replace Some
with None
so the Worker
doesn’t have a
thread to run.
So we know we want to update the definition of Worker
like this:
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
worker.thread.join().unwrap();
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} got a job; executing.", id);
job();
});
Worker { id, thread }
}
}
Now let’s lean on the compiler to find the other places that need to change. Checking this code, we get two errors:
$ cargo check
Checking hello v0.1.0 (file:///projects/hello)
error[E0599]: no method named `join` found for enum `Option` in the current scope
--> src/lib.rs:52:27
|
52 | worker.thread.join().unwrap();
| ^^^^ method not found in `Option<JoinHandle<()>>`
error[E0308]: mismatched types
--> src/lib.rs:72:22
|
72 | Worker { id, thread }
| ^^^^^^ expected enum `Option`, found struct `JoinHandle`
|
= note: expected enum `Option<JoinHandle<()>>`
found struct `JoinHandle<_>`
help: try wrapping the expression in `Some`
|
72 | Worker { id, Some(thread) }
| +++++ +
Some errors have detailed explanations: E0308, E0599.
For more information about an error, try `rustc --explain E0308`.
error: could not compile `hello` due to 2 previous errors
Let’s address the second error, which points to the code at the end of
Worker::new
; we need to wrap the thread
value in Some
when we create a
new Worker
. Make the following changes to fix this error:
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
worker.thread.join().unwrap();
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
// --snip--
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} got a job; executing.", id);
job();
});
Worker {
id,
thread: Some(thread),
}
}
}
The first error is in our Drop
implementation. We mentioned earlier that we
intended to call take
on the Option
value to move thread
out of worker
.
The following changes will do so:
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
if let Some(thread) = worker.thread.take() {
thread.join().unwrap();
}
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} got a job; executing.", id);
job();
});
Worker {
id,
thread: Some(thread),
}
}
}
As discussed in Chapter 17, the take
method on Option
takes the Some
variant out and leaves None
in its place. We’re using if let
to destructure
the Some
and get the thread; then we call join
on the thread. If a worker’s
thread is already None
, we know that worker has already had its thread
cleaned up, so nothing happens in that case.
Signaling to the Threads to Stop Listening for Jobs
With all the changes we’ve made, our code compiles without any warnings. But
the bad news is this code doesn’t function the way we want it to yet. The key
is the logic in the closures run by the threads of the Worker
instances: at
the moment, we call join
, but that won’t shut down the threads because they
loop
forever looking for jobs. If we try to drop our ThreadPool
with our
current implementation of drop
, the main thread will block forever waiting
for the first thread to finish.
To fix this problem, we’ll modify the threads so they listen for either a Job
to run or a signal that they should stop listening and exit the infinite loop.
Instead of Job
instances, our channel will send one of these two enum
variants.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
enum Message {
NewJob(Job),
Terminate,
}
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
if let Some(thread) = worker.thread.take() {
thread.join().unwrap();
}
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} got a job; executing.", id);
job();
});
Worker {
id,
thread: Some(thread),
}
}
}
This Message
enum will either be a NewJob
variant that holds the Job
the
thread should run, or it will be a Terminate
variant that will cause the
thread to exit its loop and stop.
We need to adjust the channel to use values of type Message
rather than type
Job
, as shown in Listing 20-23.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Message>,
}
// --snip--
type Job = Box<dyn FnOnce() + Send + 'static>;
enum Message {
NewJob(Job),
Terminate,
}
impl ThreadPool {
// --snip--
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(Message::NewJob(job)).unwrap();
}
}
// --snip--
impl Drop for ThreadPool {
fn drop(&mut self) {
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
if let Some(thread) = worker.thread.take() {
thread.join().unwrap();
}
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
let thread = thread::spawn(move || loop {
let message = receiver.lock().unwrap().recv().unwrap();
match message {
Message::NewJob(job) => {
println!("Worker {} got a job; executing.", id);
job();
}
Message::Terminate => {
println!("Worker {} was told to terminate.", id);
break;
}
}
});
Worker {
id,
thread: Some(thread),
}
}
}
Listing 20-23: Sending and receiving Message
values and
exiting the loop if a Worker
receives Message::Terminate
To incorporate the Message
enum, we need to change Job
to Message
in two
places: the definition of ThreadPool
and the signature of Worker::new
. The
execute
method of ThreadPool
needs to send jobs wrapped in the
Message::NewJob
variant. Then, in Worker::new
where a Message
is received
from the channel, the job will be processed if the NewJob
variant is
received, and the thread will break out of the loop if the Terminate
variant
is received.
With these changes, the code will compile and continue to function in the same
way as it did after Listing 20-20. But we’ll get a warning because we aren’t
creating any messages of the Terminate
variety. Let’s fix this warning by
changing our Drop
implementation to look like Listing 20-24.
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Message>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
enum Message {
NewJob(Job),
Terminate,
}
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(Message::NewJob(job)).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
println!("Sending terminate message to all workers.");
for _ in &self.workers {
self.sender.send(Message::Terminate).unwrap();
}
println!("Shutting down all workers.");
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
if let Some(thread) = worker.thread.take() {
thread.join().unwrap();
}
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
let thread = thread::spawn(move || loop {
let message = receiver.lock().unwrap().recv().unwrap();
match message {
Message::NewJob(job) => {
println!("Worker {} got a job; executing.", id);
job();
}
Message::Terminate => {
println!("Worker {} was told to terminate.", id);
break;
}
}
});
Worker {
id,
thread: Some(thread),
}
}
}
Listing 20-24: Sending Message::Terminate
to the
workers before calling join
on each worker thread
We’re now iterating over the workers twice: once to send one Terminate
message for each worker and once to call join
on each worker’s thread. If we
tried to send a message and join
immediately in the same loop, we couldn’t
guarantee that the worker in the current iteration would be the one to get the
message from the channel.
To better understand why we need two separate loops, imagine a scenario with
two workers. If we used a single loop to iterate through each worker, on the
first iteration a terminate message would be sent down the channel and join
called on the first worker’s thread. If that first worker was busy processing a
request at that moment, the second worker would pick up the terminate message
from the channel and shut down. We would be left waiting on the first worker to
shut down, but it never would because the second thread picked up the terminate
message. Deadlock!
To prevent this scenario, we first put all of our Terminate
messages on the
channel in one loop; then we join on all the threads in another loop. Each
worker will stop receiving requests on the channel once it gets a terminate
message. So, we can be sure that if we send the same number of terminate
messages as there are workers, each worker will receive a terminate message
before join
is called on its thread.
To see this code in action, let’s modify main
to accept only two requests
before gracefully shutting down the server, as shown in Listing 20-25.
Filename: src/bin/main.rs
use hello::ThreadPool;
use std::fs;
use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;
use std::thread;
use std::time::Duration;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let pool = ThreadPool::new(4);
for stream in listener.incoming().take(2) {
let stream = stream.unwrap();
pool.execute(|| {
handle_connection(stream);
});
}
println!("Shutting down.");
}
fn handle_connection(mut stream: TcpStream) {
let mut buffer = [0; 1024];
stream.read(&mut buffer).unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK", "hello.html")
} else if buffer.starts_with(sleep) {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!(
"{}\r\nContent-Length: {}\r\n\r\n{}",
status_line,
contents.len(),
contents
);
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
}
Listing 20-25: Shut down the server after serving two requests by exiting the loop
You wouldn’t want a real-world web server to shut down after serving only two requests. This code just demonstrates that the graceful shutdown and cleanup is in working order.
The take
method is defined in the Iterator
trait and limits the iteration
to the first two items at most. The ThreadPool
will go out of scope at the
end of main
, and the drop
implementation will run.
Start the server with cargo run
, and make three requests. The third request
should error, and in your terminal you should see output similar to this:
$ cargo run
Compiling hello v0.1.0 (file:///projects/hello)
Finished dev [unoptimized + debuginfo] target(s) in 1.0s
Running `target/debug/main`
Worker 0 got a job; executing.
Worker 3 got a job; executing.
Shutting down.
Sending terminate message to all workers.
Shutting down all workers.
Shutting down worker 0
Worker 1 was told to terminate.
Worker 2 was told to terminate.
Worker 0 was told to terminate.
Worker 3 was told to terminate.
Shutting down worker 1
Shutting down worker 2
Shutting down worker 3
You might see a different ordering of workers and messages printed. We can see
how this code works from the messages: workers 0 and 3 got the first two
requests, and then on the third request, the server stopped accepting
connections. When the ThreadPool
goes out of scope at the end of main
, its
Drop
implementation kicks in, and the pool tells all workers to terminate.
The workers each print a message when they see the terminate message, and then
the thread pool calls join
to shut down each worker thread.
Notice one interesting aspect of this particular execution: the ThreadPool
sent the terminate messages down the channel, and before any worker received
the messages, we tried to join worker 0. Worker 0 had not yet received the
terminate message, so the main thread blocked waiting for worker 0 to finish.
In the meantime, each of the workers received the termination messages. When
worker 0 finished, the main thread waited for the rest of the workers to
finish. At that point, they had all received the termination message and were
able to shut down.
Congrats! We’ve now completed our project; we have a basic web server that uses a thread pool to respond asynchronously. We’re able to perform a graceful shutdown of the server, which cleans up all the threads in the pool.
Here’s the full code for reference:
Filename: src/bin/main.rs
use hello::ThreadPool;
use std::fs;
use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;
use std::thread;
use std::time::Duration;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let pool = ThreadPool::new(4);
for stream in listener.incoming() {
let stream = stream.unwrap();
pool.execute(|| {
handle_connection(stream);
});
}
println!("Shutting down.");
}
fn handle_connection(mut stream: TcpStream) {
let mut buffer = [0; 1024];
stream.read(&mut buffer).unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK", "hello.html")
} else if buffer.starts_with(sleep) {
thread::sleep(Duration::from_secs(5));
("HTTP/1.1 200 OK", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!(
"{}\r\nContent-Length: {}\r\n\r\n{}",
status_line,
contents.len(),
contents
);
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
}
Filename: src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
pub struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Message>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
enum Message {
NewJob(Job),
Terminate,
}
impl ThreadPool {
/// Create a new ThreadPool.
///
/// The size is the number of threads in the pool.
///
/// # Panics
///
/// The `new` function will panic if the size is zero.
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
pub fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(Message::NewJob(job)).unwrap();
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
println!("Sending terminate message to all workers.");
for _ in &self.workers {
self.sender.send(Message::Terminate).unwrap();
}
println!("Shutting down all workers.");
for worker in &mut self.workers {
println!("Shutting down worker {}", worker.id);
if let Some(thread) = worker.thread.take() {
thread.join().unwrap();
}
}
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
let thread = thread::spawn(move || loop {
let message = receiver.lock().unwrap().recv().unwrap();
match message {
Message::NewJob(job) => {
println!("Worker {} got a job; executing.", id);
job();
}
Message::Terminate => {
println!("Worker {} was told to terminate.", id);
break;
}
}
});
Worker {
id,
thread: Some(thread),
}
}
}
We could do more here! If you want to continue enhancing this project, here are some ideas:
- Add more documentation to
ThreadPool
and its public methods. - Add tests of the library’s functionality.
- Change calls to
unwrap
to more robust error handling. - Use
ThreadPool
to perform some task other than serving web requests. - Find a thread pool crate on crates.io and implement a similar web server using the crate instead. Then compare its API and robustness to the thread pool we implemented.
Summary
Well done! You’ve made it to the end of the book! We want to thank you for joining us on this tour of Rust. You’re now ready to implement your own Rust projects and help with other peoples’ projects. Keep in mind that there is a welcoming community of other Rustaceans who would love to help you with any challenges you encounter on your Rust journey.
Phụ lục
Phần này bao gồm thông tin tham chiếu bạn có thể tìm thấy trong hành trình Rust của mình.
Appendix A: Keywords
The following list contains keywords that are reserved for current or future use by the Rust language. As such, they cannot be used as identifiers (except as raw identifiers as we’ll discuss in the “Raw Identifiers” section), including names of functions, variables, parameters, struct fields, modules, crates, constants, macros, static values, attributes, types, traits, or lifetimes.
Keywords Currently in Use
The following keywords currently have the functionality described.
as
- perform primitive casting, disambiguate the specific trait containing an item, or rename items inuse
andextern crate
statementsasync
- return aFuture
instead of blocking the current threadawait
- suspend execution until the result of aFuture
is readybreak
- exit a loop immediatelyconst
- define constant items or constant raw pointerscontinue
- continue to the next loop iterationcrate
- link an external crate or a macro variable representing the crate in which the macro is defineddyn
- dynamic dispatch to a trait objectelse
- fallback forif
andif let
control flow constructsenum
- define an enumerationextern
- link an external crate, function, or variablefalse
- Boolean false literalfn
- define a function or the function pointer typefor
- loop over items from an iterator, implement a trait, or specify a higher-ranked lifetimeif
- branch based on the result of a conditional expressionimpl
- implement inherent or trait functionalityin
- part offor
loop syntaxlet
- bind a variableloop
- loop unconditionallymatch
- match a value to patternsmod
- define a modulemove
- make a closure take ownership of all its capturesmut
- denote mutability in references, raw pointers, or pattern bindingspub
- denote public visibility in struct fields,impl
blocks, or modulesref
- bind by referencereturn
- return from functionSelf
- a type alias for the type we are defining or implementingself
- method subject or current modulestatic
- global variable or lifetime lasting the entire program executionstruct
- define a structuresuper
- parent module of the current moduletrait
- define a traittrue
- Boolean true literaltype
- define a type alias or associated typeunion
- define a union and is only a keyword when used in a union declarationunsafe
- denote unsafe code, functions, traits, or implementationsuse
- bring symbols into scopewhere
- denote clauses that constrain a typewhile
- loop conditionally based on the result of an expression
Keywords Reserved for Future Use
The following keywords do not have any functionality but are reserved by Rust for potential future use.
abstract
become
box
do
final
macro
override
priv
try
typeof
unsized
virtual
yield
Raw Identifiers
Raw identifiers are the syntax that lets you use keywords where they wouldn’t
normally be allowed. You use a raw identifier by prefixing a keyword with r#
.
For example, match
is a keyword. If you try to compile the following function
that uses match
as its name:
Filename: src/main.rs
fn match(needle: &str, haystack: &str) -> bool {
haystack.contains(needle)
}
you’ll get this error:
error: expected identifier, found keyword `match`
--> src/main.rs:4:4
|
4 | fn match(needle: &str, haystack: &str) -> bool {
| ^^^^^ expected identifier, found keyword
The error shows that you can’t use the keyword match
as the function
identifier. To use match
as a function name, you need to use the raw
identifier syntax, like this:
Filename: src/main.rs
fn r#match(needle: &str, haystack: &str) -> bool { haystack.contains(needle) } fn main() { assert!(r#match("foo", "foobar")); }
This code will compile without any errors. Note the r#
prefix on the function
name in its definition as well as where the function is called in main
.
Raw identifiers allow you to use any word you choose as an identifier, even if
that word happens to be a reserved keyword. In addition, raw identifiers allow
you to use libraries written in a different Rust edition than your crate uses.
For example, try
isn’t a keyword in the 2015 edition but is in the 2018
edition. If you depend on a library that’s written using the 2015 edition and
has a try
function, you’ll need to use the raw identifier syntax, r#try
in
this case, to call that function from your 2018 edition code. See Appendix
E for more information on editions.
Appendix B: Operators and Symbols
This appendix contains a glossary of Rust’s syntax, including operators and other symbols that appear by themselves or in the context of paths, generics, trait bounds, macros, attributes, comments, tuples, and brackets.
Operators
Table B-1 contains the operators in Rust, an example of how the operator would appear in context, a short explanation, and whether that operator is overloadable. If an operator is overloadable, the relevant trait to use to overload that operator is listed.
Table B-1: Operators
Operator | Example | Explanation | Overloadable? |
---|---|---|---|
! | ident!(...) , ident!{...} , ident![...] | Macro expansion | |
! | !expr | Bitwise or logical complement | Not |
!= | var != expr | Nonequality comparison | PartialEq |
% | expr % expr | Arithmetic remainder | Rem |
%= | var %= expr | Arithmetic remainder and assignment | RemAssign |
& | &expr , &mut expr | Borrow | |
& | &type , &mut type , &'a type , &'a mut type | Borrowed pointer type | |
& | expr & expr | Bitwise AND | BitAnd |
&= | var &= expr | Bitwise AND and assignment | BitAndAssign |
&& | expr && expr | Short-circuiting logical AND | |
* | expr * expr | Arithmetic multiplication | Mul |
*= | var *= expr | Arithmetic multiplication and assignment | MulAssign |
* | *expr | Dereference | Deref |
* | *const type , *mut type | Raw pointer | |
+ | trait + trait , 'a + trait | Compound type constraint | |
+ | expr + expr | Arithmetic addition | Add |
+= | var += expr | Arithmetic addition and assignment | AddAssign |
, | expr, expr | Argument and element separator | |
- | - expr | Arithmetic negation | Neg |
- | expr - expr | Arithmetic subtraction | Sub |
-= | var -= expr | Arithmetic subtraction and assignment | SubAssign |
-> | fn(...) -> type , |...| -> type | Function and closure return type | |
. | expr.ident | Member access | |
.. | .. , expr.. , ..expr , expr..expr | Right-exclusive range literal | PartialOrd |
..= | ..=expr , expr..=expr | Right-inclusive range literal | PartialOrd |
.. | ..expr | Struct literal update syntax | |
.. | variant(x, ..) , struct_type { x, .. } | “And the rest” pattern binding | |
... | expr...expr | (Deprecated, use ..= instead) In a pattern: inclusive range pattern | |
/ | expr / expr | Arithmetic division | Div |
/= | var /= expr | Arithmetic division and assignment | DivAssign |
: | pat: type , ident: type | Constraints | |
: | ident: expr | Struct field initializer | |
: | 'a: loop {...} | Loop label | |
; | expr; | Statement and item terminator | |
; | [...; len] | Part of fixed-size array syntax | |
<< | expr << expr | Left-shift | Shl |
<<= | var <<= expr | Left-shift and assignment | ShlAssign |
< | expr < expr | Less than comparison | PartialOrd |
<= | expr <= expr | Less than or equal to comparison | PartialOrd |
= | var = expr , ident = type | Assignment/equivalence | |
== | expr == expr | Equality comparison | PartialEq |
=> | pat => expr | Part of match arm syntax | |
> | expr > expr | Greater than comparison | PartialOrd |
>= | expr >= expr | Greater than or equal to comparison | PartialOrd |
>> | expr >> expr | Right-shift | Shr |
>>= | var >>= expr | Right-shift and assignment | ShrAssign |
@ | ident @ pat | Pattern binding | |
^ | expr ^ expr | Bitwise exclusive OR | BitXor |
^= | var ^= expr | Bitwise exclusive OR and assignment | BitXorAssign |
| | pat | pat | Pattern alternatives | |
| | expr | expr | Bitwise OR | BitOr |
|= | var |= expr | Bitwise OR and assignment | BitOrAssign |
|| | expr || expr | Short-circuiting logical OR | |
? | expr? | Error propagation |
Non-operator Symbols
The following list contains all non-letters that don’t function as operators; that is, they don’t behave like a function or method call.
Table B-2 shows symbols that appear on their own and are valid in a variety of locations.
Table B-2: Stand-Alone Syntax
Symbol | Explanation |
---|---|
'ident | Named lifetime or loop label |
...u8 , ...i32 , ...f64 , ...usize , etc. | Numeric literal of specific type |
"..." | String literal |
r"..." , r#"..."# , r##"..."## , etc. | Raw string literal, escape characters not processed |
b"..." | Byte string literal; constructs a [u8] instead of a string |
br"..." , br#"..."# , br##"..."## , etc. | Raw byte string literal, combination of raw and byte string literal |
'...' | Character literal |
b'...' | ASCII byte literal |
|...| expr | Closure |
! | Always empty bottom type for diverging functions |
_ | “Ignored” pattern binding; also used to make integer literals readable |
Table B-3 shows symbols that appear in the context of a path through the module hierarchy to an item.
Table B-3: Path-Related Syntax
Symbol | Explanation |
---|---|
ident::ident | Namespace path |
::path | Path relative to the crate root (i.e., an explicitly absolute path) |
self::path | Path relative to the current module (i.e., an explicitly relative path). |
super::path | Path relative to the parent of the current module |
type::ident , <type as trait>::ident | Associated constants, functions, and types |
<type>::... | Associated item for a type that cannot be directly named (e.g., <&T>::... , <[T]>::... , etc.) |
trait::method(...) | Disambiguating a method call by naming the trait that defines it |
type::method(...) | Disambiguating a method call by naming the type for which it’s defined |
<type as trait>::method(...) | Disambiguating a method call by naming the trait and type |
Table B-4 shows symbols that appear in the context of using generic type parameters.
Table B-4: Generics
Symbol | Explanation |
---|---|
path<...> | Specifies parameters to generic type in a type (e.g., Vec<u8> ) |
path::<...> , method::<...> | Specifies parameters to generic type, function, or method in an expression; often referred to as turbofish (e.g., "42".parse::<i32>() ) |
fn ident<...> ... | Define generic function |
struct ident<...> ... | Define generic structure |
enum ident<...> ... | Define generic enumeration |
impl<...> ... | Define generic implementation |
for<...> type | Higher-ranked lifetime bounds |
type<ident=type> | A generic type where one or more associated types have specific assignments (e.g., Iterator<Item=T> ) |
Table B-5 shows symbols that appear in the context of constraining generic type parameters with trait bounds.
Table B-5: Trait Bound Constraints
Symbol | Explanation |
---|---|
T: U | Generic parameter T constrained to types that implement U |
T: 'a | Generic type T must outlive lifetime 'a (meaning the type cannot transitively contain any references with lifetimes shorter than 'a ) |
T: 'static | Generic type T contains no borrowed references other than 'static ones |
'b: 'a | Generic lifetime 'b must outlive lifetime 'a |
T: ?Sized | Allow generic type parameter to be a dynamically sized type |
'a + trait , trait + trait | Compound type constraint |
Table B-6 shows symbols that appear in the context of calling or defining macros and specifying attributes on an item.
Table B-6: Macros and Attributes
Symbol | Explanation |
---|---|
#[meta] | Outer attribute |
#![meta] | Inner attribute |
$ident | Macro substitution |
$ident:kind | Macro capture |
$(…)… | Macro repetition |
ident!(...) , ident!{...} , ident![...] | Macro invocation |
Table B-7 shows symbols that create comments.
Table B-7: Comments
Symbol | Explanation |
---|---|
// | Line comment |
//! | Inner line doc comment |
/// | Outer line doc comment |
/*...*/ | Block comment |
/*!...*/ | Inner block doc comment |
/**...*/ | Outer block doc comment |
Table B-8 shows symbols that appear in the context of using tuples.
Table B-8: Tuples
Symbol | Explanation |
---|---|
() | Empty tuple (aka unit), both literal and type |
(expr) | Parenthesized expression |
(expr,) | Single-element tuple expression |
(type,) | Single-element tuple type |
(expr, ...) | Tuple expression |
(type, ...) | Tuple type |
expr(expr, ...) | Function call expression; also used to initialize tuple struct s and tuple enum variants |
expr.0 , expr.1 , etc. | Tuple indexing |
Table B-9 shows the contexts in which curly braces are used.
Table B-9: Curly Brackets
Context | Explanation |
---|---|
{...} | Block expression |
Type {...} | struct literal |
Table B-10 shows the contexts in which square brackets are used.
Table B-10: Square Brackets
Context | Explanation |
---|---|
[...] | Array literal |
[expr; len] | Array literal containing len copies of expr |
[type; len] | Array type containing len instances of type |
expr[expr] | Collection indexing. Overloadable (Index , IndexMut ) |
expr[..] , expr[a..] , expr[..b] , expr[a..b] | Collection indexing pretending to be collection slicing, using Range , RangeFrom , RangeTo , or RangeFull as the “index” |
Appendix C: Derivable Traits
In various places in the book, we’ve discussed the derive
attribute, which
you can apply to a struct or enum definition. The derive
attribute generates
code that will implement a trait with its own default implementation on the
type you’ve annotated with the derive
syntax.
In this appendix, we provide a reference of all the traits in the standard
library that you can use with derive
. Each section covers:
- What operators and methods deriving this trait will enable
- What the implementation of the trait provided by
derive
does - What implementing the trait signifies about the type
- The conditions in which you’re allowed or not allowed to implement the trait
- Examples of operations that require the trait
If you want different behavior from that provided by the derive
attribute,
consult the standard library documentation
for each trait for details of how to manually implement them.
The rest of the traits defined in the standard library can’t be implemented on
your types using derive
. These traits don’t have sensible default behavior,
so it’s up to you to implement them in the way that makes sense for what you’re
trying to accomplish.
An example of a trait that can’t be derived is Display
, which handles
formatting for end users. You should always consider the appropriate way to
display a type to an end user. What parts of the type should an end user be
allowed to see? What parts would they find relevant? What format of the data
would be most relevant to them? The Rust compiler doesn’t have this insight, so
it can’t provide appropriate default behavior for you.
The list of derivable traits provided in this appendix is not comprehensive:
libraries can implement derive
for their own traits, making the list of
traits you can use derive
with truly open-ended. Implementing derive
involves using a procedural macro, which is covered in the
“Macros” section of Chapter 19.
Debug
for Programmer Output
The Debug
trait enables debug formatting in format strings, which you
indicate by adding :?
within {}
placeholders.
The Debug
trait allows you to print instances of a type for debugging
purposes, so you and other programmers using your type can inspect an instance
at a particular point in a program’s execution.
The Debug
trait is required, for example, in use of the assert_eq!
macro.
This macro prints the values of instances given as arguments if the equality
assertion fails so programmers can see why the two instances weren’t equal.
PartialEq
and Eq
for Equality Comparisons
The PartialEq
trait allows you to compare instances of a type to check for
equality and enables use of the ==
and !=
operators.
Deriving PartialEq
implements the eq
method. When PartialEq
is derived on
structs, two instances are equal only if all fields are equal, and the
instances are not equal if any fields are not equal. When derived on enums,
each variant is equal to itself and not equal to the other variants.
The PartialEq
trait is required, for example, with the use of the
assert_eq!
macro, which needs to be able to compare two instances of a type
for equality.
The Eq
trait has no methods. Its purpose is to signal that for every value of
the annotated type, the value is equal to itself. The Eq
trait can only be
applied to types that also implement PartialEq
, although not all types that
implement PartialEq
can implement Eq
. One example of this is floating point
number types: the implementation of floating point numbers states that two
instances of the not-a-number (NaN
) value are not equal to each other.
An example of when Eq
is required is for keys in a HashMap<K, V>
so the
HashMap<K, V>
can tell whether two keys are the same.
PartialOrd
and Ord
for Ordering Comparisons
The PartialOrd
trait allows you to compare instances of a type for sorting
purposes. A type that implements PartialOrd
can be used with the <
, >
,
<=
, and >=
operators. You can only apply the PartialOrd
trait to types
that also implement PartialEq
.
Deriving PartialOrd
implements the partial_cmp
method, which returns an
Option<Ordering>
that will be None
when the values given don’t produce an
ordering. An example of a value that doesn’t produce an ordering, even though
most values of that type can be compared, is the not-a-number (NaN
) floating
point value. Calling partial_cmp
with any floating point number and the NaN
floating point value will return None
.
When derived on structs, PartialOrd
compares two instances by comparing the
value in each field in the order in which the fields appear in the struct
definition. When derived on enums, variants of the enum declared earlier in the
enum definition are considered less than the variants listed later.
The PartialOrd
trait is required, for example, for the gen_range
method
from the rand
crate that generates a random value in the range specified by a
range expression.
The Ord
trait allows you to know that for any two values of the annotated
type, a valid ordering will exist. The Ord
trait implements the cmp
method,
which returns an Ordering
rather than an Option<Ordering>
because a valid
ordering will always be possible. You can only apply the Ord
trait to types
that also implement PartialOrd
and Eq
(and Eq
requires PartialEq
). When
derived on structs and enums, cmp
behaves the same way as the derived
implementation for partial_cmp
does with PartialOrd
.
An example of when Ord
is required is when storing values in a BTreeSet<T>
,
a data structure that stores data based on the sort order of the values.
Clone
and Copy
for Duplicating Values
The Clone
trait allows you to explicitly create a deep copy of a value, and
the duplication process might involve running arbitrary code and copying heap
data. See the “Ways Variables and Data Interact:
Clone” section in
Chapter 4 for more information on Clone
.
Deriving Clone
implements the clone
method, which when implemented for the
whole type, calls clone
on each of the parts of the type. This means all the
fields or values in the type must also implement Clone
to derive Clone
.
An example of when Clone
is required is when calling the to_vec
method on a
slice. The slice doesn’t own the type instances it contains, but the vector
returned from to_vec
will need to own its instances, so to_vec
calls
clone
on each item. Thus, the type stored in the slice must implement Clone
.
The Copy
trait allows you to duplicate a value by only copying bits stored on
the stack; no arbitrary code is necessary. See the “Stack-Only Data:
Copy” section in Chapter 4 for more
information on Copy
.
The Copy
trait doesn’t define any methods to prevent programmers from
overloading those methods and violating the assumption that no arbitrary code
is being run. That way, all programmers can assume that copying a value will be
very fast.
You can derive Copy
on any type whose parts all implement Copy
. A type that
implements Copy
must also implement Clone
, because a type that implements
Copy
has a trivial implementation of Clone
that performs the same task as
Copy
.
The Copy
trait is rarely required; types that implement Copy
have
optimizations available, meaning you don’t have to call clone
, which makes
the code more concise.
Everything possible with Copy
you can also accomplish with Clone
, but the
code might be slower or have to use clone
in places.
Hash
for Mapping a Value to a Value of Fixed Size
The Hash
trait allows you to take an instance of a type of arbitrary size and
map that instance to a value of fixed size using a hash function. Deriving
Hash
implements the hash
method. The derived implementation of the hash
method combines the result of calling hash
on each of the parts of the type,
meaning all fields or values must also implement Hash
to derive Hash
.
An example of when Hash
is required is in storing keys in a HashMap<K, V>
to store data efficiently.
Default
for Default Values
The Default
trait allows you to create a default value for a type. Deriving
Default
implements the default
function. The derived implementation of the
default
function calls the default
function on each part of the type,
meaning all fields or values in the type must also implement Default
to
derive Default
.
The Default::default
function is commonly used in combination with the struct
update syntax discussed in the “Creating Instances From Other Instances With
Struct Update
Syntax”
section in Chapter 5. You can customize a few fields of a struct and then
set and use a default value for the rest of the fields by using
..Default::default()
.
The Default
trait is required when you use the method unwrap_or_default
on
Option<T>
instances, for example. If the Option<T>
is None
, the method
unwrap_or_default
will return the result of Default::default
for the type
T
stored in the Option<T>
.
Appendix D - Useful Development Tools
In this appendix, we talk about some useful development tools that the Rust project provides. We’ll look at automatic formatting, quick ways to apply warning fixes, a linter, and integrating with IDEs.
Automatic Formatting with rustfmt
The rustfmt
tool reformats your code according to the community code style.
Many collaborative projects use rustfmt
to prevent arguments about which
style to use when writing Rust: everyone formats their code using the tool.
To install rustfmt
, enter the following:
$ rustup component add rustfmt
This command gives you rustfmt
and cargo-fmt
, similar to how Rust gives you
both rustc
and cargo
. To format any Cargo project, enter the following:
$ cargo fmt
Running this command reformats all the Rust code in the current crate. This
should only change the code style, not the code semantics. For more information
on rustfmt
, see its documentation.
Fix Your Code with rustfix
The rustfix tool is included with Rust installations and can automatically fix some compiler warnings. If you’ve written code in Rust, you’ve probably seen compiler warnings. For example, consider this code:
Filename: src/main.rs
fn do_something() {} fn main() { for i in 0..100 { do_something(); } }
Here, we’re calling the do_something
function 100 times, but we never use the
variable i
in the body of the for
loop. Rust warns us about that:
$ cargo build
Compiling myprogram v0.1.0 (file:///projects/myprogram)
warning: unused variable: `i`
--> src/main.rs:4:9
|
4 | for i in 0..100 {
| ^ help: consider using `_i` instead
|
= note: #[warn(unused_variables)] on by default
Finished dev [unoptimized + debuginfo] target(s) in 0.50s
The warning suggests that we use _i
as a name instead: the underscore
indicates that we intend for this variable to be unused. We can automatically
apply that suggestion using the rustfix
tool by running the command cargo fix
:
$ cargo fix
Checking myprogram v0.1.0 (file:///projects/myprogram)
Fixing src/main.rs (1 fix)
Finished dev [unoptimized + debuginfo] target(s) in 0.59s
When we look at src/main.rs again, we’ll see that cargo fix
has changed the
code:
Filename: src/main.rs
fn do_something() {} fn main() { for _i in 0..100 { do_something(); } }
The for
loop variable is now named _i
, and the warning no longer appears.
You can also use the cargo fix
command to transition your code between
different Rust editions. Editions are covered in Appendix E.
More Lints with Clippy
The Clippy tool is a collection of lints to analyze your code so you can catch common mistakes and improve your Rust code.
To install Clippy, enter the following:
$ rustup component add clippy
To run Clippy’s lints on any Cargo project, enter the following:
$ cargo clippy
For example, say you write a program that uses an approximation of a mathematical constant, such as pi, as this program does:
Filename: src/main.rs
fn main() { let x = 3.1415; let r = 8.0; println!("the area of the circle is {}", x * r * r); }
Running cargo clippy
on this project results in this error:
error: approximate value of `f{32, 64}::consts::PI` found. Consider using it directly
--> src/main.rs:2:13
|
2 | let x = 3.1415;
| ^^^^^^
|
= note: #[deny(clippy::approx_constant)] on by default
= help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/master/index.html#approx_constant
This error lets you know that Rust has this constant defined more precisely and
that your program would be more correct if you used the constant instead. You
would then change your code to use the PI
constant. The following code
doesn’t result in any errors or warnings from Clippy:
Filename: src/main.rs
fn main() { let x = std::f64::consts::PI; let r = 8.0; println!("the area of the circle is {}", x * r * r); }
For more information on Clippy, see its documentation.
IDE Integration Using rust-analyzer
To help IDE integration, the Rust community recommends using
rust-analyzer
. This tool is a set of compiler-centric
utilities that speaks the Language Server Protocol, which is a
specification for IDEs and programming languages to communicate with each
other. Different clients can use rust-analyzer
, such as the Rust analyzer
plug-in for Visual Studio Code.
Visit the rust-analyzer
project’s home page for installation
instructions, then install the language server support in your particular IDE.
Your IDE will gain abilities such as autocompletion, jump to definition, and
inline errors.
For more information on rust-analyzer
, see its
documentation.
Appendix E - Editions
In Chapter 1, you saw that cargo new
adds a bit of metadata to your
Cargo.toml file about an edition. This appendix talks about what that means!
The Rust language and compiler have a six-week release cycle, meaning users get a constant stream of new features. Other programming languages release larger changes less often; Rust releases smaller updates more frequently. After a while, all of these tiny changes add up. But from release to release, it can be difficult to look back and say, “Wow, between Rust 1.10 and Rust 1.31, Rust has changed a lot!”
Every two or three years, the Rust team produces a new Rust edition. Each edition brings together the features that have landed into a clear package with fully updated documentation and tooling. New editions ship as part of the usual six-week release process.
Editions serve different purposes for different people:
- For active Rust users, a new edition brings together incremental changes into an easy-to-understand package.
- For non-users, a new edition signals that some major advancements have landed, which might make Rust worth another look.
- For those developing Rust, a new edition provides a rallying point for the project as a whole.
At the time of this writing, three Rust editions are available: Rust 2015, Rust 2018, and Rust 2021. This book is written using Rust 2021 edition idioms.
The edition
key in Cargo.toml indicates which edition the compiler should
use for your code. If the key doesn’t exist, Rust uses 2015
as the edition
value for backward compatibility reasons.
Each project can opt in to an edition other than the default 2015 edition. Editions can contain incompatible changes, such as including a new keyword that conflicts with identifiers in code. However, unless you opt in to those changes, your code will continue to compile even as you upgrade the Rust compiler version you use.
All Rust compiler versions support any edition that existed prior to that compiler’s release, and they can link crates of any supported editions together. Edition changes only affect the way the compiler initially parses code. Therefore, if you’re using Rust 2015 and one of your dependencies uses Rust 2018, your project will compile and be able to use that dependency. The opposite situation, where your project uses Rust 2018 and a dependency uses Rust 2015, works as well.
To be clear: most features will be available on all editions. Developers using any Rust edition will continue to see improvements as new stable releases are made. However, in some cases, mainly when new keywords are added, some new features might only be available in later editions. You will need to switch editions if you want to take advantage of such features.
For more details, the Edition
Guide is a complete book
about editions that enumerates the differences between editions and explains
how to automatically upgrade your code to a new edition via cargo fix
.
Appendix F: Translations of the Book
For resources in languages other than English. Most are still in progress; see the Translations label to help or let us know about a new translation!
- Português (BR)
- Português (PT)
- 简体中文
- 正體中文
- Українська
- Español, alternate
- Italiano
- Русский
- 한국어
- 日本語
- Français
- Polski
- Cebuano
- Tagalog
- Esperanto
- ελληνική
- Svenska
- Farsi
- Deutsch
- Turkish, online
- हिंदी
- ไทย
- Danske
Appendix G - How Rust is Made and “Nightly Rust”
This appendix is about how Rust is made and how that affects you as a Rust developer.
Stability Without Stagnation
As a language, Rust cares a lot about the stability of your code. We want Rust to be a rock-solid foundation you can build on, and if things were constantly changing, that would be impossible. At the same time, if we can’t experiment with new features, we may not find out important flaws until after their release, when we can no longer change things.
Our solution to this problem is what we call “stability without stagnation”, and our guiding principle is this: you should never have to fear upgrading to a new version of stable Rust. Each upgrade should be painless, but should also bring you new features, fewer bugs, and faster compile times.
Choo, Choo! Release Channels and Riding the Trains
Rust development operates on a train schedule. That is, all development is
done on the master
branch of the Rust repository. Releases follow a software
release train model, which has been used by Cisco IOS and other software
projects. There are three release channels for Rust:
- Nightly
- Beta
- Stable
Most Rust developers primarily use the stable channel, but those who want to try out experimental new features may use nightly or beta.
Here’s an example of how the development and release process works: let’s
assume that the Rust team is working on the release of Rust 1.5. That release
happened in December of 2015, but it will provide us with realistic version
numbers. A new feature is added to Rust: a new commit lands on the master
branch. Each night, a new nightly version of Rust is produced. Every day is a
release day, and these releases are created by our release infrastructure
automatically. So as time passes, our releases look like this, once a night:
nightly: * - - * - - *
Every six weeks, it’s time to prepare a new release! The beta
branch of the
Rust repository branches off from the master
branch used by nightly. Now,
there are two releases:
nightly: * - - * - - *
|
beta: *
Most Rust users do not use beta releases actively, but test against beta in their CI system to help Rust discover possible regressions. In the meantime, there’s still a nightly release every night:
nightly: * - - * - - * - - * - - *
|
beta: *
Let’s say a regression is found. Good thing we had some time to test the beta
release before the regression snuck into a stable release! The fix is applied
to master
, so that nightly is fixed, and then the fix is backported to the
beta
branch, and a new release of beta is produced:
nightly: * - - * - - * - - * - - * - - *
|
beta: * - - - - - - - - *
Six weeks after the first beta was created, it’s time for a stable release! The
stable
branch is produced from the beta
branch:
nightly: * - - * - - * - - * - - * - - * - * - *
|
beta: * - - - - - - - - *
|
stable: *
Hooray! Rust 1.5 is done! However, we’ve forgotten one thing: because the six
weeks have gone by, we also need a new beta of the next version of Rust, 1.6.
So after stable
branches off of beta
, the next version of beta
branches
off of nightly
again:
nightly: * - - * - - * - - * - - * - - * - * - *
| |
beta: * - - - - - - - - * *
|
stable: *
This is called the “train model” because every six weeks, a release “leaves the station”, but still has to take a journey through the beta channel before it arrives as a stable release.
Rust releases every six weeks, like clockwork. If you know the date of one Rust release, you can know the date of the next one: it’s six weeks later. A nice aspect of having releases scheduled every six weeks is that the next train is coming soon. If a feature happens to miss a particular release, there’s no need to worry: another one is happening in a short time! This helps reduce pressure to sneak possibly unpolished features in close to the release deadline.
Thanks to this process, you can always check out the next build of Rust and
verify for yourself that it’s easy to upgrade to: if a beta release doesn’t
work as expected, you can report it to the team and get it fixed before the
next stable release happens! Breakage in a beta release is relatively rare, but
rustc
is still a piece of software, and bugs do exist.
Unstable Features
There’s one more catch with this release model: unstable features. Rust uses a
technique called “feature flags” to determine what features are enabled in a
given release. If a new feature is under active development, it lands on
master
, and therefore, in nightly, but behind a feature flag. If you, as a
user, wish to try out the work-in-progress feature, you can, but you must be
using a nightly release of Rust and annotate your source code with the
appropriate flag to opt in.
If you’re using a beta or stable release of Rust, you can’t use any feature flags. This is the key that allows us to get practical use with new features before we declare them stable forever. Those who wish to opt into the bleeding edge can do so, and those who want a rock-solid experience can stick with stable and know that their code won’t break. Stability without stagnation.
This book only contains information about stable features, as in-progress features are still changing, and surely they’ll be different between when this book was written and when they get enabled in stable builds. You can find documentation for nightly-only features online.
Rustup and the Role of Rust Nightly
Rustup makes it easy to change between different release channels of Rust, on a global or per-project basis. By default, you’ll have stable Rust installed. To install nightly, for example:
$ rustup toolchain install nightly
You can see all of the toolchains (releases of Rust and associated
components) you have installed with rustup
as well. Here’s an example on one
of your authors’ Windows computer:
> rustup toolchain list
stable-x86_64-pc-windows-msvc (default)
beta-x86_64-pc-windows-msvc
nightly-x86_64-pc-windows-msvc
As you can see, the stable toolchain is the default. Most Rust users use stable
most of the time. You might want to use stable most of the time, but use
nightly on a specific project, because you care about a cutting-edge feature.
To do so, you can use rustup override
in that project’s directory to set the
nightly toolchain as the one rustup
should use when you’re in that directory:
$ cd ~/projects/needs-nightly
$ rustup override set nightly
Now, every time you call rustc
or cargo
inside of
~/projects/needs-nightly, rustup
will make sure that you are using nightly
Rust, rather than your default of stable Rust. This comes in handy when you
have a lot of Rust projects!
The RFC Process and Teams
So how do you learn about these new features? Rust’s development model follows a Request For Comments (RFC) process. If you’d like an improvement in Rust, you can write up a proposal, called an RFC.
Anyone can write RFCs to improve Rust, and the proposals are reviewed and discussed by the Rust team, which is comprised of many topic subteams. There’s a full list of the teams on Rust’s website, which includes teams for each area of the project: language design, compiler implementation, infrastructure, documentation, and more. The appropriate team reads the proposal and the comments, writes some comments of their own, and eventually, there’s consensus to accept or reject the feature.
If the feature is accepted, an issue is opened on the Rust repository, and
someone can implement it. The person who implements it very well may not be the
person who proposed the feature in the first place! When the implementation is
ready, it lands on the master
branch behind a feature gate, as we discussed
in the “Unstable Features” section.
After some time, once Rust developers who use nightly releases have been able to try out the new feature, team members will discuss the feature, how it’s worked out on nightly, and decide if it should make it into stable Rust or not. If the decision is to move forward, the feature gate is removed, and the feature is now considered stable! It rides the trains into a new stable release of Rust.