This repository collects resources for writing clean, idiomatic Rust code. Please bring your own.
Idiomatic coding means following the conventions of a given language. It is the most concise, convenient, and common way of accomplishing a task in that language, rather than forcing it to work in a way the author is familiar with from a different language. - Adapted from Tim Mansfield
- Rust Anthology - The best short-form writing about Rust, collected.
- cheat.rs - Idiomatic Rust tips - A list of quick tips to make your code more idiomatic.
- clippy - A bunch of lints to catch common mistakes and improve your Rust code.
- Patterns - A catalogue of Rust design patterns.
- Elements of Rust - A collection of software engineering techniques for effectively expressing intent with Rust.
- Rust by Example - A community driven collection of example code which follow Rust best practices.
- Rust Cookbook - Examples that demonstrate good practices to accomplish common programming tasks in Rust.
- rust-api-guidelines - An extensive list of recommendations for idiomatic Rust APIs.
- Build your own JIRA with Rust - A test-driven workshop to learn Rust building your own JIRA clone!
- Ferrous Systems Teaching Material - Free workshop material produced by Ferrous Systems for trainings. The time for the full course is around three to four days.
- PingCAP talent plan - A series of training courses about writing distributed systems in Rust. The courses primarily consist of projects where coding problems are presented, along with a partial implementation or API description, and a test suite.
- Procedural Macros Workshop - This repo contains a selection of projects designed to learn to write Rust procedural macros — Rust code that generates Rust code.
📖 Articles and Books
- Refactoring Rust Transpiled from C by Per Larsen - Describes how to lift a C-project that was automatically converted to unsafe Rust with C2Rust to safer, more idiomatic Rust with some human intervention.
- Learning Rust through open source and live code reviews by Luciano Mammino and Stefano Abalsamo - Covers patterns like FromStr and exposing a CLI and a library in one crate.
- Guide on how to write documentation for a Rust crate - Writing good documentation with rustdoc including many examples.
- Await a minute by David Tolnay - Example code for moving from raw futures to async/await syntax to improve error handling, native control flow, and borrowing.
- Taking string arguments in Rust by @Xion - Discussing how to avoid subtle issues with string handling and when to use
str(the string slice) and
String(the owned/allocated string).
Programming an ARM microcontroller in Rust at four different levels of abstraction by Pramode C.E - Demonstrates how Rust helps to move from brittle, low-level embedded code to high-level abstractions with zero cost.
Discover the world of microcontrollers through Rust! - This book is an introductory course on microcontroller-based embedded systems that uses Rust as the teaching language rather than the usual C/C++.
- Iteration patterns for Result & Option by @Xion - Explores how to filter and partition iterators of Result and Option types idiomatically.
- Lessons learned redesigning and refactoring a Rust Library by @mgattozzi -
RefCell, the builder pattern and more.
- Math with distances in Rust: safety and correctness across units by @code-ape - How to create a system to cleanly and safely do arithmetic with lengths.
- The balance between cost, useability and soundness in C bindings, and Rust-SDL2's release by @Cobrand - Writing safe, sound, idiomatic libraries despite the limitations of the borrow checker.
- Russian Dolls and clean Rust code by @mgattozzi - How to use the full power of
- Elegant Library APIs in Rust by @killercup - Many helpful tips and tricks for writing libraries in Rust.
- Teaching libraries through good documentation by @killercup - How to use the full power of Rust's documentation support (e.g. doc tests)
- Pretty State Machine Patterns in Rust by @hoverbear - How to represent a State Machine in an expressive and understandable way in Rust.
- Ripgrep Code Review by @mbrt - An analysis of the popular
ripgreptool's source code.
- Rustic Bits by @llogiq - Small things that make for rustic code.
- Convenient and idiomatic conversions in Rust by meqif - Explains
AsMut<T>with pratical examples.
- Idiomatic tree and graph like structures in Rust by saschagrunert - Introduction to safe, dynamic, arena based tree structures without using lifetimes.
- Rust traits for developer friendly libraries by @benashford - Thoughts about implementing good Rust libraries.
- Error Handling in Rust by @BurntSushi - Understanding and handling errors in Rust in an idiomatic way.
- Creating a Rust function that accepts String or &str by @hjr - How to make calling your code both ergonomic and fast (zero-allocation).
- Creating a Rust function that returns a &str or String by @hjr - How
Cow(Clone-on-write) work together to avoid allocations for string types.
- Effectively Using Iterators In Rust by @hjr - Explanation of the
IntoItertraits and how loops actually work in Rust.
- Strategies for solving 'cannot move out of' borrowing errors in Rust by @hjr - Practical tips to help understand the borrow-checker and move semantics.
- Rayon: data parallelism in Rust by @nikomatsakis - Writing elegant parallel code in Rust.
- Which is more idiomatic? Functional, imperative or a mix?
- An idiomatic way to sum up values in a multidimensional Array
Coming from Python I loved to have some guidelines on how "idiomatic Python" looks like. I was inspired by the likes of Peter Norvig, who wrote amazing articles on spellcheckers and sudoku solvers. And, of course, the Zen of Python.
The goal of this project is to create a peer-reviewed collection of articles/talks/repos which teach idiomatic Rust style. It's a community project. If this becomes a thing I plan to move it to some "semi-official" place like rust-nursery or so. But first I need YOUR help for that ;-)