Chapter 3: Introduction to the Rust Standard Library

In the previous chapter, we built a command-line tool using various Rust language primitives and modules from the Rust Standard Library. However, in order to fully exploit the power of Rust, it is imperative to understand the breadth of what features are available within the standard library for system programming tasks, without having to reach out to third-party crates.

In this chapter, we'll deep-dive into the structure of the Rust Standard Library. You'll get an introduction to the standard modules for accessing system resources and learn how to manage them programmatically. With the knowledge gained, we will implement a tiny portion of a template engine in Rust. By the end of this chapter, you will be able to confidently navigate the Rust Standard Library and make use of it in your projects.

The following are the key learning outcomes for this chapter:

• Introducing the Rust Standard Library
• Writing...

Technical requirements

Rustup and Cargo must be installed in your local development environment. The GitHub repository for the examples in this chapter can be found at https://github.com/PacktPublishing/Practical-System-Programming-for-Rust-Developers/tree/master/Chapter03.

The Rust Standard Library and systems programming

Before we dive into the standard library, let's understand the context of how it fits into systems programming.

In systems programming, one of the cardinal requirements is to manage system resources such as memory, files, network I/O, devices, and processes. Every operating system has a kernel (or equivalent), which is the central software module that is loaded in memory and connects the system hardware with the application processes. You may think, where does the Rust Standard Library fit in then? Are we going to write a kernel in Rust? No, that's not the purpose of this book. The most popular operating systems, which are basically the Unix, Linux, and Windows variants, all have kernels written mostly in C with a mix of assembly. It is still early days for Rust to augment C as the kernel development language, though there are several experimental efforts in that direction. However, what the Rust Standard Library offers...

Exploring the Rust Standard Library

We earlier discussed the role of the Rust Standard Library in enabling user programs to invoke kernel operations. The following are some of the notable features of the standard library, which we will refer to as std for brevity:

• std is cross-platform. It provides functionality that hides the differences among underlying platform architectures.
• std is available to all Rust crates by default. The use statement gives access to the respective modules and their constituents (traits, methods, structs, and so on). For example, the statement use std::fs gives access to the module providing file manipulation operations.
• std includes operations on standard Rust primitives (such as integers and floating-point numbers). For example, std::i8::MAX is a constant implemented in the standard library that specifies the maximum value that can be stored in a variable of type i8.
• It implements core data types such as vector, strings, and smart pointers...

Building a template engine

In this section, we will look at the design of an HTML template engine and implement one of the features using the Rust Standard Library. Let's first understand what a template engine is.

Applications such as web and mobile apps use structured data stored in datastores such as relational databases, NoSQL databases, and key-value stores. However, there is a lot of data on the web that is unstructured. One particular example is text data that all web pages contain. Web pages are generated as HTML files that have a text-based format.

On observing closely, we can see that an HTML page has two parts: static text literals and dynamic parts. The HTML page is authored as a template with the static and dynamic parts, and the context for HTML generation comes from a data source. While generating a web page, the generator should take the static text and output it without change, while it should combine some processing and the supplied context to generate...

Summary

In this chapter, we reviewed the overall structure of the Rust Standard Library and classified the modules of the standard library into different categories for better understanding. You got a brief introduction to the modules in areas of concurrency, memory management, file system operations, data processing, data types, error handling, compiler-related, FFI, networking, I/O, OS-specific, and time-related features.

We looked at what a template engine is, how it works, and defined the scope and requirements of our project. We designed the template engine in terms of Rust data structures (enum and struct) and Rust functions. We saw how to write code for parsing templates and to generate HTML for statements involving template variables. We executed the program providing input data and verified the generated HTML in the terminal (command line).

In the next chapter, we will take a closer look at the Rust Standard Library modules that deal with managing process environment...

Further reading

• Django template language: https://docs.djangoproject.com/en/3.0/ref/templates/language/
• Rust Standard Library: https://doc.rust-lang.org/std/index.html