R1: Cargo

Question 1

What is Cargo?

Answer 1

Cargo is Rust’s build system and package manager. It can: build your code, download the libraries your code depends on, and build those libraries.

Question 2

Cmd: cargo new <project name>

Answer 2

We can create a project. You’ll see that Cargo has generated two files and one directory for us: a Cargo.toml file and a src directory with a main.rs file inside.

Question 3

Cmd: cargo new --vcs=git hello_cargo

Answer 3

Same as cargo new <project name> but overrides current git config files.

Question 4

What does the Cargo.toml contain?

Answer 4

This file is in the TOML (Tom’s Obvious, Minimal Language) format, which is Cargo’s configuration format.

Example:

[package]
name = “hello_cargo”
version = “0.1.0”
edition = “2021”

See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Question 5

What is [package] in Cargo.toml?

Answer 5

The first line, [package], is a section heading that indicates that the following statements are configuring a package.

Question 6

What is [dependencies] in Cargo.toml?

Answer 6

Is the start of a section for you to list any of your project’s dependencies. In Rust, packages of code are referred to as crates.

Question 7

Cmd: cargo build

Answer 7

We can build a project

Question 8

Cmd: cargo run

Answer 8

We can build and run a project in one step

Question 9

Cmd: cargo check

Answer 9

We can build a project without producing a binary to check for errors using

Question 10

target/debug directory

Answer 10

Instead of saving the result of the build in the same directory as our code, Cargo stores it in the target/debug directory.

Question 11

Cmd: cargo build --release?

Answer 11

When your project is finally ready for release, you can use cargo build –release to compile it with optimizations. This command will create an executable in target/release instead of target/debug.

Question 12

Cmd: cargo build --release?

Answer 12

When your project is finally ready for release, you can use cargo build –release to compile it with optimizations. This command will create an executable in target/release instead of target/debug.

Question 13

module system

Answer 13

Rust has a number of features that allow you to manage your code’s organization, including which details are exposed, which details are private, and what names are in each scope in your programs.

These features include:

• Packages: A Cargo feature that lets you build, test, and share crates
• Crates: A tree of modules that produces a library or executable
• Modules and use: Let you control the organization, scope, and privacy of paths
• Paths: A way of naming an item, such as a struct, function, or module

Question 14

crate

Answer 14

A crate is the smallest amount of code that the Rust compiler considers at a time. A crate can come in one of two forms:
- Binary crates: are programs you can compile to an executable that you can run, such as a command-line program or a server.
- Library crates don’t have a main function, and they don’t compile to an executable. Instead, they define functionality intended to be shared with multiple projects.

Question 15

crate root

Answer 15

The crate root is a source file that the Rust compiler starts from and makes up the root module of your crate (usually src/lib.rs for a library crate or src/main.rs for a binary crate).

Question 16

package

Answer 16

A package is a bundle of one or more crates that provides a set of functionality. A package contains a Cargo.toml file that describes how to build those crates.

Question 17

Declaring submodules

Answer 17

Declaring modules: In the crate root file, you can declare new modules; say, you declare a “garden” module with mod garden;.

Once a module is part of your crate, you can refer to code in that module from anywhere else in that same crate, as long as the privacy rules allow, using the path to the code. For example, an Asparagus type in the garden vegetables module would be found at crate::garden::vegetables::Asparagus.

Question 18

Private vs public modules

Answer 18

Code within a module is private from its parent modules by default. To make a module public, declare it with pub mod instead of mod.

Question 19

use keyword

Answer 19

The use keyword: Within a scope, the use keyword creates shortcuts to items to reduce repetition of long paths. In any scope that can refer to crate::garden::vegetables::Asparagus, you can create a shortcut with use crate::garden::vegetables::Asparagus; and from then on you only need to write Asparagus to make use of that type in the scope.

Question 20

backyard

Answer 20

Here we create a binary crate named backyard that illustrates these rules. The crate’s directory, also named backyard, contains these files and directories:

backyard
├── Cargo.lock
├── Cargo.toml
└── src
    ├── garden
    │   └── vegetables.rs
    ├── garden.rs
    └── main.rs

Question 21

Example of modules use

Answer 21

``` src/main.rs
use crate::garden::vegetables::Asparagus;

pub mod garden;

fn main() {
let plant = Asparagus {};
println!(“I’m growing {:?}!”, plant);
}
~~~

``` src/garden.rs
pub mod vegetables;
~~~

```src/garden/vegetables.rs
#[derive(Debug)]
pub struct Asparagus {}
~~~

Question 22

Grouping Related Code in Modules

Answer 22

Examples of fs tree:
~~~
crate
└── front_of_house
├── hosting
│ ├── add_to_waitlist
│ └── seat_at_table
└── serving
├── take_order
├── serve_order
└── take_payment

Examples of module:

mod front_of_house {
mod hosting {
fn add_to_waitlist() {}

    fn seat_at_table() {}
}

mod serving {
    fn take_order() {}

    fn serve_order() {}

    fn take_payment() {}
} } ~~~

Question 23

absolute path

Answer 23

• An absolute path: is the full path starting from a crate root; for code from an external crate, the absolute path begins with the crate name, and for code from the current crate, it starts with the literal crate.

Emod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();
}

Question 24

relative path

Answer 24

• A relative path: starts from the current module and uses self, super, or an identifier in the current module.

Emod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Relative path
    front_of_house::hosting::add_to_waitlist();

Question 25

Starting Relative Paths with super

Answer 25

fn deliver_order() {}

mod back_of_house {
fn fix_incorrect_order() {
cook_order();
super::deliver_order();
}

fn cook_order() {} }

Question 26

Making Structs and Enums Public

Answer 26

mod back_of_house {
pub struct Breakfast {
pub toast: String,
seasonal_fruit: String,
}

impl Breakfast {
    pub fn summer(toast: &str) -> Breakfast {
        Breakfast {
            toast: String::from(toast),
            seasonal_fruit: String::from("peaches"),
        }
    }
} }

pub fn eat_at_restaurant() {
// Order a breakfast in the summer with Rye toast
let mut meal = back_of_house::Breakfast::summer(“Rye”);
// Change our mind about what bread we’d like
meal.toast = String::from(“Wheat”);
println!(“I’d like {} toast please”, meal.toast);

// The next line won't compile if we uncomment it; we're not allowed
// to see or modify the seasonal fruit that comes with the meal
// meal.seasonal_fruit = String::from("blueberries"); }

Question 27

Providing New Names with the as Keyword

Answer 27

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
// –snip–
}

fn function2() -> IoResult<()> {
// –snip–
}

Question 28

Using External Packages

Answer 28

To use rand (External Packages) in our project, we added this line to Cargo.toml:

Filename: Cargo.toml
~~~
rand = “0.8.5”
~~~
Adding rand as a dependency in Cargo.toml tells Cargo to download the rand package and any dependencies from crates.io and make rand available to our project.

use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1..=100);
}

Question 29

Using Nested Paths to Clean Up Large use Lists

Answer 29

Before:
// –snip–
use std::cmp::Ordering;
use std::io;
// –snip–

After:
// –snip–
use std::{cmp::Ordering, io};
// –snip–

Before:
// –snip–
use std::io;
use std::io::Write;
// –snip–

After:
use std::io::{self, Write};
// –snip–

Question 30

The Glob Operator

Answer 30

If we want to bring all public items defined in a path into scope, we can specify that path followed by the * glob operator:

use std::collections::*;