Bisecting and matrix goop

leetcode/.python-version

@@ -0,0 +1 @@
+3.12.0

leetcode/pyproject.toml

@@ -0,0 +1,156 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "leetcode"
+description = 'What A Mess'
+readme = "README.md"
+version = "0.1.0"
+requires-python = ">=3.7"
+license = "MIT"
+keywords = []
+authors = [
+  { name = "Dan Buch", email = "dan@meatballhat.com" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.7",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "ipython"
+]
+
+[project.urls]
+Documentation = "https://github.com/unknown/leetcode#readme"
+Issues = "https://github.com/unknown/leetcode/issues"
+Source = "https://github.com/unknown/leetcode"
+
+[tool.hatch.envs.default]
+dependencies = [
+  "coverage[toml]>=6.5",
+  "pytest",
+]
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+  "- coverage combine",
+  "coverage report",
+]
+cov = [
+  "test-cov",
+  "cov-report",
+]
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.7", "3.8", "3.9", "3.10", "3.11"]
+
+[tool.hatch.envs.lint]
+detached = true
+dependencies = [
+  "black>=23.1.0",
+  "mypy>=1.0.0",
+  "ruff>=0.0.243",
+]
+[tool.hatch.envs.lint.scripts]
+typing = "mypy --install-types --non-interactive {args:src/leetcode tests}"
+style = [
+  "ruff {args:.}",
+  "black --check --diff {args:.}",
+]
+fmt = [
+  "black {args:.}",
+  "ruff --fix {args:.}",
+  "style",
+]
+all = [
+  "style",
+  "typing",
+]
+
+[tool.black]
+target-version = ["py37"]
+line-length = 120
+skip-string-normalization = true
+
+[tool.ruff]
+target-version = "py37"
+line-length = 120
+select = [
+  "A",
+  "ARG",
+  "B",
+  "C",
+  "DTZ",
+  "E",
+  "EM",
+  "F",
+  "FBT",
+  "I",
+  "ICN",
+  "ISC",
+  "N",
+  "PLC",
+  "PLE",
+  "PLR",
+  "PLW",
+  "Q",
+  "RUF",
+  "S",
+  "T",
+  "TID",
+  "UP",
+  "W",
+  "YTT",
+]
+ignore = [
+  # Allow non-abstract empty methods in abstract base classes
+  "B027",
+  # Allow boolean positional values in function calls, like `dict.get(... True)`
+  "FBT003",
+  # Ignore checks for possible passwords
+  "S105", "S106", "S107",
+  # Ignore complexity
+  "C901", "PLR0911", "PLR0912", "PLR0913", "PLR0915",
+]
+unfixable = [
+  # Don't touch unused imports
+  "F401",
+]
+
+[tool.ruff.isort]
+known-first-party = ["leetcode"]
+
+[tool.ruff.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.per-file-ignores]
+# Tests can use magic values, assertions, and relative imports
+"tests/**/*" = ["PLR2004", "S101", "TID252"]
+
+[tool.coverage.run]
+source_pkgs = ["leetcode", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/leetcode/__about__.py",
+]
+
+[tool.coverage.paths]
+leetcode = ["src/leetcode", "*/leetcode/src/leetcode"]
+tests = ["tests", "*/leetcode/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

leetcode/stuff.py

@@ -0,0 +1,131 @@
+import enum
+import itertools
+import pprint
+import typing
+
+
+def yep(s: str) -> bool:
+    return s.strip().lower().startswith("y")
+
+
+def guess_bisect_repl(lower: int, upper: int) -> int:
+    mid = lower + ((upper - lower) // 2)
+
+    if yep(input(f"is it {mid}? ")):
+        return mid
+
+    if yep(input(f"higher than {mid}? ")):
+        return guess_bisect_repl(mid, upper)
+
+    return guess_bisect_repl(lower, mid)
+
+
+def find_sqrt_ish(n: int) -> int:
+    return int(find_bisect(0, n, gen_sqrt_check(n)))
+
+
+def gen_sqrt_check(n: int) -> typing.Callable[[float], int]:
+    def check(mid: float) -> int:
+        mid_sq: float = mid * mid
+
+        if mid_sq == n:
+            return 0
+
+        if mid_sq < n:
+            return 1
+
+        return -1
+
+    return check
+
+
+def find_bisect(lower: float, upper: float, check: typing.Callable[[float], int]) -> float:
+    mid: float = lower + ((upper - lower) / 2)
+
+    print(f"lower={lower} mid={mid} upper={upper}")
+
+    if mid == lower or mid == upper or check(mid) == 0:
+        return mid
+
+    if check(mid) == 1:
+        return find_bisect(mid, upper, check)
+
+    return find_bisect(lower, mid, check)
+
+
+def cartesian_path(p0: tuple[int, int], p1: tuple[int, int]) -> list[tuple[int, int]]:
+    path: list[tuple[int, int]] = []
+
+    if p0 < p1:
+        for i in range(p0[1], p1[1]):
+            path.append((i, p0[0]))
+
+        for i in range(p0[0], p1[0]):
+            path.append((p1[1], i))
+
+    else:
+        for i in range(p0[1], p1[1] - 1, -1):
+            path.append((i, p0[0]))
+
+        for i in range(p0[0] - 1, p1[0], -1):
+            path.append((p1[1], i))
+
+    return path
+
+
+def gen_matrix(width: int, height: int) -> list[list[int]]:
+    return [list(range(width)) for _ in range(height)]
+
+
+def matrix_spiral(matrix: list[list[typing.Any]]) -> list[typing.Any]:
+    return [matrix[y][x] for x, y in matrix_spiral_path(matrix)]
+
+
+def matrix_spiral_path(matrix: list[list[int]]) -> list[tuple[int, int]]:
+    snek = SpinSnek(matrix)
+
+    while snek.step():
+        ...
+
+    return snek.path
+
+
+class SpinSnek:
+    def __init__(self, board: list[list[int]], loc: tuple[int, int] = (0, 0)):
+        self.max_loc: tuple[int, int] = (len(board[0]) - 1, len(board) - 1)
+        self.spinner: itertools.cycle[tuple[int, int]] = itertools.cycle(
+            [
+                (1, 0),  # east
+                (0, 1),  # south
+                (-1, 0),  # west
+                (0, -1),  # north
+            ]
+        )
+        self.direction = next(self.spinner)
+        self.path: list[tuple[int, int]] = [loc]
+        self.missteps: int = 0
+
+    def step(self) -> bool:
+        loc = self.path[-1]
+        next_loc: tuple[int, int] = (
+            loc[0] + self.direction[0],
+            loc[1] + self.direction[1],
+        )
+
+        if (
+            next_loc[0] > self.max_loc[0]
+            or next_loc[1] > self.max_loc[1]
+            or next_loc[0] < 0
+            or next_loc[1] < 0
+            or next_loc in self.path
+        ):
+            self.direction = next(self.spinner)
+            if self.missteps > 3:
+                return False
+
+            self.missteps += 1
+            return self.step()
+
+        self.missteps: int = 0
+        self.path.append(next_loc)
+        return True

leetcode/test_stuff.py

@@ -0,0 +1,61 @@
+import pytest
+
+import stuff
+
+
+@pytest.mark.parametrize(
+    ("n", "expected"),
+    [
+        (0, 0),
+        (1, 1),
+        (5, 2),
+        (4, 2),
+        (8, 2),
+        (9, 3),
+    ],
+)
+def test_find_sqrt_ish(n: int, expected: int):
+    assert stuff.find_sqrt_ish(n) == expected
+
+
+@pytest.mark.parametrize(
+    ("matrix", "expected"),
+    [
+        (
+            [
+                ["a", "b", "c"],
+                ["d", "e", "f"],
+                ["g", "h", "i"],
+            ],
+            ["a", "b", "c", "f", "i", "h", "g", "d", "e"],
+        ),
+        (
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+            ],
+            [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7],
+        ),
+        (
+            [
+                [1, 2, 3, 4, 5, 6, 7, 8, 9],
+                [1, 2, 3, 4, 5, 6, 7, 8, 9],
+                [1, 2, 3, 4, 5, 6, 7, 8, 9],
+                [1, 2, 3, 4, 5, 6, 7, 8, 9],
+                [1, 2, 3, 4, 5, 6, 7, 8, 9],
+            ],
+            []
+            + [1, 2, 3, 4, 5, 6, 7, 8, 9]  # right
+            + [9, 9, 9]  # down
+            + [9, 8, 7, 6, 5, 4, 3, 2, 1]  # left
+            + [1, 1]  # up
+            + [1, 2, 3, 4, 5, 6, 7, 8]  # right
+            + [8]  # down
+            + [8, 7, 6, 5, 4, 3, 2]  # left
+            + [2, 3, 4, 5, 6, 7],  # right
+        ),
+    ],
+)
+def test_matrix_spiral(matrix, expected):
+    assert stuff.matrix_spiral(matrix) == expected

rustbyexample/.gitignore

@@ -1,11 +1,3 @@
-/custom_types/*
-/hello/*
-/primitives/*
-/variable_bindings/*
-/types/*
-
-!/custom_types/*.rs
-!/hello/*.rs
-!/primitives/*.rs
-!/variable_bindings/*.rs
-!/types/*.rs
+/out/
+/*.d/out
+/*.d/**/out

rustbyexample/conversion.d/from_into.rs

@@ -0,0 +1,18 @@
+use std::convert::From;
+
+#[allow(dead_code)]
+#[derive(Debug)]
+struct Number {
+    value: i32,
+}
+
+impl From<i32> for Number {
+    fn from(item: i32) -> Self {
+        Number { value: item }
+    }
+}
+
+fn main() {
+    let num = Number::from(30);
+    println!("My number is {:?}", num);
+}

rustbyexample/conversion.d/from_into2.rs

@@ -0,0 +1,19 @@
+use std::convert::Into;
+
+#[allow(dead_code)]
+#[derive(Debug)]
+struct Number {
+    value: i32,
+}
+
+impl Into<Number> for i32 {
+    fn into(self) -> Number {
+        Number { value: self }
+    }
+}
+
+fn main() {
+    let int = 5;
+    let num: Number = int.into();
+    println!("My number is {:?}", num);
+}

rustbyexample/conversion.d/string.rs

@@ -0,0 +1,16 @@
+use std::fmt;
+
+struct Circle {
+    radius: i32,
+}
+
+impl fmt::Display for Circle {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Circle of radius {}", self.radius)
+    }
+}
+
+fn main() {
+    let circle = Circle { radius: 6 };
+    println!("{}", circle.to_string());
+}

rustbyexample/conversion.d/string2.rs

@@ -0,0 +1,7 @@
+fn main() {
+    let parsed: i32 = "5".parse().unwrap();
+    let turbo_parsed = "10".parse::<i32>().unwrap();
+
+    let sum = parsed + turbo_parsed;
+    println!("Sum: {:?}", sum);
+}

rustbyexample/conversion.d/try_from_try_into.rs

@@ -0,0 +1,28 @@
+use std::convert::TryFrom;
+use std::convert::TryInto;
+
+#[derive(Debug, PartialEq)]
+struct EvenNumber(i32);
+
+impl TryFrom<i32> for EvenNumber {
+    type Error = ();
+
+    fn try_from(value: i32) -> Result<Self, Self::Error> {
+        if value % 2 == 0 {
+            Ok(EvenNumber(value))
+        } else {
+            Err(())
+        }
+    }
+}
+
+fn main() {
+    assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8)));
+    assert_eq!(EvenNumber::try_from(5), Err(()));
+
+    let result: Result<EvenNumber, ()> = 8i32.try_into();
+    assert_eq!(result, Ok(EvenNumber(8)));
+
+    let result: Result<EvenNumber, ()> = 5i32.try_into();
+    assert_eq!(result, Err(()));
+}

rustbyexample/custom_types.d/structs.rs

@@ -1,3 +1,4 @@
+#[allow(dead_code)]
 #[derive(Debug)]
 struct Person {
     name: String,

rustbyexample/expression.rs

@@ -0,0 +1,25 @@
+#[allow(path_statements)]
+#[allow(unused_must_use)]
+fn main() {
+    let x = 5;
+    x;
+    x + 1;
+    15;
+
+    let x = 5u32;
+
+    let y = {
+        let x_squared = x * x;
+        let x_cube = x_squared * x;
+
+        x_cube + x_squared + x
+    };
+
+    let z = {
+        2 * x;
+    };
+
+    println!("x is {:?}", x);
+    println!("y is {:?}", y);
+    println!("z is {:?}", z);
+}

rustbyexample/flow_control.d/for.rs

@@ -0,0 +1,13 @@
+fn main() {
+    for n in 1..101 {
+        if n % 15 == 0 {
+            println!("fizzbuzz");
+        } else if n % 3 == 0 {
+            println!("fizz");
+        } else if n % 5 == 0 {
+            println!("buzz");
+        } else {
+            println!("{}", n);
+        }
+    }
+}

rustbyexample/flow_control.d/for2.rs

@@ -0,0 +1,13 @@
+fn main() {
+    for n in 1..=100 {
+        if n % 15 == 0 {
+            println!("fizzbuzz");
+        } else if n % 3 == 0 {
+            println!("fizz");
+        } else if n % 5 == 0 {
+            println!("buzz");
+        } else {
+            println!("{}", n);
+        }
+    }
+}

rustbyexample/flow_control.d/for3.rs

@@ -0,0 +1,12 @@
+fn main() {
+    let names = vec!["Bob", "Frank", "Ferris"];
+
+    for name in names.iter() {
+        match name {
+            &"Ferris" => println!("There is a rustacean among us!"),
+            _ => println!("Hello {}", name),
+        }
+    }
+
+    println!("names: {:?}", names);
+}

rustbyexample/flow_control.d/for4.rs

@@ -0,0 +1,12 @@
+fn main() {
+    let names = vec!["Bob", "Frank", "Ferris"];
+
+    for name in names.into_iter() {
+        match name {
+            "Ferris" => println!("There is a rustacean among us!"),
+            _ => println!("Hello {}", name),
+        }
+    }
+
+    //println!("names: {:?}", names);
+}

rustbyexample/flow_control.d/for5.rs

@@ -0,0 +1,12 @@
+fn main() {
+    let mut names = vec!["Bob", "Frank", "Ferris"];
+
+    for name in names.iter_mut() {
+        *name = match name {
+            &mut "Ferris" => "There is a rustacean among us!",
+            _ => "Hello",
+        }
+    }
+
+    println!("names: {:?}", names);
+}

rustbyexample/flow_control.d/if_else.rs

@@ -0,0 +1,23 @@
+fn main() {
+    let n = 5;
+
+    if n < 0 {
+        print!("{} is negative", n);
+    } else if n > 0 {
+        print!("{} is positive", n);
+    } else {
+        print!("{} is zero", n);
+    }
+
+    let big_n = if n < 10 && n > -10 {
+        println!(", and is a small number, increase net-fold");
+
+        10 * n
+    } else {
+        println!(", and is a big number, halve the number");
+
+        n / 2
+    };
+
+    println!("{} -> {}", n, big_n);
+}

rustbyexample/flow_control.d/if_let.rs

@@ -0,0 +1,25 @@
+fn main() {
+    let number = Some(7);
+    let letter: Option<i32> = None;
+    let emoticon: Option<i32> = None;
+
+    if let Some(i) = number {
+        println!("Matched {:?}!", i);
+    }
+
+    if let Some(i) = letter {
+        println!("Matched {:?}!", i);
+    } else {
+        println!("Didn't match a number. Let's go with a letter!");
+    }
+
+    let i_like_letters = false;
+
+    if let Some(i) = emoticon {
+        println!("Matched {:?}!", i);
+    } else if i_like_letters {
+        println!("Didn't match a number. Let's go with a letter!");
+    } else {
+        println!("I don't like letters. Let's go with an emoticon :)!");
+    }
+}

rustbyexample/flow_control.d/if_let2.rs

@@ -0,0 +1,27 @@
+enum Foo {
+    Bar,
+    Baz,
+    Qux(u32),
+}
+
+fn main() {
+    let a = Foo::Bar;
+    let b = Foo::Baz;
+    let c = Foo::Qux(100);
+
+    if let Foo::Bar = a {
+        println!("a is a foobar");
+    }
+
+    if let Foo::Bar = b {
+        println!("b is foobar");
+    }
+
+    if let Foo::Qux(value) = c {
+        println!("c is {}", value);
+    }
+
+    if let Foo::Qux(value @ 100) = c {
+        println!("c is one hundred (value: {:?})", value);
+    }
+}

rustbyexample/flow_control.d/if_let3.rs

@@ -0,0 +1,11 @@
+enum Foo {
+    Bar,
+}
+
+fn main() {
+    let a = Foo::Bar;
+
+    if let Foo::Bar = a {
+        println!("a is foobar");
+    }
+}

rustbyexample/flow_control.d/let_else.rs

@@ -0,0 +1,16 @@
+use std::str::FromStr;
+
+fn get_count_item(s: &str) -> (u64, &str) {
+    let mut it = s.split(' ');
+    let (Some(count_str), Some(item)) = (it.next(), it.next()) else {
+        panic!("Can't segment count item pair: '{s}'");
+    };
+    let Ok(count) = u64::from_str(count_str) else {
+        panic!("Can't parse integer: '{count_str}'");
+    };
+    (count, item)
+}
+
+fn main() {
+    assert_eq!(get_count_item("3 chairs"), (3, "chairs"));
+}

rustbyexample/flow_control.d/loop.d/nested.rs

@@ -0,0 +1,18 @@
+#![allow(unreachable_code)]
+#![allow(unused_labels)]
+
+fn main() {
+    'outer: loop {
+        println!("Entered the outer loop");
+
+        'inner: loop {
+            println!("Entered the inner loop");
+
+            break 'outer;
+        }
+
+        println!("This point will never be reached");
+    }
+
+    println!("Exited the outer loop");
+}

rustbyexample/flow_control.d/loop.d/return.rs

@@ -0,0 +1,13 @@
+fn main() {
+    let mut counter = 0;
+
+    let result = loop {
+        counter += 1;
+
+        if counter == 10 {
+            break counter * 2;
+        }
+    };
+
+    assert_eq!(result, 20);
+}

rustbyexample/flow_control.d/loop.rs

@@ -0,0 +1,23 @@
+fn main() {
+    let mut count = 0u32;
+
+    println!("Let's count until infinity!");
+
+    loop {
+        count += 1;
+
+        if count == 3 {
+            println!("three");
+
+            continue;
+        }
+
+        println!("{}", count);
+
+        if count == 5 {
+            println!("OK, that's enough");
+
+            break;
+        }
+    }
+}

rustbyexample/flow_control.d/match.d/binding.rs

@@ -0,0 +1,14 @@
+fn age() -> u32 {
+    15
+}
+
+fn main() {
+    println!("Tell me what type of person you are");
+
+    match age() {
+        0 => println!("I haven't celebrated my first birthday yet"),
+        n @ 1..=12 => println!("I'm a child of age {:?}", n),
+        n @ 13..=19 => println!("I'm a teen of age {:?}", n),
+        n => println!("I'm an old person of age {:?}", n),
+    }
+}

rustbyexample/flow_control.d/match.d/binding2.rs

@@ -0,0 +1,11 @@
+fn some_number() -> Option<u32> {
+    Some(42)
+}
+
+fn main() {
+    match some_number() {
+        Some(n @ 42) => println!("The Answer: {}!", n),
+        Some(n) => println!("Not interesting... {}", n),
+        _ => (),
+    }
+}

rustbyexample/flow_control.d/match.d/destructuring.d/destructure_enum.rs

@@ -0,0 +1,30 @@
+#[allow(dead_code)]
+enum Color {
+    Red,
+    Blue,
+    Green,
+    RGB(u32, u32, u32),
+    HSV(u32, u32, u32),
+    HSL(u32, u32, u32),
+    CMY(u32, u32, u32),
+    CMYK(u32, u32, u32, u32),
+}
+
+fn main() {
+    let color = Color::RGB(122, 17, 40);
+
+    println!("What color is it?");
+    match color {
+        Color::Red => println!("The color is Red!"),
+        Color::Blue => println!("The color is Blue!"),
+        Color::Green => println!("The color is Green!"),
+        Color::RGB(r, g, b) => println!("Red: {}, green: {}, and blue: {}!", r, g, b),
+        Color::HSV(h, s, v) => println!("Hue: {}, saturation: {}, value: {}!", h, s, v),
+        Color::HSL(h, s, l) => println!("Hue: {}, saturation: {}, lightness: {}!", h, s, l),
+        Color::CMY(c, m, y) => println!("Cyan: {}, magenta: {}, yellow: {}!", c, m, y),
+        Color::CMYK(c, m, y, k) => println!(
+            "Cyan: {}, magenta: {}, yellow: {}, key (black): {}!",
+            c, m, y, k
+        ),
+    }
+}

rustbyexample/flow_control.d/match.d/destructuring.d/destructure_pointers.rs

@@ -0,0 +1,29 @@
+fn main() {
+    let reference = &4;
+
+    match reference {
+        &val => println!("Got a value via destructuring: {:?}", val),
+    }
+
+    match *reference {
+        val => println!("Got a value via dereferencing: {:?}", val),
+    }
+
+    let _not_a_reference = 3;
+
+    let ref _is_a_reference = 3;
+
+    let value = 5;
+    let mut mut_value = 6;
+
+    match value {
+        ref r => println!("Got a reference to a value: {:?}", r),
+    }
+
+    match mut_value {
+        ref mut m => {
+            *m += 10;
+            println!("We added 10. `mut_value`: {:?}", m);
+        }
+    }
+}

rustbyexample/flow_control.d/match.d/destructuring.d/destructure_slice.rs

@@ -0,0 +1,27 @@
+fn main() {
+    let array = [1, -2, 6];
+
+    match array {
+        [0, second, third] => println!("array[0] = 0, array[1] = {}, array[2] = {}", second, third),
+
+        [1, _, third] => println!(
+            "array[0] = 1, array[2] = {} and array[1] was ignored",
+            third
+        ),
+
+        [-1, second, ..] => println!(
+            "array[0] = -1, array[1] = {} and all the other ones were ignored",
+            second
+        ),
+
+        [3, second, tail @ ..] => println!(
+            "array[0] = 3, array[1] = {} and the other elements were {:?}",
+            second, tail
+        ),
+
+        [first, middle @ .., last] => println!(
+            "array[0] = {}, middle = {:?}, array[2] = {}",
+            first, middle, last
+        ),
+    }
+}

rustbyexample/flow_control.d/match.d/destructuring.d/destructure_structures.rs

@@ -0,0 +1,19 @@
+fn main() {
+    struct Foo {
+        x: (u32, u32),
+        y: u32,
+    }
+
+    let foo = Foo { x: (1, 2), y: 3 };
+
+    match foo {
+        Foo { x: (1, b), y } => println!("First of x is 1, b = {}, y = {}", b, y),
+        Foo { y: 2, x: i } => println!("y is 2, i = {:?}", i),
+        Foo { y, .. } => println!("y = {}, we don't care about x", y),
+    }
+
+    let faa = Foo { x: (1, 2), y: 3 };
+
+    let Foo { x: x0, y: y0 } = faa;
+    println!("Outside: x0 = {x0:?}, y0 = {y0}");
+}

rustbyexample/flow_control.d/match.d/destructuring.d/destructure_tuple.rs

@@ -0,0 +1,12 @@
+fn main() {
+    let triple = (0, -2, 3);
+
+    println!("Tell me about {:?}", triple);
+    match triple {
+        (0, y, z) => println!("First is `0`, `y` is {:?}, and `z` is {:?}", y, z),
+        (1, ..) => println!("First is `1` and the rest doesn't matter"),
+        (.., 2) => println!("last is `2` and the rest doesn't matter"),
+        (3, .., 4) => println!("First is `3`, last is `4`, and the rest doesn't matter"),
+        _ => println!("It doesn't matter what they are"),
+    }
+}

rustbyexample/flow_control.d/match.d/guard.rs

@@ -0,0 +1,16 @@
+#[allow(dead_code)]
+enum Temperature {
+    Celsius(i32),
+    Fahrenheit(i32),
+}
+
+fn main() {
+    let temperature = Temperature::Celsius(35);
+
+    match temperature {
+        Temperature::Celsius(t) if t > 30 => println!("{}C is above 30 Celsius", t),
+        Temperature::Celsius(t) => println!("{}C is below 30 Celsius", t),
+        Temperature::Fahrenheit(t) if t > 86 => println!("{}F is above 86 Fahrenheit", t),
+        Temperature::Fahrenheit(t) => println!("{}F is below 86 Fahrenheit", t),
+    }
+}

rustbyexample/flow_control.d/match.d/guard2.rs

@@ -0,0 +1,9 @@
+fn main() {
+    let number: u8 = 4;
+
+    match number {
+        i if i == 0 => println!("Zero"),
+        i if i > 0 => println!("Greater than zero"),
+        _ => unreachable!("Should never happen."),
+    }
+}

rustbyexample/flow_control.d/match.rs

@@ -0,0 +1,19 @@
+fn main() {
+    let number = 13;
+
+    println!("Tell me about {}", number);
+    match number {
+        1 => println!("One!"),
+        2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
+        13..=19 => println!("A teen"),
+        _ => println!("Ain't special"),
+    }
+
+    let boolean = true;
+    let binary = match boolean {
+        false => 0,
+        true => 1,
+    };
+
+    println!("{} -> {}", boolean, binary);
+}

rustbyexample/flow_control.d/while.rs

@@ -0,0 +1,17 @@
+fn main() {
+    let mut n = 1;
+
+    while n < 101 {
+        if n % 15 == 0 {
+            println!("fizzbuzz");
+        } else if n % 3 == 0 {
+            println!("fizz");
+        } else if n % 5 == 0 {
+            println!("buzz");
+        } else {
+            println!("{}", n);
+        }
+
+        n += 1;
+    }
+}

rustbyexample/flow_control.d/while_let.rs

@@ -0,0 +1,13 @@
+fn main() {
+    let mut optional = Some(0);
+
+    while let Some(i) = optional {
+        if i > 9 {
+            println!("Greater than 9, quit!");
+            optional = None;
+        } else {
+            println!("`i` is `{:?}`. Try again.", i);
+            optional = Some(i + 1);
+        }
+    }
+}

rustbyexample/fn.d/closures.d/anonymity.rs

@@ -0,0 +1,14 @@
+fn apply<F>(f: F)
+where
+    F: Fn(),
+{
+    f();
+}
+
+fn main() {
+    let x = 7;
+
+    let print = || println!("{}", x);
+
+    apply(print);
+}

rustbyexample/fn.d/closures.d/capture.rs

@@ -0,0 +1,36 @@
+fn main() {
+    use std::mem;
+
+    let color = String::from("green");
+
+    let print = || println!("`color`: {}", color);
+
+    print();
+
+    let _reborrow = &color;
+    print();
+
+    let _color_moved = color;
+
+    let mut count = 0;
+
+    let mut inc = || {
+        count += 1;
+        println!("`count`: {}", count);
+    };
+
+    inc();
+
+    inc();
+
+    let _count_reborrowed = &mut count;
+
+    let movable = Box::new(3);
+
+    let consume = || {
+        println!("`movable`: {:?}", movable);
+        mem::drop(movable);
+    };
+
+    consume();
+}

rustbyexample/fn.d/closures.d/capture2.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let haystack = vec![1, 2, 3];
+
+    let contains = move |needle| haystack.contains(needle);
+
+    println!("{}", contains(&1));
+    println!("{}", contains(&4));
+}

rustbyexample/fn.d/closures.d/input_parameters.rs

@@ -0,0 +1,36 @@
+fn apply<F>(f: F)
+where
+    F: FnOnce(),
+{
+    f();
+}
+
+fn apply_to_3<F>(f: F) -> i32
+where
+    F: Fn(i32) -> i32,
+{
+    f(3)
+}
+
+fn main() {
+    use std::mem;
+
+    let greeting = "hello";
+    let mut farewell = "goodbye".to_owned();
+
+    let diary = || {
+        println!("I said {}.", greeting);
+
+        farewell.push_str("!!!");
+        println!("Then I screamed {}.", farewell);
+        println!("Now I can sleep. zzzzz");
+
+        mem::drop(farewell);
+    };
+
+    apply(diary);
+
+    let double = |x| 2 * x;
+
+    println!("3 doubled: {}", apply_to_3(double));
+}

rustbyexample/fn.d/closures.rs

@@ -0,0 +1,12 @@
+fn main() {
+    let outer_var = 42;
+
+    let closure_annotated = |i: i32| -> i32 { i + outer_var };
+    let closure_inferred = |i| i + outer_var;
+
+    println!("closure_annotated: {}", closure_annotated(1));
+    println!("closure_inferred: {}", closure_inferred(1));
+
+    let one = || 1;
+    println!("closure returning one: {}", one());
+}

rustbyexample/fn.d/methods.rs

@@ -0,0 +1,74 @@
+struct Point {
+    x: f64,
+    y: f64,
+}
+
+impl Point {
+    fn origin() -> Point {
+        Point { x: 0.0, y: 0.0 }
+    }
+
+    fn new(x: f64, y: f64) -> Point {
+        Point { x: x, y: y }
+    }
+}
+
+struct Rectangle {
+    p1: Point,
+    p2: Point,
+}
+
+impl Rectangle {
+    fn area(&self) -> f64 {
+        let Point { x: x1, y: y1 } = self.p1;
+        let Point { x: x2, y: y2 } = self.p2;
+
+        ((x1 - x2) * (y1 - y2)).abs()
+    }
+
+    fn perimeter(&self) -> f64 {
+        let Point { x: x1, y: y1 } = self.p1;
+        let Point { x: x2, y: y2 } = self.p2;
+
+        2.0 * ((x1 - x2).abs() + (y1 - y2).abs())
+    }
+
+    fn translate(&mut self, x: f64, y: f64) {
+        self.p1.x += x;
+        self.p2.x += x;
+
+        self.p1.y += y;
+        self.p2.y += y;
+    }
+}
+
+struct Pair(Box<i32>, Box<i32>);
+
+impl Pair {
+    fn destroy(self) {
+        let Pair(first, second) = self;
+
+        println!("Destroying Pair({}, {})", first, second);
+    }
+}
+
+fn main() {
+    let rectangle = Rectangle {
+        p1: Point::origin(),
+        p2: Point::new(3.0, 4.0),
+    };
+
+    println!("Rectangle perimeter: {}", rectangle.perimeter());
+    println!("Rectangle area: {}", rectangle.area());
+
+    let mut square = Rectangle {
+        p1: Point::origin(),
+        p2: Point::new(1.0, 1.0),
+    };
+
+    square.translate(1.0, 1.0);
+
+    let pair = Pair(Box::new(1), Box::new(2));
+
+    pair.destroy();
+}

rustbyexample/fn.rs

@@ -0,0 +1,29 @@
+fn main() {
+    fizzbuzz_to(100);
+}
+
+fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
+    if rhs == 0 {
+        return false;
+    }
+
+    lhs % rhs == 0
+}
+
+fn fizzbuzz(n: u32) -> () {
+    if is_divisible_by(n, 15) {
+        println!("fizzbuzz");
+    } else if is_divisible_by(n, 3) {
+        println!("fizz");
+    } else if is_divisible_by(n, 5) {
+        println!("buzz");
+    } else {
+        println!("{}", n);
+    }
+}
+
+fn fizzbuzz_to(n: u32) {
+    for n in 1..=n {
+        fizzbuzz(n);
+    }
+}

rustbyexample/hello.d/print.d/print_debug2.rs

@@ -1,3 +1,4 @@
+#[allow(dead_code)]
 #[derive(Debug)]
 struct Person<'a> {
     name: &'a str,

rustbyexample/hello.d/print.d/print_display.d/testcase_list.rs

@@ -20,6 +20,6 @@ impl fmt::Display for List {
 }
 
 fn main() {
-    let v = List(vec![1, 2, 3]);
+    let v = List(vec![6, 0, 6, 8, 0, 8, 9, 1, 1, 1, 3, 1, 2]);
     println!("{}", v);
 }

rustbyexample/primitives.d/array.rs

@@ -22,5 +22,14 @@ fn main() {
     println!("borrow a section of the array as a slice");
     analyze_slice(&ys[1..4]);
 
-    // println!("{}", xs[5]);
+    let empty_array: [u32; 0] = [];
+    assert_eq!(&empty_array, &[]);
+    assert_eq!(&empty_array, &[][..]);
+
+    for i in 0..xs.len() + 1 {
+        match xs.get(i) {
+            Some(xval) => println!("{}: {}", i, xval),
+            None => println!("Slow down! {} is too far!", i),
+        }
+    }
 }

rustbyexample/primitives.d/literals.rs

@@ -3,6 +3,8 @@ fn main() {
 
     println!("1 - 2 = {}", 1i32 - 2);
 
+    println!("1e4 is {}, -2.5e-3 is {}", 1e4, -2.5e-3);
+
     println!("true AND false is {}", true && false);
     println!("true OR false is {}", true || false);
     println!("NOT true is {}", !true);

rustbyexample/primitives.rs

@@ -1,3 +1,5 @@
+#[allow(unused_variables)]
+#[allow(unused_assignments)]
 fn main() {
     let logical: bool = true;
 

rustbyexample/types.d/alias.rs

@@ -0,0 +1,15 @@
+type NanoSecond = u64;
+type Inch = u64;
+type U64 = u64;
+
+fn main() {
+    let nanoseconds: NanoSecond = 5 as U64;
+    let inches: Inch = 2 as U64;
+
+    println!(
+        "{} nanoseconds + {} inches = {} unit?",
+        nanoseconds,
+        inches,
+        nanoseconds + inches
+    );
+}

rustbyexample/types/alias.rs

@@ -1,15 +0,0 @@
-type NanoSecond = u64;
-type Inch = u64;
-
-#[allow(non_camel_case_types)]
-type u64_t = u64;
-
-fn main() {
-    let nanoseconds: NanoSecond = 5 as u64_t;
-    let inches: Inch = 2 as u64_t;
-
-    println!("{} nanoseconds + {} inches = {} unit?",
-        nanoseconds,
-        inches,
-        nanoseconds + inches);
-}

rustbyexample/variable_bindings.d/scope2.rs

@@ -13,4 +13,3 @@ fn main() {
     let shadowed_binding = 2;
     println!("shadowed in outer block: {}", shadowed_binding);
 }
-

rustbyexample/variable_bindings.rs

@@ -11,5 +11,5 @@ fn main() {
 
     let _unused_variable = 3u32;
 
-    let noisy_unused_variable = 2u32;
+    let _noisy_unused_variable = 2u32;
 }