We saw a couple of functions, in passing, in the last chapter when we looked at the automatically generated boilerplate code created by cargo new. What were we actually seeing, though?

A function is a sequence of instructions for the computer to follow. It's sort of like a recipe. We don't have to tell a person how much flour, sugar, and milk to use to bake cookies, if we know that they already have a cookie recipe. We can just say: Bake some cookies, please. It's similar with a function. We don't have to tell the computer exactly how to save some information to a database; if there's a save_to_database function, we can use it to do the job.

In Rust, instructions that can tell the computer to take action can only be written inside of functions. It all starts with a function called main, which can cause other functions to run, which can in turn...

Modules give us a way to organize our functions (and other items that have names, such as data structures) into categories. This helps us keep things organized, and allows us to use the same name more than once, as long as we only use it once per module. It also lets us use shorter versions of a thing's name most of the time, but gives us a longer version we can use when those short names might be confusing or ambiguous.

Defining a module is easy. In any .rs file which the compiler is going to be looking at, we can use the mod keyword to start a new module. There are two different ways to use that keyword, though, depending on whether we want to define the module as a section of the current file...

The instructions that tell the computer to do something in a Rust program are almost all expressions. An expression tells the computer how to compute a particular value, and produces that value as its result. In math, 2 + 2 is an expression with a resulting value of 4. Similarly, (2 + 2) - 1 is an expression with a resulting value of 3, which is itself made up of an addition expression and a subtraction expression. In Rust, the same basic idea applies: expressions tell the computer how to find a value, and they can be combined together, because using an expression that produces a value has the same result as using that value directly, just as writing (2 + 2) - 1 has the same result as writing 4 - 1.

Not all expressions in Rust look like math, though. Rust is a programming language, not just a calculator. It's the idea of expressions, which combine values to produce...

A variable is a named box in which a data value can be stored. The variable itself isn't the data value, just like a carton of milk is not the same thing as milk (it's waxed cardboard and such containing milk).

On the other hand, if somebody needs milk and you hand them a full milk carton, they're not going to complain, and the same goes for Rust. If a Rust expression needs an integer, and we provide a variable containing an integer, Rust will be perfectly happy with that.

Variables are most often created using the let keyword:

let x = 10;

This statement creates a variable called x containing the 10 value in it. Once that's done, we can refer to x as part of the expressions. For example, x + 5 is now a valid expression, with a resulting value of 15.

Creating a data structure is one of the ways to add a new data type to Rust. A data structure is a group of variables that have been attached to each other, resulting in a single new data type that means all of these, together.

A new structure is defined using the struct keyword:

pub struct Constrained {
    pub min: i32,
    pub max: i32,
    current: i32,
}

Here, we've defined a structure called Constrained, which is made up of three different 32-bit unsigned integer variables. The structure itself is public, meaning that it can be used...

Now, we're going to fill in the blanks left in the earlier discussion of functions by talking about parameters and return types.

Parameters allow us to provide information to a function at the time when we ask it to run.

When we define a function, we can tell it the variable names and types we want it to use for receiving parameters, as in the following example:

pub fn set(&mut self, value: i32) {
    self.current = value;
}

We'll talk about self in the Implementing behavior for types section of this chapter. For now, ignore it and take a look at value. Here, we've provided a name and data type, just as we would if we were using...

In previous examples, we've seen what appeared to be calls to functions that were contained within data values, such as "127.0.0.1:12345".parse() or ["Hello", "world", "of", "loops"].iter(). Those are functions that have been implemented on the type of those values. Implementing functions on a type looks like this:

impl Constrained {
    pub fn set(&mut self, value: i32) {
        self.current = value;
    }

    pub fn get(&self) -> i32 {
        if self.current < self.min {
            return self.min;
        }
        else if self.current > self.max {
            return self.max;
        }
        else {
            return self.current;
        };
    }
}

This is an implementation block (which is not a block expression) for a data type, in this case the Constrained type that we created...

As we put the things we've learned in this chapter into practice, our grasp on them will solidify. We've learned about the basic structure of Rust programs, as well as how to write functions, loops, and branches. In addition, we've learned about Rust's type system and how to attach behavior to a data type. These things give us a foundation to build on, while we learn about the things that make Rust truly different from other programming languages.

In the next chapter, we're going to look at how the fundamental Rust concepts of ownership and borrowing work.