Rust: Building Reusable Code with Rust from Scratch

Description

In this course, you will :

• Discover the advantages of the Rust up toolchain manager and the Cargo build tool
• Prevent data races and memory corruption by controlling exclusive versus shared access
• Build powerful abstractions with traits and bounded generics
• Create concise pipelines with closures and iterators
• Understand generics and learn to use it to abstract algorithms for multiple data types
• Define and enforce clear interface using traits
• Explore how the standard library uses features such as generics, traits, and macros
• Structure your code with modules and crates and publish them online

Syllabus :

1. Learning Rust

• Bindings and Mutability
• Built-In Types
• Imports and Namespaces
• The Standard Library
• Recursive Fibonacci
• Dynamic Fibonacci
• Installing Rust with Rustup
• Managing Toolchains with Rustup
• Creating Projects with Cargo
• Exploring the Crate Ecosystem
• Rustdoc and the Documentation Ecosystem
• Adding Dependencies with Cargo
• Motivation for the Borrow Checker
• Ownership, Borrowing, and RAII
• Shared and Exclusive Access
• Fighting with the Borrow Checker
• Strings, Strs, Vecs, and Slices
• Understanding Borrow Checker Errors
• Structured Data
• Enumerations
• Match Expressions
• Designing a Markup Language
• Implementing the Markup Language
• Introduction to Traits
• Built-In Traits
• Writing Your Own Traits
• Generic Functions
• Generic Types
• Trait Objects and Dynamic Dispatch
• Closures
• Iterators
• Map, Filter, and Fold
• Building a Barycenter Finder
• Parallelizing the Barycenter Finder
• Breaking Up Code with Modules
• Error Handling
• API Design
• Unit Testing
• Integration Testing
• Documentation

2. Building Reusable Code with Rust

• Setting Up the Rust Development Environment
• Exploring Code Reuse in Rust
• Loops and Iterators
• Using Functional Programming Loops
• Functions in Rust
• Exploring Generics
• Use Generic Functions to Reuse Algorithms
• Reuse Structures in Enums and Structs
• Working with Generic in Struct Methods
• Generics in the Rust Standard Library
• Exploring Traits
• Using Trait Bounds and Trait Objects to Communicate Interfaces
• Associated Types versus Generics and Trait Inheritance
• Exploring Traits, Generics, and Performance
• Traits in the Rust Standard Library
• Write Code with Code – Metaprogramming in Rust
• Use Declarative Macros to Write Less Code
• Using Procedural Macros for Custom Derive
• Macros in the Rust Standard Library
• Introducing Crates
• Using Modules to Define the Structure of Crates
• Using a Crate with Cargo.toml
• Publishing to crates.io