Grab the first number.

A function which takes a `WebEvent` enum as an argument and returns nothing.

This function borrows an i32

The same structure as before but rather than chain all `Results` and `Options` along, we `?` to get the inner value out immediately.

Check whether there's food or not before trying to eat it!

Use the `pub` modifier to override default visibility.

The adult has seen it all, and can handle any drink well. All drinks are handled explicitly using `match`.

Function that returns a boolean value

Return the length of the list

Consume a list, and return the same list with a new element at its front

One input reference with lifetime `'a` which must live at least as long as the function.

This function borrows a slice

This function takes a reference to a book

Define a function which takes a generic `F` argument bounded by `Fn`, and calls it

Chopping food. If there isn't any, then return `None`. Otherwise, return the chopped food.

Cooking food. Here, we showcase `map()` instead of `match` for case handling.

Others will `panic` before drinking sugary drinks. All drinks are handled implicitly using `unwrap`.

Returns a Fibonacci sequence generator

We have the recipe for everything except Cordon Bleu.

With the return type rewritten, we use pattern matching without `unwrap()`.

Use the above alias to refer to our specific `Result` type.

As with `Option`, we can use combinators such as `map()`. This function is otherwise identical to the one above and reads: Modify n if the value is va

Peeling food. If there isn't any, then return `None`. Otherwise, return the peeled food.

Here, the alias again allows us to save some space.

Default trait methods can be overridden.

This function handles a division that may not succeed

Mutable references are possible with lifetimes as well.

Annotate lifetimes as in a standalone function.

A function `age` which returns a `u32`.

`F` must implement `Fn` for a closure which takes no inputs and returns nothing - exactly what is required for `print`.

A function which takes a closure as an argument and calls it. <F> denotes that F is a "Generic type parameter"

An integer division that doesn't `panic!`

This is the exact same function, but its return type uses `impl Trait`. Look how much simpler it is!

#[cfg(some_condition)]*/

`&Self::A` and `&Self::B` are also valid here.

This can conveniently be rewritten more compactly with `and_then()`:

raii.rs

This method "consumes" the resources of the caller object `self` desugars to `self: Self`

This function takes ownership of the heap allocated memory

Re-implementation of integer division (/)

This method takes ownership of both passed arguments, deallocating both.

This function takes ownership of a box and destroys it

`elided_input` and `annotated_input` essentially have identical signatures because the lifetime of `elided_input` is inferred by the compiler:

A function which takes no arguments, but has a lifetime parameter `'a`.

Grab the first number.

Functions that "don't" return a value, actually return the unit type `()`

When a function returns `()`, the return type can be omitted from the signature

Define a function `gen_spec_i32` that takes an argument `_s` of type `SGen<i32>`. It has been explicitly given the type parameter `i32`, which is a sp

Define a function `gen_spec_t` that takes an argument `_s` of type `SGen<T>`. It has been explicitly given the type parameter `A`, but because `A` has

Define a function `generic` that takes an argument `_s` of type `SGen<T>`. Because `SGen<T>` is preceded by `<T>`, this function is generic over `T`.

We don't have the ingredients to make Sushi.

Items can access other items in the same module, even when private.

Grab the last number.

Grab the last number.

Returns a function that adds `y` to its input

This function takes a reference to a mutable book and changes `year` to 2014

Intermediate function