@ Notice that when we write the type of `iter`, we don't actually have to give the lifetime @ parameter of `Iter`. Just as it is the case with functio

Increments the number by 1.

Registration works just like last time, except that we are creating an `Rc` now.

And here we call all the stored callbacks.

Compute the minimum element of the vector

The core operation is, of course, `increment`.

Next, we are going to provide an iterator. @ This function just creates an instance of `IterMut`, the iterator type which does the actual @ work.

With the operations of the three threads defined, we can now implement a function that performs grepping according to some given options.

@ `[T]` is the type of an (unsized) *array*, with elements of type `T`. All this means is that @ there's a contiguous region of memory, where a bunch

@ As an example, consider a function which increments every element of a vector by 1. @ The type `&mut Vec<i32>` is the type of mutable references to

@ So, let's re-write `vec_min` to work on a shared reference to a vector, written `&Vec<i32>`. @ I also took the liberty to convert the function from

@ Next, we write `vec_min` as a generic function over a type `T` that we demand to satisfy the `Minimum` trait. @ This requirement is called a *trait

@ The case is slightly different for `box_into_raw`: Converting a `Box` to a raw pointer is @ always safe. It just drops some information. Hence we ke

Time for a demo!

Here we perform the actual printing of the prefix and the digit. We're not making use of our ability to change `self` here, but we could replace the p

The second function filters the lines it receives through `in_channel` with the pattern, and sends matches via `out_channel`.

The function `get` returns the current value of the counter.

This function extracts the rgrep options from the command-line arguments.

@ The function `head` demonstrates how that could work: It returns a reference to the first @ element of a vector if it is non-empty. The type of the

This is essentially the solution to 06.1.

Now that we reduced the problem to computing the minimum of two integers, let's do that.

@ Remember that helper function `min_i32`? Rust allows us to define such helper functions @ *inside* other functions. This is just a matter of namespa

The third function performs the output operations, receiving the relevant lines on its `in_channel`.

Add with carry, returning the sum and the carry

So, let us write a function to "add with carry", and give it the appropriate type. Notice Rust's native support for pairs.

Subtract with carry, returning the difference and the carry

@ `println!` is again a macro, where the first argument is a *format string*. For @ now, you just need to know that `{}` is the placeholder for a valu

Finally, this function takes a `BigInt` and a prefix, and prints the digits with the given prefix. @ It does so by creating an instance of `PrintWithS

@ We declare `raw_into_box` to be an `unsafe` function, telling Rust that calling this function @ is not generally safe. This grants us the unsafe pow

The first function reads the files, and sends every line over the `out_channel`.

@ `vec!` is a *macro* (as indicated by `!`) that constructs a constant `Vec<_>` with the given @ elements.

Now we are ready to run our new code. Remember to change `main.rs` appropriately. @ Rust figures out automatically that we want the `T` of `vec_min` t

@ Let's now go over this function line-by-line. First, we call the constructor of `Vec` @ to create an empty vector. As mentioned in the previous part

With our refactored functions and methods, `main` now looks as follows:

Registration simply stores the callback.

@ For this to work, we need to demand that the type `F` does not contain any short-lived @ references. After all, we will store it in our list of call

Observe how in Rust, the return type comes *after* the arguments.

Let us now refactor `vec_min`.

## Ownership @ What does that mean in practice? Consider the following example.

Conditionals are also just expressions. This is comparable to the ternary `? :` operator from languages like C.

Now we can write the actual function performing the addition.

@ Observe how `new` does *not* have a `self` parameter. This corresponds to a `static` method @ in Java or C++. In fact, `new` is the Rust convention

## Cloning @ If you take a close look at the type of `BigInt::from_vec`, you will notice that it consumes @ the vector `v`. The caller hence loses acc

Now we can compare `BigInt`s. Rust treats `PartialEq` special in that it is wired to the operator `==`: @ That operator can now be used on our numbers

It is even the case that blocks are expressions, evaluating to the last expression they contain.

So, let us put our counter in a `Cell`, and replicate the example from the previous part.

Now we can repeat the demo from the previous part - but this time, our `CallbacksMut` type can be cloned.

The destructor itself is a method which takes `self` in mutably borrowed form. It cannot own `self`, because then the destructor of `self` would be ca

And as a final example, one can also collect all elements of an iterator, and put them, e.g., in a vector.

Construct a BigInt from a vector of 64-bit "digits", with the last significant digit being first. Solution to 05.1.

We can convert any little-endian vector of digits (i.e., least-significant digit first) into a number, by removing trailing zeros. The `mut` declarati

Increments the number by "by".

Let's say we want to write a function that increments every entry of a `Vec` by some number, then looks for numbers larger than some threshold, and pr

@ It turns out that the answer to this question is yes! This particular aspect of the concept of @ lifetimes helps Rust to eliminate the issue of *ite