Now our counter is ready for action.

This decides which part is actually run.

To actually run the code of some part (after filling in the blanks, if necessary), simply edit the `main` function.

Now our counter is ready for action.

We are finally ready to iterate! Remember to edit `main.rs` to run this function.

Now we are ready for the demo. Remember to edit `main.rs` to run it.

Putting it all together:

Finally, we can call the `run` function from the previous part on the options extracted using `get_options`. Edit `main.rs` to call this function. You

Here's a small main function, demonstrating the code above in action. Remember to edit `main.rs` to run it.

Now we have all the pieces together for testing our rgrep with some hard-coded options. @ We need to call `to_string` on string literals to convert th

If you update your `main.rs` to use part 03, `cargo run` should now ask you for some numbers, and tell you the minimum. Neat, isn't it?

Here's an example of calling `vec_inc`.

Construct a BigInt from a "small" one.

The constructor should not be surprising.

The constructor just wraps the constructors of `Arc` and `Mutex`.

@ Let's start with a constructor, creating a `BigInt` from an ordinary integer. @ To create an instance of a struct, we write its name followed by a l

Now we can provide some functions. The constructor should be straight-forward.

A new linked list just contains null pointers. `PhantomData` is how we construct any `PhantomData<T>`.

Return the nth power-of-2 as BigInt

Remember that we decided to use the `FnMut` trait above? This means our closure could actually mutate its environment. For example, we can use that to

Of course, we don't have to use `for` to apply the iterator. We can also explicitly call `next`.

@ Now, it turns out that this combination of doing a loop and a pattern matching is fairly @ common, and Rust provides some convenient syntactic sugar

Sometimes it is useful to know both the position of some element in a list, and its value. That's where the `enumerate` function helps.

Now that we saw how to write a function that operates on closures, let's see how to write a closure.

This function adds a new node to the end of the list.

Technically, we are returning a pointer to the first element. But doesn't that mean that callers have to be careful? Imagine `head` would be a C++ fun

Now that `vec_min` does not acquire ownership of the vector anymore, we can call it multiple times on the same vector and also do things like

## Arrays @ An *array* in Rust is given by the type `[T; n]`, where `n` is some *fixed* number. So, `[f64; @ 10]` is an array of 10 floating-point num

Now, we can sort, e.g., an vector of numbers.

## Expression-based programming @ For example, consider `sqr`:

[test]*/

@ It can often be useful to encode the invariant of a data-structure in code, so here @ is a check that detects useless trailing zeros.

`overflow_add` is a sufficiently intricate function that a test case is justified. This should also help you to check your solution of the exercise. [

Now we are ready to use `assert_eq!` to test `vec_min`. [test]*/

Return a pointer to the minimal value of `v`.

Now we can write `vec_min`.

@ Now we can implement a generic function `vec_min` that works on above trait. @ The code is pretty much straight-forward, and Rust checks that all th

Print all elements in the vector

Compute the sum of elements in the vector

@ Now consider the following piece of code. Like above, `n` will be a reference to a part of @ `var`, and since we wrote `ref mut`, the reference will