Building Reusable Code with Rust

Name: Building Reusable Code with Rust
Rating: 4.4 (66 reviews)

Use generics, traits, and macros to write clean and reusable Rust libraries that are easy to understand and maintain

Created byPackt Publishing

Last updated 4/2019

English

What you'll learn

Write clean and reusable Rust code for your applications
Use loop, map, filter and fold to avoid duplicated code
Understand generics and learn to use it to abstract algorithms for multiple data types
Define and enforce clear interface using traits
Work with macros and compiler plugins for metaprogramming
Explore how the standard library uses features such as generics, traits and macros
Structure your code with modules and crates and publish them online

Course content

5 sections • 27 lectures • 1h 59m total length

The Course Overview3:10
This video provides an overview of the entire course.
Setting Up the Rust Development Environment3:45
How can we try the code examples from the course? By setting up the Rust development environment.
• Understand the options available: playground and rustup
• Learn to test simple code using the online playground
• Learn to install the toolchain locally with rustup
Exploring Code Reuse in Rust2:34
A brief overview of the code reuse mechanisms in Rust, which we'll discuss further in the course.
• Understand the considerations of code reusability
• Learn what Rust provides us for code reuse
Loops and Iterators5:40
How do we avoid repetitive code using loops and properly use iterators?
• See why for loops only accept iterators
• Learn what the IntoIterator trait has to do with the for loop
• Understand the ways to get different iterators with or without reference
Using Functional Programming Loops12:57
The aim of this video is to learn an alternative way of doing loops.
• Learn iterator adaptor and consuming adaptor
• Know when we should use functional programming loops as against for loops
• See how lazy evaluation can help you do more than a for loop
Functions in Rust3:06
How we can use one of the most common features in programming languages—functions—to avoid duplication?
• Understand the basic syntax of functions
• See how functions take typed parameters
• Learn the common mistake of moving ownership into a function

Exploring Generics2:26
How and where can generics help us to reuse code in Rust?
• Learn how generics can help us reuse high-level algorithms
• Learn how generics can help us reuse high-level data structures
• Understand where generics can be applied
Use Generic Functions to Reuse Algorithms3:49
How can we reuse an algorithm for different types? Generic functions can help us abstract away the types in a function signature.
• Understand the basic syntax of generics in functions
• Know why not all types can fit into all generic functions
• See how we can use a trait bound to restrict the types used in a generic function
Reuse Structures in Enums and Structs2:30
How to reuse common data structures for different types? With generic on structs and enums.
• Learn how generic struct can abstract away the types
• Learn how multiple generic types can be used in one struct
• Understand how the same concept can be applied to enums
Working with Generic in Struct Methods3:43
The aim of this video is to learn how struct methods can use generic just like normal functions.
• Learn the basic syntax of generic on struct methods
• Understand why we need impl<T> instead of just impl
• See how we can implement a generic struct method for only certain types
Generics in the Rust Standard Library – Part I3:45
Show how generics are used in the Rust standard library.
• See how option<T> uses generic to represent optional values
• See how result<T> uses generic to represent a success/fail result
• Know how to use option and result in error handling
Generics in the Rust Standard Library – Part II4:18
The aim of this video is to showcase how generics are used in the Rust standard library.
• See how collections like vector or hash use generics
• Learn how smart pointers and wrappers use generics
• See how we can compose wrappers using the generic syntax

Exploring Traits3:09
The aim of this video is to learn the basic syntax of trait and trait bound.
• Learn the basic syntax of trait
• See how trait can help us define interfaces
• Learn how trait bound can help us enforce interfaces
Using Trait Bounds and Trait Objects to Communicate Interfaces3:41
How can we enforce and use a trait without knowing the solid type? Trait bounds and trait objects can help us here.
• See how trait bounds are used in a real-world example
• Learn the "where" form of trait bound syntax
• See how a trait object can be used instead of a solid type
Associated Types versus Generics and Trait Inheritance2:52
Using generics on traits may cause us to accidentally create multiple implementations. Associated type can guarantee that it's only implemented once.
• Understand why generics on traits may cause multiple implementations
• See how associated type solves this problem
• Learn how trait inheritance can enforce more complex trait relationships
Exploring Traits, Generics, and Performance3:30
Traits and generics have different effects on performance. Learn the difference between static dispatch and dynamic dispatch.
• Learn about static dispatch and the code bloat problem
• Learn about dynamic dispatch and its performance impact
• See how a trait object is implemented internally
Traits in the Rust Standard Library – Part I7:42
How do we do operator overloading and type conversion in Rust? The Rust standard library uses traits for this.
• See how operator overloading can be achieved by traits
• Learn how lifetime and function calls also utilize traits
• Understand how From and Into traits help us do type conversion
Traits in the Rust Standard Library – Part II6:21
How to tell the compiler that our custom type has a special property? Marker traits will help. We also talk about some useful std traits.
• Learn about marker traits and how they interact with the compiler
• Know how to define custom formatting with Display and Debug
• Learn how a default trait can be useful in defining defaults

Write Code with Code – Metaprogramming in Rust2:28
Learn what metaprogramming is and the tools available in Rust.
• Learn what metaprogramming is
• Understand the options for metaprogramming in Rust
• Know when to use metaprogramming
Use Declarative Macros to Write Less Code4:05
Some code repetition is not possible to eliminate by the language itself. We can use declarative macros to abstract away that.
• Understand the syntax for defining declarative macros
• See a real-world example of vec!()
• Learn about the namespace for macro and why we need macro_use
Using Procedural Macros for Custom Derive4:37
Implementing repetitive traits is cumbersome. Using procedural macros, we can create custom derive rules to reduce clutter.
• Learn how custom derive works
• Learn how we organize the folder structure for custom derive code
• Understand how we use proc_macro, syn, and quote to achieve the custom derive logic
Macros in the Rust Standard Library – Part I4:55
The aim of this video is to walk through important macros in the Rust standard library.
• Briefly review what we’ve learned about derive
• Walk through macros for formatting
• Walk through macros for introspection, including files, and more
Macros in the Rust Standard Library – Part II5:37
The aim of this video is to walk through important macros in the Rust standard library.
• Walk through macros for conditional compiling
• Walk through macros for error handling
• Walk through macros that aid development like unimplemented, panic, or assert

Introducing Crates5:05
How do we create a self-contained unit of module that can be reused? Using Cargo to create crates.
• Learn how the "cargo new" command creates crates
• Learn how a binary crate is structured
• Learn how a library crate is structured
Using Modules to Define the Structure of Crates4:27
How do we create namespace in crates to convey the structure of our code? Modules are built exactly for that.
• See how module definition works in one file
• Learn how we can split modules into files and folders
• Understand how the "pub" keyword controls the accessibility of modules
Using a Crate with Cargo.toml6:06
How do we reuse the modules we created or other people created? We can specify the dependency in Cargo.toml.
• Learn how Cargo.toml works
• How to use third-party or local crates
• How to include the crate in the code with "extern crate" and "use"
Publishing to crates.io2:47
How do we publish our crate to the world? We need to put them on crates.io.
• Understand what crates.io is
• Understand the requirement for your crate to be published
• Demonstrate the procedure of publishing to crates.io

Requirements

Basic knowledge of Rust programing is required.

Description

Rust is the ideal language for writing safe, correct code in a way that won't make you pull your hair out. This course will teach you how to build reusable Rust code so that you can stop copying and pasting code. Write code that can adapt to many different usages.

You will reuse code by using advanced features such as traits, generics and macros. You will work with different forms of code reuse, loops, map, filter and fold to save time and resources. Achieve higher-level reuse without sacrificing runtime performance. Organize your code into modules and crates to publish them to crates. io.

By the end of the course you will be able to avoid code duplication and write clean reusable code.

About the Author

Shing Lyu is a software engineer and open-source promoter. Shing contributed to Mozilla's Servo and Gecko (Firefox) browser engines using Rust, and is active in Rust study groups, training, and conference talks. Shing is passionate about coding, automated testing, and promoting free and open-source software craftsmanship.

Who this course is for:

This course will appeal to Rust developers who are already familiar with the language and want to learn how to build Rust libraries that are maintainable and reusable, and have an API that honors Rust conventions.

Building Reusable Code with Rust

What you'll learn

Explore related topics

Course content

Basics of Code Reuse6 lectures • 31min

Using Generics in Rust6 lectures • 21min

Defining Interfaces with Traits6 lectures • 27min

Hacking the Language with Macros and Compiler Plugins5 lectures • 22min

Reusing the Code with Other People Using Modules and Crates4 lectures • 18min

Requirements

Description

Who this course is for: