So, let us define a trait that demands that the type provides some method `do_action` on digits. @ This immediately raises the question: How do we pas

@ To write this down in Rust, we use a `struct`, which is a lot like structs in C: @ Just a bunch of named fields. Every field can be private to the c

@ So, what can we do, if we can't store the callbacks in a vector? We can put them in a box. @ Semantically, `Box<T>` is a lot like `T`: You fully own

@ First of all, we need to find a way to store the callbacks. Clearly, there will be a `Vec` @ involved, so that we can always grow the number of regi

@ In writing this down, we again have to be explicit about the lifetime of the reference: We @ can't just have an `Iter`, we must have an `Iter<'a>` t

@ For Rust to accept the type, we have to add two more annotations. First of all, we have to @ ensure that the data in the list lives at least as long

The linked list itself stores pointers to the first and the last node. In addition, we tell Rust that this type will own data of type `T`. @ The type

This trait is used to compute the minimum of two elements of the given type

@ So, as a first step towards a generic `vec_min`, we define a `Minimum` trait. @ For now, just ignore the `Copy`, we will come back to this point lat

With our new knowledge of lifetimes, we are now able to write down the desired type of `min`: @ We want the function to take two references *with the

@ As usually, we start by defining the types. Everything is parameterized by the type `T` of the @ data stored in the list. A node of the list consist

A number, or nothing

An `enum` for "a number or nothing" could look as follows:

@ And the same applies to case distinction with `match`: Every `arm` of the match @ gives the expression that is returned in the respective case. @ (W

Exercise 03.1**: The goal is to write a generic version of `SomethingOrNothing::print`. To this end, define a trait `Print` that provides (simple) gen

@ As the next step, we need to come up with some action, and write an appropriate implementation @ of `Action` for it. So, let's say we want to print

A polymorphic (generic) "some value, or no value"

@ The solution to this is called *generics* or *polymorphism* (the latter is Greek, @ meaning "many shapes"). You may know something similar from C++

## Mutation + aliasing considered harmful (part 2) @ Now that we know how to create references to contents of an `enum` (like `v` above), there's @ an