chapter_10/chapter-10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c1517920-b1f6-440c-b5c8-4df6bec2fbc1",
   "metadata": {},
   "source": [
    "# Google Colab Rust Setup\n",
    "\n",
    "The following cell is used to set up and spin up a Jupyter Notebook environment with a Rust kernel using Nix and IPC Proxy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbf50b02-3730-4aa0-af49-16c1546fd09e",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -qO- https://gist.github.com/wiseaidev/2af6bef753d48565d11bcd478728c979/archive/3f6df40db09f3517ade41997b541b81f0976c12e.tar.gz | tar xvz --strip-components=1\n",
    "!bash setup_evcxr_kernel.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60c8d72c-b011-4360-b368-d540b8d7361a",
   "metadata": {},
   "source": [
    "## Iterators and Closures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38339871-7f3d-49d8-9b4f-e77f9e2a88da",
   "metadata": {},
   "source": [
    "### Anatomy of an Iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a163999f-7353-4fb9-88cf-61ac934c34f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the first 10 prime numbers is: 129\n"
     ]
    }
   ],
   "source": [
    "fn is_prime(n: u32) -> bool {\n",
    "    if n <= 1 {\n",
    "        return false;\n",
    "    }\n",
    "    for i in 2..(n / 2 + 1) {\n",
    "        if n % i == 0 {\n",
    "            return false;\n",
    "        }\n",
    "    }\n",
    "    true\n",
    "}\n",
    "\n",
    "fn sum_of_primes(n: u32) -> u32 {\n",
    "    (2..).filter(|&x| is_prime(x)).take(n as usize).sum()\n",
    "}\n",
    "\n",
    "let n = 10;\n",
    "let result = sum_of_primes(n);\n",
    "println!(\"The sum of the first {} prime numbers is: {}\", n, result);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95f2fdfa-0f86-4959-9ab7-5aa92de36ea9",
   "metadata": {},
   "source": [
    "### Key Traits: Iterator and IntoIterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "125e0cb0-88a3-49c3-bb79-c6b78171ec60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item: 42\n",
      "Item: 100\n",
      "Item: 7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct MyCollection {\n",
    "    data: Vec<i32>,\n",
    "}\n",
    "\n",
    "impl MyCollection {\n",
    "    fn new() -> Self {\n",
    "        MyCollection { data: Vec::new() }\n",
    "    }\n",
    "\n",
    "    fn add(&mut self, value: i32) {\n",
    "        self.data.push(value);\n",
    "    }\n",
    "}\n",
    "\n",
    "impl IntoIterator for MyCollection {\n",
    "    type Item = i32;\n",
    "    type IntoIter = std::vec::IntoIter<Self::Item>;\n",
    "\n",
    "    fn into_iter(self) -> Self::IntoIter {\n",
    "        self.data.into_iter()\n",
    "    }\n",
    "}\n",
    "\n",
    "\n",
    "let mut collection = MyCollection::new();\n",
    "\n",
    "collection.add(42);\n",
    "collection.add(100);\n",
    "collection.add(7);\n",
    "\n",
    "for item in collection {\n",
    "    println!(\"Item: {}\", item);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c4bb2d5-57a3-4075-b044-0898cb18a41e",
   "metadata": {},
   "source": [
    "### Creating Iterators with `from_fn` and `successors`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a501d270-db4d-474b-a37c-1439aff79ad6",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep rand = {version=\"0.8.5\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e43f6159-0e97-40f9-8fb1-702ac600f60c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.026231996097305532, 0.3638420476998353, 0.529187247261019, 0.3697265864723026, 0.9199704902784379, 0.0578703524231724, 0.2434883502345343, 0.1948597360516151, 0.38109952692955174, 0.47026570340584917]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use rand::random;\n",
    "\n",
    "use std::iter::from_fn;\n",
    "\n",
    "let lengths: Vec<f64> =\n",
    "    from_fn(|| Some((random::<f64>() - random::<f64>()).abs()))\n",
    "    .take(1000)\n",
    "    .collect();\n",
    "lengths[..10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a27b5c86-6134-4823-8484-019668dd97ad",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep num = {version=\"0.4.1\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "743e0887-3158-4a61-b6c5-152579c472e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escaped after 96 steps.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use num::Complex;\n",
    "use std::iter::successors;\n",
    "\n",
    "fn escape_time(c: Complex<f64>, limit: usize) -> Option<usize> {\n",
    "    let zero = Complex { re: 0.0, im: 0.0 };\n",
    "\n",
    "    let result = successors(Some(zero), |&z| Some(z * z + c))\n",
    "        .take(limit)\n",
    "        .enumerate()\n",
    "        .find(|(_i, z)| z.norm_sqr() > 4.0);\n",
    "\n",
    "    match result {\n",
    "        Some((i, _z)) => Some(i),\n",
    "        None => None,\n",
    "    }\n",
    "}\n",
    "\n",
    "let c = Complex { re: -0.7, im: 0.27015 };\n",
    "let limit = 1000;\n",
    "\n",
    "match escape_time(c, limit) {\n",
    "    Some(steps) => println!(\"Escaped after {} steps.\", steps),\n",
    "    None => println!(\"Did not escape within {} steps.\", limit),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "95d8e464-7461-4da3-9378-bfb599a8a864",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fibonacci sequence (first 8 numbers): [1, 1, 2, 3, 5, 8, 13, 21]\n"
     ]
    }
   ],
   "source": [
    "fn fibonacci() -> impl Iterator<Item = usize> {\n",
    "    let mut state = (0, 1);\n",
    "    std::iter::from_fn(move || {\n",
    "        state = (state.1, state.0 + state.1);\n",
    "        Some(state.0)\n",
    "    })\n",
    "}\n",
    "\n",
    "let result: Vec<usize> = fibonacci().take(8).collect();\n",
    "\n",
    "let expected = vec![1, 1, 2, 3, 5, 8, 13, 21];\n",
    "\n",
    "assert_eq!(result, expected);\n",
    "\n",
    "println!(\"Fibonacci sequence (first 8 numbers): {:?}\", result);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb679a2d-a3d3-4e8a-8ac4-e80114bd0040",
   "metadata": {},
   "source": [
    "### Drain Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "512ad7b2-b6ea-4a7b-a02b-04dabe326551",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"art\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut outer = \"Earth\".to_string();\n",
    "\n",
    "let inner = String::from_iter(outer.drain(1..4));\n",
    "\n",
    "assert_eq!(outer, \"Eh\");\n",
    "\n",
    "inner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88919fcd-07ec-47d5-8ca9-7a5ed088420e",
   "metadata": {},
   "source": [
    "### Iterator Adapter Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "004baf75-87f2-469b-93da-f4b16310bd9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = vec![1, 2, 3, 4, 5];\n",
    "\n",
    "let squared: Vec<i32> = numbers.into_iter().map(|x| x * x).collect();\n",
    "\n",
    "squared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6c832e12-9e25-44ed-9547-133150726c51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = 1..=10;\n",
    "\n",
    "let evens: Vec<i32> = numbers.into_iter().filter(|x| x % 2 == 0).collect();\n",
    "\n",
    "evens"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63ba2c2d-58e9-4eb4-b80e-59de8af58675",
   "metadata": {},
   "source": [
    "### Building Custom Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "875abcbf-9769-4347-9f60-b9f42fd7b3fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct PrimeGenerator {\n",
    "    current: u32,\n",
    "}\n",
    "\n",
    "impl Iterator for PrimeGenerator {\n",
    "    type Item = u32;\n",
    "\n",
    "    fn next(&mut self) -> Option<Self::Item> {\n",
    "        loop {\n",
    "            self.current += 1;\n",
    "            if is_prime(self.current) {\n",
    "                return Some(self.current);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "fn is_prime(num: u32) -> bool {\n",
    "    if num <= 1 {\n",
    "        return false;\n",
    "    }\n",
    "\n",
    "    for i in 2..(num / 2 + 1) {\n",
    "        if num % i == 0 {\n",
    "            return false;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    true\n",
    "}\n",
    "\n",
    "let prime_sequence = PrimeGenerator { current: 1 };\n",
    "\n",
    "for prime in prime_sequence.take(10) {\n",
    "    println!(\"{}\", prime);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c524bf-4542-4f49-844e-1a23297b8c85",
   "metadata": {},
   "source": [
    "### Lazy Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "784b82e1-b9c9-4696-a87e-58db53ce046a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = vec![1, 2, 3, 4, 5];\n",
    "\n",
    "let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();\n",
    "\n",
    "doubled"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f83b51dd-d82c-477d-922a-bb2d53e230e3",
   "metadata": {},
   "source": [
    "### Advanced Techniques"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "057dbe3d-35b3-4802-a203-be7487390e9d",
   "metadata": {},
   "source": [
    "#### flat_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0b06ea30-1017-41f6-a769-ecb23215a3c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['R', 'u', 's', 't', 'i', 's', 'a', 'w', 'e', 's', 'o', 'm', 'e']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let words = vec![\"Rust\", \"is\", \"awesome\"];\n",
    "\n",
    "let letters: Vec<char> = words.iter()\n",
    "    .flat_map(|&word| word.chars())\n",
    "    .collect();\n",
    "\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ee6c89b-de65-4d46-8bcf-1a0d10839e4c",
   "metadata": {},
   "source": [
    "#### take and skip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0de6c26a-7933-4981-b3ce-d81dcccfe432",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 7]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n",
    "\n",
    "let selected_numbers: Vec<i32> = numbers.iter()\n",
    "    .skip(3)\n",
    "    .take(4)\n",
    "    .cloned()\n",
    "    .collect();\n",
    "\n",
    "selected_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc860a6f-7390-4e3f-83ba-048755a1aa83",
   "metadata": {},
   "source": [
    "#### peekable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "094ed404-00c2-43ee-a344-4a60765799c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The next number is: 1\n",
      "The next number is: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut numbers = vec![1, 2, 3, 4, 5].into_iter().peekable();\n",
    "\n",
    "if let Some(&next_number) = numbers.peek() {\n",
    "    println!(\"The next number is: {}\", next_number);\n",
    "} else {\n",
    "    println!(\"No more numbers to process.\");\n",
    "}\n",
    "\n",
    "let _ = numbers.next();\n",
    "\n",
    "if let Some(&next_number) = numbers.peek() {\n",
    "    println!(\"The next number is: {}\", next_number);\n",
    "} else {\n",
    "   println!(\"No more numbers to process.\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dbdaca2-fe3f-4b12-bb7e-84c9aec3a5fa",
   "metadata": {},
   "source": [
    "#### filter_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f02f50e5-1a2e-4357-af94-7461cd88d1d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 19, 27, 33]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::str::FromStr;\n",
    "\n",
    "let text = \"The numbers are: 42, 19, invalid, 27, 33\";\n",
    "\n",
    "let parsed_numbers: Vec<i32> = text\n",
    "    .split(',')\n",
    "    .map(str::trim)\n",
    "    .filter_map(|s| {\n",
    "        let s = s\n",
    "            .chars()\n",
    "            .skip_while(|&c| !c.is_digit(10))\n",
    "            .collect::<String>();\n",
    "        if !s.is_empty() {\n",
    "            i32::from_str(&s).ok()\n",
    "        } else {\n",
    "            None\n",
    "        }\n",
    "    })\n",
    "    .collect();\n",
    "\n",
    "parsed_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff04472d-8a50-4a6c-93c2-a724352494be",
   "metadata": {},
   "source": [
    "#### fuse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "24908d21-f8dc-4408-b449-87164be34a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Unpredictable(bool);\n",
    "\n",
    "impl Iterator for Unpredictable {\n",
    "    type Item = &'static str;\n",
    "\n",
    "    fn next(&mut self) -> Option<Self::Item> {\n",
    "        if self.0 {\n",
    "            self.0 = false;\n",
    "            Some(\"totally the last item\")\n",
    "        } else {\n",
    "            self.0 = true;\n",
    "            None\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "let mut unpredictable = Unpredictable(true);\n",
    "assert_eq!(unpredictable.next(), Some(\"totally the last item\"));\n",
    "assert_eq!(unpredictable.next(), None);\n",
    "assert_eq!(unpredictable.next(), Some(\"totally the last item\"));\n",
    "\n",
    "let mut reliable = Unpredictable(true).fuse();\n",
    "assert_eq!(reliable.next(), Some(\"totally the last item\"));\n",
    "assert_eq!(reliable.next(), None);\n",
    "assert_eq!(reliable.next(), None);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0353fcc-fd74-4934-b49d-89a3e29638f2",
   "metadata": {},
   "source": [
    "#### flatten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "542051bf-fb22-49f6-bf39-a176129a8eb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Course: Computer Science, Students Enrolled: 1\n",
      "Course: Physics, Students Enrolled: 2\n",
      "Course: Biology, Students Enrolled: 1\n",
      "Course: Math, Students Enrolled: 1\n",
      "Course: Chemistry, Students Enrolled: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let mut student_courses = HashMap::new();\n",
    "student_courses.insert(\"Alice\", vec![\"Math\", \"Physics\"]);\n",
    "student_courses.insert(\"Bob\", vec![\"Computer Science\", \"Chemistry\"]);\n",
    "student_courses.insert(\"Charlie\", vec![\"Physics\", \"Biology\"]);\n",
    "\n",
    "let course_enrollment: HashMap<&str, usize> = student_courses\n",
    "    .values()\n",
    "    .flatten()\n",
    "    .fold(HashMap::new(), |mut enrollment, course| {\n",
    "        *enrollment.entry(course).or_insert(0) += 1;\n",
    "        enrollment\n",
    "    });\n",
    "\n",
    "for (course, count) in &course_enrollment {\n",
    "    println!(\"Course: {}, Students Enrolled: {}\", course, count);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ae01099-ab85-47dd-aef9-541f62ba8357",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c1f55e2-ad37-4088-9bc0-802070a5a928",
   "metadata": {},
   "source": [
    "### Closures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "617c08b2-766e-4bf3-b54c-67f829c08ce1",
   "metadata": {},
   "source": [
    "#### Variable Capture in Closures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "208fa7f6-9f0b-46c9-a18d-2494e87f3926",
   "metadata": {},
   "source": [
    "#### Borrowing Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6fbb30ea-d914-46e2-965f-52f906f05b5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 10, 15, 20, 25]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let multiplier = 5;\n",
    "let numbers = vec![1, 2, 3, 4, 5];\n",
    "\n",
    "let multiplied: Vec<i32> = numbers.iter().map(|x| x * multiplier).collect();\n",
    "\n",
    "multiplied"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e669bf4a-5ada-47be-b23c-f24343f2642a",
   "metadata": {},
   "source": [
    "#### Moving Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "63b1e2dd-0f8c-4f8a-8d4d-33a7dc0d2123",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Rust!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let message = \"Hello, Rust!\".to_string();\n",
    "\n",
    "    let greet = || {\n",
    "        let message = message;\n",
    "        println!(\"{}\", message);\n",
    "    };\n",
    "\n",
    "    greet();\n",
    "\n",
    "    // greet();\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c581c3fb-bf21-43ad-9aa7-fd8ec0e08831",
   "metadata": {},
   "source": [
    "### Closures and Fn, FnMut, FnOnce Traits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b3342a7-9a39-45f7-99ba-0118538c9a35",
   "metadata": {},
   "source": [
    "#### Fn Closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "22e55751-2627-4683-8d37-9772da5fe813",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let counter = 0;\n",
    "\n",
    "    let print_counter = || {\n",
    "        println!(\"Counter: {}\", counter);\n",
    "    };\n",
    "\n",
    "    print_counter();\n",
    "\n",
    "    // counter += 1;\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ff15650-26a4-4a89-86a2-8874decbbfb8",
   "metadata": {},
   "source": [
    "#### FnMut Closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "14cb0a3c-7077-4319-8a3d-860b6f4b92ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter: 1\n",
      "Counter: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let mut counter = 0;\n",
    "    let mut increment = || {\n",
    "        counter += 1; // <3>\n",
    "        println!(\"Counter: {}\", counter);\n",
    "    };\n",
    "\n",
    "    increment();\n",
    "    increment();\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f715e3a-ed2b-4f1a-b74f-65329e1e5fa5",
   "metadata": {},
   "source": [
    "#### FnOnce Closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d5f652b0-1d91-4367-bb6c-3d4ed011798a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum: 15\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let numbers = vec![1, 2, 3, 4, 5];\n",
    "    let consume_numbers = || {\n",
    "        let numbers = numbers;\n",
    "        let sum: i32 = numbers.iter().sum();\n",
    "        println!(\"Sum: {}\", sum);\n",
    "    };\n",
    "\n",
    "    consume_numbers();\n",
    "    // consume_numbers();  // <7>\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34dce128-1e81-4827-a620-85e6c279ac5a",
   "metadata": {},
   "source": [
    "### Working with Iterators for Efficient Data Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca96c6c4-e099-45ec-b46c-21f2a46f3913",
   "metadata": {},
   "source": [
    "####  Accumulating Data with `fold`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "0ed35e01-80c0-4cdd-b927-dc74a3a2731f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = vec![1, 2, 3, 4, 5];\n",
    "\n",
    "let sum: i32 = numbers.iter().fold(0, |acc, x| acc + x);\n",
    "\n",
    "sum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "960b1d46-2958-448c-b1ed-67c3b6abcfc8",
   "metadata": {},
   "source": [
    "#### Chaining Iterators with `chain`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b07078ca-97f1-4c80-ac64-7bf24cdae2b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Combined and doubled: [2, 4, 6, 8, 10, 12]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let numbers1 = vec![1, 2, 3];\n",
    "    let numbers2 = vec![4, 5, 6];\n",
    "\n",
    "    let combined: Vec<i32> = numbers1\n",
    "        .iter()\n",
    "        .chain(numbers2.iter())\n",
    "        .map(|x| x * 2)\n",
    "        .collect();\n",
    "\n",
    "    println!(\"Combined and doubled: {:?}\", combined);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fb3bd80-99ab-4ccd-ace5-a567b3c9c099",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30a339d7-6011-42cb-a520-734796fdd507",
   "metadata": {},
   "source": [
    "### Applying Iterators and Closures to Practical Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2e7169d-c9ff-4ac3-9f7a-4b1d7ba655be",
   "metadata": {},
   "source": [
    "#### Use Case 1: Text Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "f6ded3de-6b97-482e-9998-04e6d3782112",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word Frequencies: {\"learn\": 2, \"fun\": 1, \"makes\": 1, \"to\": 1, \"you\": 1, \"that\": 1, \"and\": 1, \"when\": 1, \"it\": 1, \"language\": 1, \"easy\": 1, \"rust\": 4, \"programming\": 1, \"a\": 1, \"is\": 2}\n"
     ]
    }
   ],
   "source": [
    "let text = \"Rust is a language that makes it easy to learn Rust and Rust programming is fun when you learn Rust\";\n",
    "\n",
    "let word_freq: HashMap<String, u32> = text\n",
    "    .split_whitespace()\n",
    "    .map(|word| word.to_lowercase())\n",
    "    .filter(|word| !word.is_empty())\n",
    "    .fold(HashMap::new(), |mut map, word| {\n",
    "        *map.entry(word.to_string()).or_insert(0) += 1;\n",
    "        map\n",
    "    });\n",
    "\n",
    "println!(\"Word Frequencies: {:?}\", word_freq);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a000ab6-10bb-4b1b-af1e-a547961212ff",
   "metadata": {},
   "source": [
    "#### Use Case 2: Image Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "21c6e430-eb9a-4ddb-a8e4-e87200a74aab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image after processing: [Pixel { red: 200, green: 100, blue: 50 }, Pixel { red: 144, green: 200, blue: 100 }]\n"
     ]
    }
   ],
   "source": [
    "#[derive(Debug)]\n",
    "struct Pixel {\n",
    "    red: u8,\n",
    "    green: u8,\n",
    "    blue: u8,\n",
    "}\n",
    "\n",
    "let mut image: Vec<Pixel> = vec![\n",
    "    Pixel {\n",
    "        red: 100,\n",
    "        green: 50,\n",
    "        blue: 25,\n",
    "    },\n",
    "    Pixel {\n",
    "        red: 200,\n",
    "        green: 100,\n",
    "        blue: 50,\n",
    "    },\n",
    "    // ... more pixels\n",
    "];\n",
    "\n",
    "image.iter_mut().for_each(|pixel| {\n",
    "    pixel.red = pixel.red.wrapping_mul(2);\n",
    "    pixel.green = pixel.green.wrapping_mul(2);\n",
    "    pixel.blue = pixel.blue.wrapping_mul(2);\n",
    "});\n",
    "\n",
    "println!(\"Image after processing: {:?}\", image);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7e591a-6eda-48db-9887-4399aecea9a8",
   "metadata": {},
   "source": [
    "#### Use Case 3: Data Filtering and Transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a0b355e0-9ee2-4760-a314-d33bdd157aad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discounted Products: [Product { name: \"Widget A\", price: 8.0, in_stock: true }]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[derive(Debug)]\n",
    "struct Product {\n",
    "    name: String,\n",
    "    price: f64,\n",
    "    in_stock: bool,\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let products = vec![\n",
    "        Product {\n",
    "            name: String::from(\"Widget A\"),\n",
    "            price: 10.0,\n",
    "            in_stock: true,\n",
    "        },\n",
    "        Product {\n",
    "            name: String::from(\"Widget B\"),\n",
    "            price: 15.0,\n",
    "            in_stock: false,\n",
    "        },\n",
    "        // ... more products\n",
    "    ];\n",
    "\n",
    "    let discount = 0.2;\n",
    "\n",
    "    let discounted_products: Vec<Product> = products\n",
    "        .into_iter()\n",
    "        .filter(|product| product.in_stock)\n",
    "        .map(|mut product| {\n",
    "            product.price -= product.price * discount;\n",
    "            product\n",
    "        })\n",
    "        .collect();\n",
    "\n",
    "    println!(\"Discounted Products: {:?}\", discounted_products);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa25757d-4d18-4292-b98b-8182ebf9c72f",
   "metadata": {},
   "source": [
    "#### Use Case 4: Processing Sensor Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "319f1ebc-31b6-4a76-88cc-5ba0c5f5f27f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anomalous Readings: [SensorReading { timestamp: 3, value: 23.0 }]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[derive(Debug)]\n",
    "struct SensorReading {\n",
    "    timestamp: u64,\n",
    "    value: f64,\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let sensor_data = vec![\n",
    "        SensorReading {\n",
    "            timestamp: 1,\n",
    "            value: 20.0,\n",
    "        },\n",
    "        SensorReading {\n",
    "            timestamp: 2,\n",
    "            value: 22.0,\n",
    "        },\n",
    "        SensorReading {\n",
    "            timestamp: 3,\n",
    "            value: 23.0,\n",
    "        },\n",
    "        // ... more readings\n",
    "    ];\n",
    "\n",
    "    let threshold = 22.0;\n",
    "\n",
    "    let anomalies: Vec<&SensorReading> = sensor_data\n",
    "        .iter()\n",
    "        .filter(|&reading| reading.value > threshold)\n",
    "        .collect();\n",
    "\n",
    "    println!(\"Anomalous Readings: {:?}\", anomalies);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00a5a00e-d53d-4487-8898-de4d0df805f3",
   "metadata": {},
   "source": [
    "#### Use Case 5: Financial Calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "fe2ab707-af71-412a-8920-bbdc9eb8693a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Balance: 150.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[derive(Debug)]\n",
    "struct Transaction {\n",
    "    amount: f64,\n",
    "    transaction_type: String,\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let transactions = vec![\n",
    "        Transaction {\n",
    "            amount: 100.0,\n",
    "            transaction_type: String::from(\"Deposit\"),\n",
    "        },\n",
    "        Transaction {\n",
    "            amount: -50.0,\n",
    "            transaction_type: String::from(\"Withdrawal\"),\n",
    "        },\n",
    "        // ... more transactions\n",
    "    ];\n",
    "\n",
    "    let balance = transactions.iter().fold(0.0, |acc, transaction| {\n",
    "        if transaction.transaction_type == \"Deposit\" {\n",
    "            acc + transaction.amount\n",
    "        } else {\n",
    "            acc - transaction.amount\n",
    "        }\n",
    "    });\n",
    "\n",
    "    println!(\"Final Balance: {:?}\", balance);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc0df9a2-495b-490a-9b16-f9e5301ea92d",
   "metadata": {},
   "source": [
    "#### Use Case 6: Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "dd450be4-e1b2-4a65-86ea-a7a064df42a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product: Headphones - Price: $149.99\n",
      "Product: Smartphone - Price: $599.99\n",
      "Product: Laptop - Price: $799.99\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Product {\n",
    "    name: String,\n",
    "    price: f64,\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let mut products = vec![\n",
    "        Product {\n",
    "            name: \"Laptop\".to_string(),\n",
    "            price: 799.99,\n",
    "        },\n",
    "        Product {\n",
    "            name: \"Headphones\".to_string(),\n",
    "            price: 149.99,\n",
    "        },\n",
    "        Product {\n",
    "            name: \"Smartphone\".to_string(),\n",
    "            price: 599.99,\n",
    "        },\n",
    "    ];\n",
    "\n",
    "    products.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap());\n",
    "\n",
    "    for product in &products {\n",
    "        println!(\"Product: {} - Price: ${}\", product.name, product.price);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fb7d6c2-7514-4652-ae01-329df90832ff",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}