Search icon CANCEL
Subscription
0
Cart icon
Cart
Close icon
You have no products in your basket yet
Save more on your purchases!
Savings automatically calculated. No voucher code required
Arrow left icon
All Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletters
Free Learning
Arrow right icon
Learning Rust
Learning Rust

Learning Rust: A comprehensive guide to writing Rust applications

By Vesa Kaihlavirta
$39.99 $27.98
Book Nov 2017 308 pages 1st Edition
eBook
$39.99 $27.98
Print
$48.99
Subscription
Free Trial
Renews at $15.99p/m
eBook
$39.99 $27.98
Print
$48.99
Subscription
Free Trial
Renews at $15.99p/m

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Table of content icon View table of contents Preview book icon Preview Book

Learning Rust

Chapter 1. Introducing and Installing Rust

Rust is a fairly new addition to the ever-growing number of programming languages available to developers. If you've never used Rust, but come from pretty much any procedural language (such as C or Pascal) or are used to shell scripting, then you should very quickly feel right at home when using Rust.

Getting to grips with Rust is simple enough, and in this chapter we will cover the following topics:

  • Installing Rust with rustup
  • Testing the installation
  • Setting up a project
  • Looking at the IDEs available
  • Automation using Cargo

Installing Rust


As with most languages, Rust is available for a wide number of platforms. It would be impossible to go through installing the compiler on every variant of every operating system. Fortunately, there's an official method of installing Rust, and even though the details may differ slightly, the process is almost the same on all platforms. Therefore, this book will cover installing Rust using rustup on Fedora 27.

https://rustup.rs always contains up-to-date instructions on how to get going on all platforms. On Linux and macOS, it will look something like this:

On Windows, this text is replaced by a link to rustup-init.exe, which is an executable that installs and sets up rustup on Windows.

Installing rustup on Linux

Run the suggested command that is shown at https://rustup.rs. Run this command in a Terminal. The script suggests some defaults and asks you to confirm them. This is roughly what it should look like after completing the whole script:

Note that this script attempts to set up rustup for your user by editing your .profile and .bash_profile files. If you are using a custom setup, such as another shell, you may need to add the source $HOME/.cargo/env command manually.

After finishing this script, you can verify that it worked by logging off and on from your Terminal and verifying that the tools are in your path:

gcc prerequisites

To build any software that links against external libraries, you will need a C compiler and development versions of any libraries you may be linking against. To ensure that things work properly, install the compiler using the standard method for your operating system.

In Fedora, this would be done using the dnf tool:

sudo dnf install -y gcc

If you are unsure whether you have gcc installed, type the following command in a terminal window:

gcc -version

If gcc is installed, you'll see something like this:

Testing your installation

Open a command-prompt window and type this:

rustc --version

If everything was installed correctly, you will see something like this:

Integrated Development Environment

To effectively code Rust, you will need at least some sort of text editor. All popular editors are properly supported, so if your favorite is Vim, Emacs, or any of the others, you will find a high-quality Rust extension there. The website https://areweideyet.com/ should give a current view of how things are.

We will cover the lightweight IDE from Microsoft, Visual Studio Code, and its most current Rust extension, called simply Rust. This IDE should work fairly well in all the different desktop environments. Installation instructions and packages for several platforms are available at Visual Studio Code's main site, https://code.visualstudio.com.

  1. Open up Visual Studio Code and go to the Command Palette, either by the View menu or by the keyboard shortcut Ctrl + Shift + P (which may differ between platforms). Type in install extension to look for the proper command, and then select Install Extensions:
  1. After selecting this, type rust into the next field to look for the Rust extension. At the time of writing, the most recent one is made by kalitaalexey:
  1. You can install Rust right away by pressing Install; alternatively, click on the list item itself to show information about the extension first. After installing it, reload the editor. The Rust extension is now installed and ready to use!

Your first Rust project


Your first Rust project is not going to be particularly amazing. If anything, it's going to serve four purposes:

  • Showing the structure of a Rust project
  • Showing how to create a project by hand
  • Showing how to create a project using the Rust Cargo script
  • Compiling and executing the program

Structure of a Rust project

A Rust project (irrespective of the platform you are developing on) will have the following structure:

The preceding screenshot shows the structure of the simplest Rust project, and as such can be replicated using the following commands:

OS X/Linux

Windows (from the command prompt)

mkdir firstproject cd firstproject touch Cargo.toml mkdir src cd src touch main.rs
md firstproject cd firstproject md src echo $null >> Cargo.toml cd src echo $null >> main.rs

Note

The echo $null >> filename command creates an empty file without the need to start Notepad; save the file and exit.

The Cargo.toml file is the Rust equivalent of a Makefile. When the .toml file is created by hand, it should be edited to contain something like this:

The structure of a Rust project can expand to include documentation as well as the build structure, as follows:

Automating things

While there is nothing wrong with creating a Rust project by hand, Rust does come with a very handy utility called Cargo. Cargo can be used not only to automate the setting up of a project, but also to compile and execute Rust code. Cargo can be used to create the parts required for a library instead of an executable, and can also generate application documentation.

Creating a binary package using Cargo

As with any other script, Cargo works (by default) on the current working directory. (For example, while writing this chapter, my working directory for the example code is ~/Developer/Rust/chapter0 on the Mac and Linux boxes, and J:\Developer\Rust\Chapter0 on the Windows 10 machine.)

In its simplest form, Cargo can generate the correct file structure like this:

cargo new demo_app_name -bin

The preceding command tells Cargo to create a new structure called demo_app_name, and that it is to be a binary. If you remove -bin, it creates a structure called, which is going to be a library (or more accurately, something other than a binary).

If you don't wish to use the root (say you want to create a library within your binary framework), then instead of demo_app_name, you append the structure before the name relating to your working directory.

In the small example I gave earlier, if I wanted to create a library within my binary structure, I would use the following:

cargo new app_name/mylib

That will create a structure like this:

The Cargo.toml file requires no editing (at this stage), as it contains the information we had to enter manually when we created the project by hand.

Note

Cargo has a number of directory separator translators. This means that the preceding example can be used on OS X, Linux, and Windows without an issue; Cargo has converted the / to \ for Windows.

Using Cargo to build and run an application

As we are all able to create directory structures, Cargo is then able to build and execute our source code.

If you look at the source code that comes with this chapter, you will find a directory called app_name. To build this package using Cargo, type the following from a Terminal (or command on Windows) window:

cd app_name cargo build app_name

This will build the source code; finally you will be informed that the compilation has been successful:

Next, we can use Cargo to execute the binary as follows:

cargo run

If everything has worked, you will see something like the following:

As with any sort of utility, it's possible to "daisy-chain" the build and execution into one line, as follows:

cargo build; cargo run

Note

You may be wondering why the first operation performed was to move into the application structure rather than just type cargo build. This is because Cargo is looking for the Cargo.toml file (remember, this acts as a build script).

Cleaning your source tree with Cargo

When the Rust compiler compiles the source files, it generates something known as an object file. The object file takes the source file (which we can read and understand) and compiles this into a form that can be joined with other libraries to create a binary.

This is a good idea, as it cuts down on compilation time; if a source file has not been changed, there is no need to recompile the file, as the object file will be the same.

Sometimes, the object file becomes out of date, or code in another object file causes a panic due to conflicts. In this case, it is not uncommon to "clean" the build. This removes the object files, and the compiler then has to recompile all the source files.

Also, it should always be performed prior to creating a release build.

The standard Unix make program performs this with the clean command (make clean). Cargo performs the clean operation in a way similar to the make utility in Unix:

cargo clean

A comparison of the directories shows what happens when using the preceding Cargo command:

The entire target directory structure has simply been removed (the preceding screenshot was from a Mac, hence the dSYM and plist files. These do not exist on Linux and Windows).

Creating documentation using Cargo

As with other languages, Rust is able to create documentation based on meta tags with the source files. Take the following example:

fn main() 
{ 
   print_multiply(4, 5); 
} 
 
/// A simple function example 
/// 
/// # Examples 
/// 
/// ``` 
/// print_multiply(3, 5); 
///  
/// ``` 
 
fn print_multiply(x: i32, y: i32) 
{ 
   println!("x * y = {}", x * y); 
} 

The comments preceded by /// will be converted into documentation.

The documentation can be created in one of two ways: via Cargo or by using the rustdoc program.

rustdoc versus Cargo

As with the other operations provided by Cargo, when documentation is created, it acts as a wrapper for rustdoc. The only difference is that with rustdoc you have to specify the directory that the source file sits in. Cargo acts dumb in this case, and creates the documentation for all source files.

In its simplest form, the rustdoc command is used as follows:

cargo docrustdoc src/main.rs

Cargo does have the advantage of creating the doc structure within the root folder, whereas rustdoc creates the structure within the target (which is removed with cargo clean).

Using Cargo to help with your unit testing

Hopefully, unit testing is not something you will be unfamiliar with. A unit test is a test that operates on a specific function or method rather than an entire class or namespace. It ensures that the function operates correctly on the data it is presented with.

Unit tests within Rust are very simple to create (two examples are given in the assert_unittest and unittest directories). The following has been taken from the unittest example:

fn main() { 
    println!("Tests have not been compiled, use rustc --test instead (or cargo test)"); 
} 
 
#[test] 
fn multiply_test() 
{ 
   if 2 * 3 == 5 
   { 
      println!("The multiply worked"); 
   } 
} 

When this is built and executed, you may be surprised by the following result:

Note

The reason why this unit test has passed despite 2 x 3 not being 5 is because the unit test is not testing the result of the operation, but that the operation itself is working. It is very important that this distinction is understood from an early stage to prevent confusion later.

We have hit a limitation of unit testing: if we are not testing the data but the operation, how can we know that the result itself is correct?

Assert yourself!

Unit testing provides the developer with a number of methods called assertion methods:

#[test] 
fn multiply() 
{ 
   assert_eq!(5, 2 * 3); 
} 

In the preceding code snippet, we use the assert_eq! (assert equal) macro. The first argument is the answer expected, and the second argument is what is being tested. If 2 * 3 = 5, then the assertion is true and passes the unit test.

Is there anything Cargo can't do?

For a Rust developer, Cargo is an amazing utility. In addition to these common facilities, it also has other commands, which are listed in the table that follows. All commands follow this form:

cargo <command> <opts>

Command

What it does

fetch

This command fetches the dependencies of a package from the network. If a lockfile is available, this command will ensure that all of the Git dependencies and/or registry dependencies are downloaded and locally available. The network is never called after a cargo fetch unless the lockfile changes.

If the lockfile is not available, then this is the equivalent of cargo generate-lockfile. A lockfile is generated and all the dependencies are also updated.

generate-lockfile

This command generates the lockfile for a project. The lockfile is typically generated when cargo build is issued (you will see it as Cargo.lockfile in the directory structure).

git-checkout

This command checks out a Git repository. You will need to use it in the following form:

cargo git-checkout -url=URL
locate-project

This command locates a package.

login

This command saves an API token from the registry locally. The call is in the following form:

cargo login -host=HOST   token
owner

This command manages the owners of a crate on the registry. This allows the ownership of a crate (a crate is a Rust library) to be altered (--add LOGIN or -remove LOGIN) as well as adding tokens to the crate.

This command will modify the owners for a package on the specified registry (or the default). Note that the owners of a package can upload new versions, yank old versions, and also modify the set of owners, so be cautious!

package

This command assembles the local package into a distributable tarball.

pkgid

This command prints a fully qualified package specification.

publish

This command uploads a package to the registry.

read-manifest

This command reads the manifest file (.toml).

rustc

This command compiles the complete package.

The specified target for the current package will be compiled along with all of its dependencies. The specified options will all be passed to the final compiler invocation, not any of the dependencies. Note that the compiler will still unconditionally receive arguments such as -L, --extern, and --crate-type, and the specified options will simply be added to the compiler invocation.

This command requires that only one target is being compiled. If more than one target is available for the current package, the filters --lib, --bin, and so on—must be used to select which target is compiled.

search

This command searches for packages at https://crates.io/.

update

This command updates dependencies as recorded in the local lockfile.

Typical options are:

  • --package SPEC (package to update)
  • --aggressive (forcibly update all dependencies of <name> as well)
  • --precise PRECISE (update a single dependency to exactly PRECISE)

This command requires that a Cargo.lock file already exists as generated by cargo build or related commands.

If a package spec name (SPEC) is given, then a conservative update of the lockfile will be performed. This means that only the dependency specified by SPEC will be updated. Its transitive dependencies will be updated only if SPEC cannot be updated without updating the dependencies. All other dependencies will remain locked at their currently recorded versions.

If PRECISE is specified, then --aggressive must not also be specified. The argument PRECISE is a string representing a precise revision that the package being updated should be updated to. For example, if the package comes from a Git repository, then PRECISE would be the exact revision that the repository should be updated to.

If SPEC is not given, then all the dependencies will be re-resolved and updated.

verify-project

This command ensures that the project is correctly created.

version

This command shows the version of Cargo.

yank

This command removes a pushed crate from the index.

The yank command removes a previously pushed crate version from the server's index. This command does not delete any data, and the crate will still be available for download via the registry's download link.

Note that existing crates locked to a yanked version will still be able to download the yanked version to use it. Cargo will, however, not allow any new crates to be locked to any yanked version.

 

As you can now appreciate, the Cargo utility script is extremely powerful and flexible.

Summary


We now have a fully working installation of Rust, and are ready for the get-go. We've explained how to set up a project, both manually and via the Cargo utility, and you should already have an appreciation of how useful Cargo is.

In the next chapter, we'll be looking at the foundation of any language: variables.

Left arrow icon Right arrow icon
Download code icon Download Code

Key benefits

  • Get started with the language to build scalable and high performance applications
  • This book will help C#/C++ developers gain better performance and memory management
  • Discover the power of Rust when developing concurrent applications for large and scalable software

Description

Rust is a highly concurrent and high performance language that focuses on safety and speed, memory management, and writing clean code. It also guarantees thread safety, and its aim is to improve the performance of existing applications. Its potential is shown by the fact that it has been backed by Mozilla to solve the critical problem of concurrency. Learning Rust will teach you to build concurrent, fast, and robust applications. From learning the basic syntax to writing complex functions, this book will is your one stop guide to get up to speed with the fundamentals of Rust programming. We will cover the essentials of the language, including variables, procedures, output, compiling, installing, and memory handling. You will learn how to write object-oriented code, work with generics, conduct pattern matching, and build macros. You will get to know how to communicate with users and other services, as well as getting to grips with generics, scoping, and more advanced conditions. You will also discover how to extend the compilation unit in Rust. By the end of this book, you will be able to create a complex application in Rust to move forward with.

What you will learn

  • [*] Set up Rust for Windows, Linux, and OS X
  • [*] Write effective code using Rust
  • [*] Expand your Rust applications using libraries
  • [*] Interface existing non-Rust libraries with your Rust applications
  • [*] Use the standard library within your applications
  • [*] Understand memory management within Rust and speed efficiency when passing variables
  • [*] Create more complex data types
  • [*] Study concurrency in Rust with multi-threaded applications and sync threading techniques to improve the performance of an application problem

Product Details

Country selected

Publication date : Nov 24, 2017
Length 308 pages
Edition : 1st Edition
Language : English
ISBN-13 : 9781785884306
Category :
Languages :

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want

Product Details


Publication date : Nov 24, 2017
Length 308 pages
Edition : 1st Edition
Language : English
ISBN-13 : 9781785884306
Category :
Languages :

Table of Contents

21 Chapters
Credits Chevron down icon Chevron up icon
About the Authors Chevron down icon Chevron up icon
About the Reviewer Chevron down icon Chevron up icon
www.PacktPub.com Chevron down icon Chevron up icon
Customer Feedback Chevron down icon Chevron up icon
Title Page Chevron down icon Chevron up icon
Preface Chevron down icon Chevron up icon
1. Introducing and Installing Rust Chevron down icon Chevron up icon
2. Variables Chevron down icon Chevron up icon
3. Input and Output Chevron down icon Chevron up icon
4. Conditions, Recursion, and Loops Chevron down icon Chevron up icon
5. Remember, Remember Chevron down icon Chevron up icon
6. Creating Your Own Rust Applications Chevron down icon Chevron up icon
7. Matching and Structures Chevron down icon Chevron up icon
8. The Rust Application Lifetime Chevron down icon Chevron up icon
9. Introducing Generics, Impl, and Traits Chevron down icon Chevron up icon
10. Creating Your Own Crate Chevron down icon Chevron up icon
11. Concurrency in Rust Chevron down icon Chevron up icon
12. Now It's Your Turn! Chevron down icon Chevron up icon
13. The Standard Library Chevron down icon Chevron up icon
14. Foreign Function Interfaces Chevron down icon Chevron up icon

Customer reviews

Top Reviews
Rating distribution
Empty star icon Empty star icon Empty star icon Empty star icon Empty star icon 0
(0 Ratings)
5 star 0%
4 star 0%
3 star 0%
2 star 0%
1 star 0%
Top Reviews
No reviews found
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

How do I buy and download an eBook? Chevron down icon Chevron up icon

Where there is an eBook version of a title available, you can buy it from the book details for that title. Add either the standalone eBook or the eBook and print book bundle to your shopping cart. Your eBook will show in your cart as a product on its own. After completing checkout and payment in the normal way, you will receive your receipt on the screen containing a link to a personalised PDF download file. This link will remain active for 30 days. You can download backup copies of the file by logging in to your account at any time.

If you already have Adobe reader installed, then clicking on the link will download and open the PDF file directly. If you don't, then save the PDF file on your machine and download the Reader to view it.

Please Note: Packt eBooks are non-returnable and non-refundable.

Packt eBook and Licensing When you buy an eBook from Packt Publishing, completing your purchase means you accept the terms of our licence agreement. Please read the full text of the agreement. In it we have tried to balance the need for the ebook to be usable for you the reader with our needs to protect the rights of us as Publishers and of our authors. In summary, the agreement says:

  • You may make copies of your eBook for your own use onto any machine
  • You may not pass copies of the eBook on to anyone else
How can I make a purchase on your website? Chevron down icon Chevron up icon

If you want to purchase a video course, eBook or Bundle (Print+eBook) please follow below steps:

  1. Register on our website using your email address and the password.
  2. Search for the title by name or ISBN using the search option.
  3. Select the title you want to purchase.
  4. Choose the format you wish to purchase the title in; if you order the Print Book, you get a free eBook copy of the same title. 
  5. Proceed with the checkout process (payment to be made using Credit Card, Debit Cart, or PayPal)
Where can I access support around an eBook? Chevron down icon Chevron up icon
  • If you experience a problem with using or installing Adobe Reader, the contact Adobe directly.
  • To view the errata for the book, see www.packtpub.com/support and view the pages for the title you have.
  • To view your account details or to download a new copy of the book go to www.packtpub.com/account
  • To contact us directly if a problem is not resolved, use www.packtpub.com/contact-us
What eBook formats do Packt support? Chevron down icon Chevron up icon

Our eBooks are currently available in a variety of formats such as PDF and ePubs. In the future, this may well change with trends and development in technology, but please note that our PDFs are not Adobe eBook Reader format, which has greater restrictions on security.

You will need to use Adobe Reader v9 or later in order to read Packt's PDF eBooks.

What are the benefits of eBooks? Chevron down icon Chevron up icon
  • You can get the information you need immediately
  • You can easily take them with you on a laptop
  • You can download them an unlimited number of times
  • You can print them out
  • They are copy-paste enabled
  • They are searchable
  • There is no password protection
  • They are lower price than print
  • They save resources and space
What is an eBook? Chevron down icon Chevron up icon

Packt eBooks are a complete electronic version of the print edition, available in PDF and ePub formats. Every piece of content down to the page numbering is the same. Because we save the costs of printing and shipping the book to you, we are able to offer eBooks at a lower cost than print editions.

When you have purchased an eBook, simply login to your account and click on the link in Your Download Area. We recommend you saving the file to your hard drive before opening it.

For optimal viewing of our eBooks, we recommend you download and install the free Adobe Reader version 9.