The compiler is not in your way, it is doing your review

//! Three functions, three different promises about what can go wrong.

/// Takes a borrowed string, gives back an owned one. The caller keeps their
/// value, and the signature says so without a word of documentation.
pub fn greet(name: &str) -> String {
    format!("Hello, {name}!")
}

/// The absence of an age is in the return type, so there is no way to forget
/// it. There is no null to check for and nothing to throw.
pub fn find_age(name: &str, people: &[(String, u32)]) -> Option<u32> {
    people
        .iter()
        .find(|(person, _)| person == name)
        .map(|(_, age)| *age)
}

/// This one can fail for a reason worth reporting, so it says which reasons.
pub fn parse_age(raw: &str) -> Result<u32, std::num::ParseIntError> {
    raw.trim().parse::<u32>()
}

fn main() {
    println!("{}", greet("world"));

    let people = vec![("ada".to_string(), 36)];
    match find_age("ada", &people) {
        Some(age) => println!("ada is {age}"),
        None => println!("nobody by that name"),
    }

    // The compiler will not let this line compile without handling both cases.
    println!("{:?}", parse_age("41"));
}

# rustup installs the toolchain and is how you switch between versions.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Or through a package manager, if you prefer.
#   macOS     brew install rustup-init && rustup-init
#   Windows   winget install Rustlang.Rustup

rustc --version
cargo --version

# The components worth having on day one.
rustup component add clippy rustfmt rust-analyzer rust-src

# Pin a project to a version by writing a rust-toolchain.toml next to
# Cargo.toml. Everyone who builds it then gets the same compiler.
cat > rust-toolchain.toml <<'TOML'
[toolchain]
channel = "1.85"
components = ["clippy", "rustfmt"]
TOML

//! Every Rust program starts at fn main. Comments beginning with //! document
//! the file itself; /// documents the item below it.

fn main() {
    // println! is a macro, not a function. The ! is how you can tell, and it
    // is why the format string can be checked at compile time.
    let name = "world";
    println!("Hello, {name}!");

    // Bindings are immutable unless you ask for otherwise.
    let mut count = 0;
    count += 1;
    println!("count is {count}");

    // Types are inferred almost everywhere, and written where it helps.
    let numbers: Vec<i32> = (1..=5).collect();
    let total: i32 = numbers.iter().sum();
    println!("{numbers:?} adds up to {total}");
}

$ cargo new hello
    Creating binary (application) `hello` package
      note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
$ cd hello
$ cargo run
   Compiling hello v0.1.0 (/home/you/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.34s
     Running `target/debug/hello`
Hello, world!
$ cargo run --release
   Compiling hello v0.1.0 (/home/you/hello)
    Finished `release` profile [optimized] target(s) in 0.21s
     Running `target/release/hello`
Hello, world!

//! Every value in the comparison table, in one file that compiles.

use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq)]
struct User {
    id: u32,
    name: String,
    admin: bool,
}

#[derive(Debug)]
enum Status {
    Idle,
    Running { since: u64 },
    Failed(String),
}

fn main() {
    // Integers carry their width. i32 is the default, usize indexes things.
    let count: i32 = 42;
    let big: u64 = 9_000_000_000;
    let ratio: f64 = 3.14;
    let yes: bool = true;
    let letter: char = 'r';

    // Two string types, and the difference matters. &str borrows, String owns.
    let borrowed: &str = "hi";
    let owned: String = String::from("hi");

    // A growable list, and a fixed size array.
    let numbers: Vec<i32> = vec![1, 2, 3];
    let fixed: [i32; 3] = [1, 2, 3];

    // A tuple, which is the closest thing to Python's tuple.
    let pair: (i32, &str) = (200, "OK");

    // The dictionary.
    let mut ages: HashMap<&str, u32> = HashMap::new();
    ages.insert("ada", 36);

    // No null. An absent value has a type that says it might be absent.
    let missing: Option<i32> = None;
    let present: Option<i32> = Some(7);

    // No exceptions. A fallible result has a type that says it might fail.
    let parsed: Result<i32, std::num::ParseIntError> = "12".parse();

    // A struct and an enum with data in its variants.
    let user = User { id: 1, name: owned.clone(), admin: false };
    let status = Status::Running { since: 1_700_000_000 };

    // A closure, which can capture what is around it.
    let double = |x: i32| x * 2;

    println!("{count} {big} {ratio} {yes} {letter}");
    println!("{borrowed} {owned} {numbers:?} {fixed:?} {pair:?}");
    println!("{ages:?} {missing:?} {present:?} {parsed:?}");
    println!("{user:?} {status:?} {}", double(21));
}

//! Ownership: every value has exactly one owner, and the owner decides when
//! it is freed. There is no garbage collector and no manual free.

#[derive(Debug)]
struct Config {
    name: String,
}

/// Taking a value by value takes ownership of it. The caller cannot use it
/// afterwards, which is what the compiler means by "moved".
fn consume(config: Config) -> usize {
    config.name.len()
}

/// Borrowing reads it without taking it. The caller keeps their value.
fn inspect(config: &Config) -> usize {
    config.name.len()
}

fn main() {
    // Move: two names cannot own the same heap allocation.
    let a = String::from("hello");
    let b = a;
    // println!("{a}"); // error[E0382]: borrow of moved value: `a`
    println!("b is {b}");

    // Copy: small values with a known size are duplicated instead of moved,
    // because copying them is as cheap as tracking the move would be.
    let x = 5;
    let y = x;
    println!("x is still {x}, y is {y}");

    // Clone is the explicit "I want a second one, and I accept the cost".
    let original = String::from("hello");
    let copy = original.clone();
    println!("{original} and {copy}");

    let config = Config { name: String::from("server") };

    // Borrow first: config is still ours afterwards.
    println!("length by borrow: {}", inspect(&config));

    // Then move: this is the last thing that can use config.
    println!("length by move: {}", consume(config));
    // println!("{config:?}"); // error[E0382]: borrow of moved value

    // Ownership can also come back out of a function.
    let returned = give_back(Config { name: String::from("client") });
    println!("got it back: {returned:?}");
}

fn give_back(config: Config) -> Config {
    config
}

$ cargo run
   Compiling ownership v0.1.0 (/home/you/ownership)
error[E0382]: borrow of moved value: `a`
 --> src/main.rs:5:16
  |
2 |     let a = String::from("hello");
  |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
3 |     let b = a;
  |             - value moved here
4 |
5 |     println!("{a}");
  |                ^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let b = a.clone();
  |              ++++++++
For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

//! Borrowing: any number of shared references, or exactly one exclusive
//! reference, and never both at the same time.

fn main() {
    let mut text = String::from("hello");

    // Any number of shared borrows. Nobody can change the value while they
    // are alive, so all of them see the same thing.
    let first = &text;
    let second = &text;
    println!("{first} {second} {}", text.len());

    // The two shared borrows are not used after this point, so their
    // lifetimes have ended and an exclusive borrow is allowed here.
    let exclusive = &mut text;
    exclusive.push_str(", world");
    println!("{exclusive}");

    // Slices are borrows of part of something.
    let numbers = vec![1, 2, 3, 4, 5];
    let middle = &numbers[1..4];
    println!("{middle:?} out of {numbers:?}");

    let sentence = String::from("borrow checker");
    let word = first_word(&sentence);
    println!("first word: {word}");

    // A shared borrow inside a loop, so the vector is not consumed.
    let mut total = 0;
    for n in &numbers {
        total += n;
    }
    println!("{numbers:?} sums to {total}");

    // An exclusive borrow inside a loop, changing the elements in place.
    let mut scores = vec![1, 2, 3];
    for score in &mut scores {
        *score *= 10;
    }
    println!("{scores:?}");
}

/// Returning a borrow of the argument. The lifetime is inferred: the result
/// cannot outlive the string it points into.
fn first_word(text: &str) -> &str {
    match text.find(' ') {
        Some(index) => &text[..index],
        None => text,
    }
}

$ cargo run
error[E0502]: cannot borrow `text` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:21
  |
4 |     let first = &text;
  |                 ----- immutable borrow occurs here
5 |
6 |     let exclusive = &mut text;
  |                     ^^^^^^^^^ mutable borrow occurs here
7 |     println!("{first}");
  |               ------- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.

$ cargo check
error[E0106]: missing lifetime specifier
 --> src/lib.rs:1:41
  |
1 | fn longest(left: &str, right: &str) -> &str {
  |                  ----         ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `left` or `right`
help: consider introducing a named lifetime parameter
  |
1 | fn longest<'a>(left: &'a str, right: &'a str) -> &'a str {
  |           ++++        ++             ++           ++
For more information about this error, try `rustc --explain E0106`.

//! Lifetimes are the compiler's name for how long a borrow is valid. Most of
//! them are inferred. The ones you write down are the ones where a function
//! returns a borrow and the compiler cannot tell which input it came from.

/// Two inputs, one borrowed output, so the relationship has to be stated:
/// the result lives no longer than whichever argument lives less long.
fn longest<'a>(left: &'a str, right: &'a str) -> &'a str {
    if left.len() >= right.len() { left } else { right }
}

/// A struct that borrows rather than owns. It cannot outlive the text it
/// points into, and the lifetime parameter is how that is written down.
#[derive(Debug)]
struct Excerpt<'a> {
    part: &'a str,
}

impl<'a> Excerpt<'a> {
    fn new(text: &'a str) -> Self {
        let end = text.find('.').unwrap_or(text.len());
        Excerpt { part: &text[..end] }
    }

    /// The elision rules cover this one: an argument of &self means the
    /// output borrows from self, so no annotation is needed.
    fn announce(&self, note: &str) -> &str {
        println!("note: {note}");
        self.part
    }
}

fn main() {
    let title = String::from("the borrow checker");
    let subtitle = String::from("a short argument");
    println!("longest: {}", longest(&title, &subtitle));

    let article = String::from("Rust has no runtime. That is the point.");
    let excerpt = Excerpt::new(&article);
    println!("{:?}", excerpt.announce("first sentence"));

    // 'static means the value lives for the whole program. String literals
    // are baked into the binary, so they qualify.
    let forever: &'static str = "compiled in";
    println!("{forever}");
}

//! Structs and enums. Between them they cover what classes, interfaces,
//! unions and null are used for elsewhere.

/// A named struct. #[derive] asks the compiler to write the boring
/// implementations: Debug for printing, Clone for duplication, PartialEq
/// for ==.
#[derive(Debug, Clone, PartialEq)]
pub struct Rectangle {
    width: f64,
    height: f64,
}

/// A tuple struct, for a wrapper that needs a distinct type but no field
/// names. This is how you stop metres being added to seconds.
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Metres(pub f64);

impl Rectangle {
    /// An associated function. No self, so it is called on the type:
    /// Rectangle::new(3.0, 4.0).
    pub fn new(width: f64, height: f64) -> Self {
        Self { width, height }
    }

    /// A method taking &self borrows, so the caller keeps the rectangle.
    pub fn area(&self) -> f64 {
        self.width * self.height
    }

    /// &mut self borrows exclusively, so this can change the value.
    pub fn scale(&mut self, factor: f64) {
        self.width *= factor;
        self.height *= factor;
    }

    /// self by value consumes the rectangle. Useful for builders and for
    /// conversions that should not leave the original around.
    pub fn into_square(self) -> Rectangle {
        let side = self.width.max(self.height);
        Rectangle::new(side, side)
    }
}

/// An enum where each variant carries different data. This is the feature
/// Python and JavaScript have no direct equivalent of, and it is the reason
/// Rust needs neither null nor exceptions.
#[derive(Debug)]
pub enum Shape {
    Circle { radius: f64 },
    Rect(Rectangle),
    Point,
}

impl Shape {
    pub fn area(&self) -> f64 {
        // The match must cover every variant. Add one later and every match
        // that forgot it stops compiling, which is the whole point.
        match self {
            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
            Shape::Rect(rect) => rect.area(),
            Shape::Point => 0.0,
        }
    }
}

/// Option and Result are ordinary enums from the standard library. Nothing
/// about them is special, which is worth knowing when they start to feel
/// like language features.
pub fn describe(value: Option<i32>) -> String {
    match value {
        Some(n) if n > 0 => format!("positive: {n}"),
        Some(n) => format!("not positive: {n}"),
        None => String::from("nothing"),
    }
}

fn main() {
    let mut rect = Rectangle::new(3.0, 4.0);
    println!("area {}", rect.area());

    rect.scale(2.0);
    println!("scaled {rect:?}");

    let square = rect.clone().into_square();
    println!("square {square:?}, original still here {rect:?}");

    let shapes = vec![
        Shape::Circle { radius: 1.0 },
        Shape::Rect(Rectangle::new(2.0, 3.0)),
        Shape::Point,
    ];
    for shape in &shapes {
        println!("{shape:?} has area {:.2}", shape.area());
    }

    println!("{}", describe(Some(3)));
    println!("{}", describe(None));

    let distance = Metres(4.0);
    println!("{distance:?}");
}

$ cargo check
error[E0004]: non-exhaustive patterns: `Event::Quit` not covered
  --> src/main.rs:12:11
   |
12 |     match event {
   |           ^^^^^ pattern `Event::Quit` not covered
   |
note: `Event` defined here
  --> src/main.rs:5:6
   |
5  | enum Event {
   |      ^^^^^
8  |     Quit,
   |     ---- not covered
   = note: the matched value is of type `Event`
help: ensure the match is exhaustive by adding a match arm with a pattern
   |
15 ~         Event::Scroll(n) => format!("scroll {n}"),
16 +         Event::Quit => todo!(),
   |
For more information about this error, try `rustc --explain E0004`.

//! Pattern matching. match is an expression, it must cover every case, and
//! the compiler enforces that.

#[derive(Debug)]
enum Event {
    Click { x: i32, y: i32 },
    Key(char),
    Scroll(i32),
    Quit,
}

fn handle(event: &Event) -> String {
    match event {
        // Destructure a struct variant, and bind its fields by name.
        Event::Click { x, y } if *x == *y => format!("click on the diagonal at {x}"),
        Event::Click { x, y } => format!("click at {x},{y}"),

        // Match several literals in one arm with |.
        Event::Key('q' | 'Q') => String::from("quit key"),
        Event::Key(c) => format!("key {c}"),

        // Ranges work in patterns too.
        Event::Scroll(amount @ 1..=10) => format!("small scroll of {amount}"),
        Event::Scroll(amount) => format!("scroll of {amount}"),

        Event::Quit => String::from("quit"),
    }
}

fn main() {
    let events = vec![
        Event::Click { x: 3, y: 3 },
        Event::Key('a'),
        Event::Scroll(4),
        Event::Quit,
    ];
    for event in &events {
        println!("{}", handle(event));
    }

    // if let, for when only one case is interesting.
    let maybe = Some(5);
    if let Some(n) = maybe {
        println!("got {n}");
    }

    // let else, for when the uninteresting case means leaving early. This is
    // the one that removes most of the nesting from real code.
    let text = "42";
    let Ok(number) = text.parse::<i32>() else {
        println!("not a number");
        return;
    };
    println!("parsed {number}");

    // while let, to keep pulling until there is nothing left.
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("popped {top}");
    }

    // Destructuring in a let, and in function arguments.
    let (a, b) = (1, 2);
    let [first, .., last] = [10, 20, 30, 40];
    println!("{a} {b} {first} {last}");

    // matches! is a small macro for "does this fit the shape", as a bool.
    println!("{}", matches!(events[0], Event::Click { .. }));
}

//! Functions, closures, and the three ways a closure can capture.

/// The last expression is the return value. A semicolon after it would turn
/// it into a statement, and the function would return ().
fn double(x: i32) -> i32 {
    x * 2
}

/// return exists, and is for leaving early.
fn classify(n: i32) -> &'static str {
    if n < 0 {
        return "negative";
    }
    match n {
        0 => "zero",
        1..=9 => "small",
        _ => "large",
    }
}

/// if is an expression, so this is one binding rather than four lines of
/// assignment.
fn bmi_verdict(weight_kg: f64, height_m: f64) -> (&'static str, f64) {
    let bmi = weight_kg / (height_m * height_m);
    let verdict = if bmi <= 18.5 {
        "underweight"
    } else if bmi <= 25.0 {
        "normal"
    } else {
        "overweight"
    };
    (verdict, bmi)
}

/// Taking a function as an argument. impl Fn in argument position means "any
/// closure with this shape", resolved at compile time with no indirection.
fn apply_twice(f: impl Fn(i32) -> i32, value: i32) -> i32 {
    f(f(value))
}

/// Returning a closure. It has no name, so the return type is impl Fn, and
/// move tells the closure to take ownership of what it captured.
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n
}

fn main() {
    println!("{}", double(21));
    println!("{}", classify(-1));

    let (verdict, bmi) = bmi_verdict(70.0, 1.8);
    println!("{verdict} at {bmi:.1}");

    // A closure borrowing what it uses.
    let factor = 3;
    let triple = |x| x * factor;
    println!("{}", triple(5));
    println!("factor is still usable: {factor}");

    // A closure that changes what it captured needs to be mut itself.
    let mut count = 0;
    let mut bump = || count += 1;
    bump();
    bump();
    println!("bumped to {count}");

    println!("{}", apply_twice(double, 3));
    println!("{}", apply_twice(|x| x + 10, 3));

    let add_five = make_adder(5);
    println!("{}", add_five(10));

    // A block is an expression, so this is a way to scope temporary work.
    let result = {
        let a = 2;
        let b = 3;
        a * b
    };
    println!("{result}");
}

//! Vec, HashMap, and the two string types.

use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};

fn main() {
    // Vec is the growable list. Indexing panics on a bad index; get returns
    // an Option, which is the version that cannot surprise you.
    let mut numbers = vec![3, 1, 2];
    numbers.push(4);
    numbers.sort();
    println!("{numbers:?} first={:?} tenth={:?}", numbers.first(), numbers.get(9));

    // Removing while iterating is not allowed, so retain does it in one pass.
    let mut names = vec!["ada", "grace", "alan", "barbara"];
    names.retain(|name| name.len() > 3);
    println!("{names:?}");

    // HashMap. entry().or_insert() is the counting idiom, and or_default()
    // saves writing the zero.
    let mut counts: HashMap<&str, u32> = HashMap::new();
    for word in ["a", "b", "a", "c", "a"] {
        *counts.entry(word).or_default() += 1;
    }
    let mut pairs: Vec<_> = counts.iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(a.1).then(a.0.cmp(b.0)));
    println!("{pairs:?}");

    // get returns Option<&V>, so a missing key is a case rather than a crash.
    println!("{:?} {:?}", counts.get("a"), counts.get("z"));

    // BTreeMap keeps its keys in order, which HashMap deliberately does not.
    let sorted: BTreeMap<_, _> = counts.iter().collect();
    println!("{sorted:?}");

    // A set, and a queue with cheap pushes at both ends.
    let unique: HashSet<i32> = vec![1, 2, 2, 3].into_iter().collect();
    let mut queue: VecDeque<i32> = VecDeque::new();
    queue.push_back(1);
    queue.push_front(0);
    println!("{} unique, queue {queue:?}", unique.len());

    strings();
}

/// The two string types, which is the part that trips people up.
fn strings() {
    // String owns its bytes on the heap and can grow.
    let mut owned = String::from("hello");
    owned.push_str(", world");
    owned.push('!');

    // &str borrows a run of bytes that somebody else owns. A literal is a
    // &'static str pointing into the binary.
    let borrowed: &str = "just reading";
    let slice: &str = &owned[0..5];

    println!("{owned} / {borrowed} / {slice}");

    // Rust strings are UTF-8, so there is no indexing by character. Ask for
    // what you actually want: bytes, or chars, or graphemes from a crate.
    let text = "café";
    println!("{} bytes, {} chars", text.len(), text.chars().count());
    println!("{:?}", text.chars().rev().collect::<String>());

    // Take &str in arguments and return String when you produce something
    // new. That way callers can pass either without allocating.
    println!("{}", shout("quietly"));
}

fn shout(text: &str) -> String {
    format!("{}!", text.to_uppercase())
}

//! Iterators. They are lazy, they compile down to the loop you would have
//! written by hand, and they are the main reason Rust code reads well.

#[derive(Debug, Clone)]
struct Order {
    item: String,
    quantity: u32,
    price: f64,
}

fn main() {
    let numbers: Vec<i32> = (1..=10).collect();

    // Nothing happens until something consumes the chain. map and filter
    // build a description; sum runs it, once, in one pass.
    let total: i32 = numbers.iter().filter(|n| *n % 2 == 0).map(|n| n * n).sum();
    println!("{total}");

    // Three ways to iterate, and the difference is ownership.
    //   iter()      yields &T,     the collection is untouched
    //   iter_mut()  yields &mut T, the elements can be changed
    //   into_iter() yields T,      the collection is consumed
    let mut words = vec![String::from("one"), String::from("two")];
    for word in words.iter() {
        print!("{word} ");
    }
    for word in words.iter_mut() {
        word.push('!');
    }
    println!("{words:?}");

    let orders = vec![
        Order { item: "book".into(), quantity: 2, price: 12.5 },
        Order { item: "pen".into(), quantity: 10, price: 1.2 },
        Order { item: "desk".into(), quantity: 1, price: 210.0 },
    ];

    // The chain everyone ends up writing, and it stays readable.
    let large_total: f64 = orders
        .iter()
        .filter(|order| order.price > 10.0)
        .map(|order| order.price * f64::from(order.quantity))
        .sum();
    println!("{large_total:.2}");

    // Collecting into a different shape.
    let names: Vec<&str> = orders.iter().map(|o| o.item.as_str()).collect();
    println!("{names:?}");

    // A Result inside a collect turns a list of results into a result of a
    // list, which is exactly what you want when parsing input.
    let parsed: Result<Vec<i32>, _> = ["1", "2", "3"].iter().map(|s| s.parse::<i32>()).collect();
    println!("{parsed:?}");
    let failed: Result<Vec<i32>, _> = ["1", "x"].iter().map(|s| s.parse::<i32>()).collect();
    println!("{}", failed.is_err());

    // The adapters worth knowing by name.
    println!("{:?}", numbers.iter().take(3).collect::<Vec<_>>());
    println!("{:?}", numbers.iter().skip(7).collect::<Vec<_>>());
    println!("{:?}", numbers.iter().rev().take(2).collect::<Vec<_>>());
    println!("{:?}", numbers.chunks(4).collect::<Vec<_>>());
    println!("{:?}", numbers.windows(3).next());
    println!("{:?}", numbers.iter().zip("abc".chars()).collect::<Vec<_>>());
    println!("{:?}", numbers.iter().enumerate().find(|(_, n)| **n > 8));
    println!("{:?}", numbers.iter().position(|n| *n == 5));
    println!("{}", numbers.iter().any(|n| *n > 9));
    println!("{}", numbers.iter().all(|n| *n > 0));
    println!("{:?}", numbers.iter().max());
    println!("{:?}", numbers.iter().fold(0, |acc, n| acc + n));

    // flat_map and filter_map, for when each element gives zero or more.
    let lines = vec!["1 2", "3", "not a number"];
    let all: Vec<i32> = lines
        .iter()
        .flat_map(|line| line.split_whitespace())
        .filter_map(|word| word.parse().ok())
        .collect();
    println!("{all:?}");

    // Writing your own iterator is one method.
    let fib: Vec<u64> = Fibonacci::new().take(10).collect();
    println!("{fib:?}");
}

struct Fibonacci {
    current: u64,
    next: u64,
}

impl Fibonacci {
    fn new() -> Self {
        Fibonacci { current: 0, next: 1 }
    }
}

impl Iterator for Fibonacci {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        let value = self.current;
        self.current = self.next;
        self.next = value + self.next;
        Some(value)
    }
}