07_Common_Rust_Collections.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a4c6d7b4-0cd7-4bda-81ca-8487fcf32ff4",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "Failed to load the project at C:\\Users\\Suryansh\\AppData\\Local\\Temp\\.tmp69TltX\\Cargo.toml",
     "output_type": "error",
     "traceback": [
      "Failed to load the project at C:\\Users\\Suryansh\\AppData\\Local\\Temp\\.tmp69TltX\\Cargo.toml"
     ]
    }
   ],
   "source": [
    "extern crate unicode_segmentation;\n",
    "use unicode_segmentation::UnicodeSegmentation;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3da3fb61-9918-4ae7-b274-f60e4bfd0f37",
   "metadata": {},
   "source": [
    "# Collections in Rust"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28301485-8463-4d6c-a5b7-aa2cae769166",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Vector\n",
    "- vectors are dropped after they go out of scope like any other type stored on heap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "acbdefd8-64c9-4419-9ffa-8a371905284c",
   "metadata": {},
   "outputs": [],
   "source": [
    "// initializing an empty rust vector;\n",
    "// rust can not infer the type if the vector initialized empty;\n",
    "let v: Vec<u8> = Vec::new(); \n",
    "// we cannot add elements to this vector because it isnt mutable;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1798043e-f5ca-4d38-b2d6-8cddcef368bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "// here we're using shadowing, the new v shadowed the older v;\n",
    "let mut v: Vec<u8> = Vec::new();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3cf5ba02-1568-4c7a-b664-8533f5d4d562",
   "metadata": {},
   "outputs": [],
   "source": [
    "// adding elements to the mutable vector v;\n",
    "v.push(4);\n",
    "v.push(3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "26ce74a8-33fa-468f-8c9e-727e9b35c8a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "println!(\"{:?}\", v);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5ca4f7be-8e2b-41f4-9538-dca5ba022cdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3]\n"
     ]
    }
   ],
   "source": [
    "// initializing a vector with some values;\n",
    "// here v will get a type of i32 and not u8 like above because i32 is the default int data type;\n",
    "let mut v: Vec<i32> = vec![1,3,5];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "83b09906-f723-4662-81a3-7fb3e49c3be3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "println!(\"{:?}\", v);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4fd961f0-0707-49b8-8aab-99ded88bd011",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "println!(\"{:?}\", v[2]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9fbdc0d6-30aa-4e7c-a3e5-ef3281d90374",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 3, 5\n",
      "1000, 1002, 1004\n",
      "4, 6, 8\n"
     ]
    }
   ],
   "source": [
    "// with immutable reference\n",
    "for i in &v {\n",
    "    print!(\"{}, \", i);\n",
    "} print!(\"\\x08\\x08\\n\");\n",
    "\n",
    "// with mutable reference\n",
    "for i in 0..v.len() {\n",
    "    // using the defrence operator to get the underlying value of i, i.e v[i] and add 3 to it\n",
    "    v[i] = v[i] + 3;\n",
    "    print!(\"{}, \", v[i] + 996);\n",
    "} print!(\"\\x08\\x08\\n\");\n",
    "\n",
    "// with immutable reference\n",
    "for i in &v {\n",
    "    print!(\"{}, \", i);\n",
    "} print!(\"\\x08\\x08\\n\");\n",
    "\n",
    "// `x08` is unicode for backspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "eaef76fb-8c75-48e0-97c5-80aff6aaca98",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "thread '<unnamed>' panicked at 'index out of bounds: the len is 3 but the index is 5', src/lib.rs:97:18\n",
      "stack backtrace:\n",
      "note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
     ]
    }
   ],
   "source": [
    "// if you access a non existant index,\n",
    "// like 5 in this case, your program will crash,\n",
    "// and itll be a runtime error;\n",
    "// since you dont know the length of the vector beforehand,\n",
    "// itll be harder to handle error;\n",
    "println!(\"{:?}\", v[5]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e9eefee8-1c08-4c39-9432-acd966c1e3f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sixth element does not exist\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// to handle conditions like this,\n",
    "// rust has a safer method of accessing elements in a vector;\n",
    "// it is called the get method;\n",
    "// the get method returns an option;\n",
    "// you can handle both `some` and `none` cases easily.\n",
    "match v.get(6) {\n",
    "    Some(i) => println!(\"sixth element is {}\", i),\n",
    "    None => println!(\"sixth element does not exist\"),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3a1b02d0-9fad-4946-8801-1efcc33740ed",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "cannot find value `v2` in this scope",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[E0425] Error:\u001b[0m cannot find value `v2` in this scope",
      "   \u001b[38;5;246m╭\u001b[0m\u001b[38;5;246m─\u001b[0m\u001b[38;5;246m[\u001b[0mcommand_14:1:1\u001b[38;5;246m]\u001b[0m",
      "   \u001b[38;5;246m│\u001b[0m",
      " \u001b[38;5;246m2 │\u001b[0m \u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;100mv\u001b[0m\u001b[38;5;100m2\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m=\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249mv\u001b[0m\u001b[38;5;249m.\u001b[0m\u001b[38;5;249mc\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249mn\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249m)\u001b[0m\u001b[38;5;249m;\u001b[0m",
      " \u001b[38;5;240m  │\u001b[0m         \u001b[38;5;100m─\u001b[0m\u001b[38;5;100m┬\u001b[0m  ",
      " \u001b[38;5;240m  │\u001b[0m          \u001b[38;5;100m╰\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m help: the binding `v2` is available in a different scope in the same function",
      " \u001b[38;5;240m  │\u001b[0m ",
      " \u001b[38;5;246m4 │\u001b[0m \u001b[38;5;249mp\u001b[0m\u001b[38;5;249mr\u001b[0m\u001b[38;5;249mi\u001b[0m\u001b[38;5;249mn\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249mn\u001b[0m\u001b[38;5;249m!\u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249m\"\u001b[0m\u001b[38;5;249m{\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;249m?\u001b[0m\u001b[38;5;249m}\u001b[0m\u001b[38;5;249m\"\u001b[0m\u001b[38;5;249m,\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;54mv\u001b[0m\u001b[38;5;54m2\u001b[0m\u001b[38;5;249m)\u001b[0m\u001b[38;5;249m;\u001b[0m",
      " \u001b[38;5;240m  │\u001b[0m                  \u001b[38;5;54m─\u001b[0m\u001b[38;5;54m┬\u001b[0m  ",
      " \u001b[38;5;240m  │\u001b[0m                   \u001b[38;5;54m╰\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m error: cannot find value `v2` in this scope",
      "\u001b[38;5;246m───╯\u001b[0m"
     ]
    }
   ],
   "source": [
    "{\n",
    "    let v2 = v.clone();\n",
    "}\n",
    "println!(\"{:?}\", v2);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "054484af-fa8e-43bc-a629-f46ab3bb6107",
   "metadata": {},
   "source": [
    "### Storing multiple types of data in a vector using enums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "57084cbe-c356-4fe9-8ff7-48b86c1ea152",
   "metadata": {},
   "outputs": [],
   "source": [
    "enum SpreadsheetCell{\n",
    "    Int(i32),\n",
    "    Float(f64),\n",
    "    Text(String),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2901eba1-7c02-4b1e-ba01-4a0fc22f0b64",
   "metadata": {},
   "outputs": [],
   "source": [
    "let ve: Vec<SpreadsheetCell> = vec![\n",
    "    SpreadsheetCell::Int(3),\n",
    "    SpreadsheetCell::Text(String::from(\"multiple type holding vector\")),\n",
    "    SpreadsheetCell::Float(10.11),\n",
    "];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6edd6ef3-e68e-4908-a852-703e4aab6e27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you got some text\n"
     ]
    }
   ],
   "source": [
    "match &ve[1] {\n",
    "    SpreadsheetCell::Int(i) => println!(\"you got an integer\"),\n",
    "    SpreadsheetCell::Float(f) => println!(\"you got a float\"),\n",
    "    SpreadsheetCell::Text(t) => println!(\"you got some text\"),\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fcc15c1-7d27-4a78-a8c7-1e37be13835b",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Strings\n",
    "- In rust, strings are stored as a collection of UTF-8 encoded collection of bytes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8999e451-0241-42d3-9655-db59d07dbd5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slice to String, saved in string `s`.\n"
     ]
    }
   ],
   "source": [
    "// strings can be created and stored in following ways;\n",
    "let _s: String = String::new(); // empty string;\n",
    "let _s: &str = \"a string slice\"; // slice;\n",
    "let _s: String = _s.to_string(); // slice converted into String;\n",
    "// it is a good practice to name unused variables with `_nameofvar`\n",
    "let mut s: String = String::from(\"slice to String\"); // slice passed into `from` method of `String` module;\n",
    "\n",
    "s.push_str(\", saved in string `s`\"); // slice of string concatenated into the string `s`;\n",
    "s.push('.'); // character being concatenated into the string `s`;\n",
    "println!(\"{}\", s);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "02944e69-f7dd-43a8-8995-14f0fe47fa0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slice to String, saved in string `s`. ||| some other string ||| slice to String, saved in string `s`. | some other string\n"
     ]
    }
   ],
   "source": [
    "let s1: String = String::from(\"some other string\");\n",
    "let s2 = format!(\"{} | {}\", s, s1); // format method does not take the ownership of the passed strings;\n",
    "println!(\"{} ||| {} ||| {}\", s, s1, s2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "9a7677a7-ef7a-4753-921a-31846fbacc9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[some, other, string]\n"
     ]
    }
   ],
   "source": [
    "print!(\"[\");\n",
    "for word in s1.split_whitespace() {\n",
    "        print!(\"{}, \", word);\n",
    "} println!(\"\\x08\\x08]\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10ffb703-d074-4dfe-a01f-7557a7dfb5fc",
   "metadata": {},
   "source": [
    "### accessing individual characters in a string\n",
    "- we cannot access them like str[3], like in high level languages.\n",
    "- we have 3 representations of strings:\n",
    "    - byte collection [224, 164, 168, 224, 164, 174, 224, 164, 184, 224  165, 141, 224, 164, 16\n",
    "  224, 165, 135]\n",
    "    - scalar val [ 'न', 'म', 'स', '्', 'त', 'े' ]\n",
    "ues\n",
    "    - grapheme f [ 'न', 'म', 'स्', 'ते' ]\n",
    "orms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "19577f7c-54b8-4eaa-b0c7-b3d220d162e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164, 224, 165, 135]\n"
     ]
    }
   ],
   "source": [
    "// to print individual bytes\n",
    "let hello: String = String::from(\"नमस्ते\");\n",
    "print!(\"[\");\n",
    "for b in hello.bytes(){\n",
    "    print!(\"{}, \", b);\n",
    "} println!(\"\\x08\\x08]\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a10a09ba-fd3c-47fa-b7bf-5cd2051eb76d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[न, म, स, ्, त, े]\n"
     ]
    }
   ],
   "source": [
    "// to print scalar values\n",
    "print!(\"[\");\n",
    "for c in hello.chars(){\n",
    "    print!(\"{}, \", c);\n",
    "} println!(\"\\x08\\x08]\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9916965b-039d-4e63-ab88-c65a1e96f7c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "// cannot run since some bug in importing unicode_segmentation;\n",
    "// to print graphemes;\n",
    "print!(\"[\");\n",
    "for g in hello.graphemes(){\n",
    "    print!(\"{}, \", g);\n",
    "} println!(\"\\x08\\x08]\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9a9d41d-312d-465d-afc0-6cdbefd66de4",
   "metadata": {},
   "source": [
    "## Hash Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e0f910a9-aac1-4347-8315-6e86a6f2dda8",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::collections::HashMap;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "cb89a650-303c-457e-b86d-0cae3b38d938",
   "metadata": {},
   "outputs": [],
   "source": [
    "let mut teams: HashMap<String, i32> = HashMap::new();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1ba029cb-8fbc-45ab-8fe8-9463930db4be",
   "metadata": {},
   "outputs": [],
   "source": [
    "let blue: String = String::from(\"BLUES\");\n",
    "let red: String = String::from(\"REDS\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b5a99690-8cb1-4ab0-9190-5236aad51ffa",
   "metadata": {},
   "outputs": [],
   "source": [
    "// note that we're not passing the strings by ref;\n",
    "// passing the strings this way will move the ownership\n",
    "// of respective string into the hash map;\n",
    "teams.insert(blue, 10);\n",
    "teams.insert(red, 9);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5f24f0f9-2881-462b-ae17-c7fa9ea181ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"BLUES\": 10, \"REDS\": 9}\n"
     ]
    }
   ],
   "source": [
    "// same here, we moved the ownership of teams to print function,\n",
    "// after this function executes, the var teams will be dropped;\n",
    "println!(\"{:?}\", &teams);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "6a06f08b-e69a-4b92-81bf-79fb11ebaf46",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "The variable `score` contains a reference with a non-static lifetime so\ncan't be persisted. You can prevent this error by making sure that the\nvariable goes out of scope - i.e. wrapping the code in {}.",
     "output_type": "error",
     "traceback": [
      "\u001b[31mError:\u001b[0m The variable `score` contains a reference with a non-static lifetime so",
      "can't be persisted. You can prevent this error by making sure that the",
      "variable goes out of scope - i.e. wrapping the code in {}."
     ]
    }
   ],
   "source": [
    "// since the team names are now dropped,\n",
    "// we have to create the strings again to access them;\n",
    "// {\n",
    "    let score: Option<&i32> = teams.get(\"BLUES\"); // this function returns an option so we must unwrap it before using it;\n",
    "    let default_score: i32 = -1;\n",
    "    println!(\"{}\", score.unwrap_or(&&default_score)); // unwrap function requries a ref to the param value\n",
    "    // we had to provide a scope to ensure that the option and score var go out of scope together,\n",
    "    // this ensures that when ref to blues score go out of scope , the score var do not have a dangling pointer\n",
    "// }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "3367c3f1-fb1d-4d17-a3d4-5018f18b86bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\n",
    "    let score: Option<&i32> = teams.get(\"BLUES\"); // this function returns an option so we must unwrap it before using it;\n",
    "    let default_score: i32 = -1;\n",
    "    println!(\"{}\", score.unwrap_or(&&default_score)); // unwrap function requries a ref to the param value;\n",
    "    // we had to provide a scope to ensure that the option and score var go out of scope together,\n",
    "    // this ensures that when ref to blues score go out of scope , the score var do not have a dangling pointer;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "360ec12b-714e-49be-b51b-7af466f26739",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BLUES 10\n",
      "REDS 9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// iterating over the hash map;\n",
    "for (key, value) in teams {\n",
    "    println!(\"{} {}\", key, value);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d8dd31-1623-4da3-a63e-0c79da40a7e2",
   "metadata": {},
   "source": [
    "### Hash Map methods\n",
    "- insert(key, value)\n",
    "- entry(key) -> entry (an enum that represents a key-value pair)\n",
    "- entry(key).or_insert(vlaue) -> &mut value -- insert value to entry if the entry do not exist, else do nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "eae9ed21-7b86-4254-ad98-8671649a51fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "let mut map: HashMap<&str, u8> = HashMap::new();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0cd3301c-d8ef-4230-b966-cb344535efcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "let string: &str = \"some string from some words of some language from some where around the world\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "59bf0651-893f-46fe-b4f8-8e1e0af4adf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"string\": 1, \"from\": 2, \"words\": 1, \"language\": 1, \"around\": 1, \"the\": 1, \"world\": 1, \"some\": 4, \"where\": 1, \"of\": 1}\n"
     ]
    }
   ],
   "source": [
    "for word in string.split_whitespace() {\n",
    "    let count: &mut u8 = map.entry(word).or_insert(0);\n",
    "    *count += 1;\n",
    "}\n",
    "println!(\"{:?}\", map);"
   ]
  }
 ],
 "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
}