5.0 KiB
Code Examples for Programming Rust
This repository contains complete code for the larger example programs from the book “Programming Rust”, by Jim Blandy and Jason Orendorff.
Each subdirectory is a distinct Rust project, with its own Cargo.toml file. You
should be able to enter each directory and use cargo build
and cargo test
.
For those projects that define programs, cargo run
should run them.
Chapter 2: A Tour of Rust
-
The
gcd
directory holds the command-line program for computing the greatest common denominator of a list of numbers. -
The
iron-gcd
directory holds the code for the simple web service, implemented using theiron
framework, that computes greatest common denominators. -
The Mandelbrot plotting program has its own repository, at
https://github.com/ProgrammingRust/mandelbrot
. This repository contains several branches, each showing a different implementation strategy. Thesingle-threaded
branch holds the code for the single-threaded version, and thebands
branch holds the multi-threaded version. Chapter 19, “Concurrency”, shows several other approaches, which appear on other branches; see the repository's README.md file for details.
Chapter 8: Crates and Modules
- We did not actually write a fern simulator. Please accept our sincere apology
for this feckless deception. But the skeleton of modules and definitions we
show in the book is in the
fern_sim
subdirectory.
Chapter 9: Structs
-
The
queue
directory holds a library that defines theQueue
type, representing a queue ofchar
values. -
The
generic-queue
directory holds code for genericQueue
type.
Chapter 10: Enums and Patterns
- The
binary-tree
directory holds the source code for theBinaryTree
type that appears in the “Generic Enums” and “Populating a Binary Tree” sections.
Chapter 12: Operator Overloading
-
The
complex
directory holds theComplex
type used as a running example throughout the chapter. -
The
interval
directory holds theInterval
type for which the book implements thestd::cmp::PartialOrd
trait.
Chapter 14: Closures
- The 'basic-router' directory holds the
BasicRouter
type used as an example in the “Callbacks” section.
Chapter 15: Iterators
- The
binary-tree
directory holds the implementation of theIterator
trait for theBinaryTree
type originally defined in the “Enums and Patterns” chapter.
Chapter 17: Strings and Text
- The
complex
directory includes the implementation of thestd::fmt::Display
formatting trait for a complex number type, shown in the section “Formatting Your Own Types”.
Chapter 18: Input and Output
-
The
grep
directory holds the simple grep-like program shown in the section “Reading Lines”. -
The
copy
directory holds the program for copying directory trees from the section “Reading Directories”, including the additions shown in the next section, “Platform-Specific Features”. -
The
echo-server
directory holds the simple network service shown in the “Networking” section. -
The
http-get
directory holds the command-line program that uses thereqwest
crate to carry out an HTTP request.
Chapter 19: Concurrency
-
The search engine used as a running example throughout the book has its own repository, at
https://github.com/ProgrammingRust/fingertips
. -
The Mandelbrot set plotter discussed in the section “Revisiting the Mandelbrot Set” also has its own repository, at
https://github.com/ProgrammingRust/mandelbrot
. The repository includes several branches exploring different implementations; see the repository's README.md file for details.
Chapter 20: Macros
- The
json-macro
directory holds the definition of thejson!
macro built in the section “The json! Macro”.
Chapter 21: Unsafe Code
-
The
ascii
directory holds theAscii
type used as an example in the sections “Unsafe Blocks” and “Unsafe Functions”. -
The
ref-with-flag
directory holds theRefWithFlag
type from the “Raw Pointers” section. -
The
gap-buffer
directory holds theGapBuffer
type, used in the “Raw Pointers” section to illustrate pointer arithmetic andstd::ptr::read
andstd::ptr::write
. -
The
libgit2-rs
andlibgit2-rs-safe
directories contain the two versions of the program that uses Rust's foreign function interface to call functions from thelibgit2
C library. The version inlibgit2-rs
is written as a single giant block of unsafe code, whereas the version inlibgit2-rs-safe
implements a safe Rust interface to the same functionality, using Rust's type system to enforce libgit2's rules for proper use of the library.Note that both of these require you to have a copy of
libgit2
present on your system. The chapter provides detailed instructions for building the correct version, for Linux, macOS, and Microsoft Windows.