08_Error_Handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "15ace501-24e2-492e-bec8-99c751248687",
   "metadata": {},
   "source": [
    "# Error Handling"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "807f11ee-8c5b-4b76-9f6a-a937edff1c64",
   "metadata": {},
   "source": [
    "## The `panic` macro\n",
    "If the program fails in such a way that it's state is unrecoverable or you cannot handle the error gracefully, you can call the panic macro and the program will quit immediately with the provided error statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "933d00ba-e3a1-4f11-a1ef-6740566c8e71",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "thread '<unnamed>' panicked at 'explicit panic', src/lib.rs:22:1\n",
      "stack backtrace:\n",
      "note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
     ]
    }
   ],
   "source": [
    "panic!();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "06518199-362d-4722-8cc1-072c42dbe804",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "thread '<unnamed>' panicked at 'crash and burn', src/lib.rs:22:1\n",
      "stack backtrace:\n",
      "note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
     ]
    }
   ],
   "source": [
    "panic!(\"crash and burn\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "048c3ada-323a-49d1-8a55-f03a26c369f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::env;\n",
    "env::set_var(\"RUST_BACKTRACE\", \"full\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1bab08d-17d1-4105-bcfe-eb3471df816b",
   "metadata": {},
   "source": [
    "To see backtrace output, either set the env in the main file, or put BACKTRACE=full beofore cargo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "976e3de5-384f-4d55-b536-19c380b7efdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "thread '<unnamed>' panicked at 'number too large', src/lib.rs:15:6\n",
      "stack backtrace:\n",
      "note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
     ]
    }
   ],
   "source": [
    "fn d(x: u8){\n",
    "    if x > 3 {\n",
    "     panic!(\"number too large\");\n",
    "    }\n",
    "}\n",
    "fn c(x: u8){\n",
    "    d(x);\n",
    "}\n",
    "fn b(x: u8){\n",
    "    c(x);\n",
    "}\n",
    "fn a(x: u8){\n",
    "    b(x);\n",
    "}\n",
    "let x: u8 = 4;\n",
    "a(x);\n",
    "\n",
    "// jupyter will not print backtract;\n",
    "// to see the backtrace run the following command in your terminal;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c4a933e-0a34-4c75-8752-16263676c83c",
   "metadata": {},
   "source": [
    "```sh\n",
    "RUST_BACKTRACE=1 cargo run\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70f7b6fb-2102-4741-8686-dc82e89adcf2",
   "metadata": {},
   "source": [
    "## The `Result` enum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "50067136-31f7-4445-88bd-c36bbefc1aba",
   "metadata": {},
   "outputs": [],
   "source": [
    "enum Result<T, E> {\n",
    "    Ok(T),\n",
    "    Err(E),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fd6ffe7-55f0-4371-8ce8-c6878e086c2f",
   "metadata": {},
   "source": [
    "### about\n",
    "- We use this enum when we want to handle errors gracefully and don't want to crash the program.\n",
    "- It is simmilar to the option enum, this enum represents 2 variants, success and error.\n",
    "- This enum is very common in rust so it is also brought into the scope by default.\n",
    "- unwrap --> this method returns the resultant value in case of success. But if error, it panicks!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5eb9cd13-9e31-48d1-bc85-6b83f673f6d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extern crate unicode_segmentation;\n",
      "use unicode_segmentation::UnicodeSegmentation;\n",
      "\n",
      "fn main() {\n",
      "    notebook_7_string_to_grapheme();\n",
      "}\n",
      "\n",
      "fn notebook_7_string_to_grapheme() {\n",
      "    let hello: String = String::from(\"नमस्ते\");\n",
      "    // to print graphemes\n",
      "    print!(\"[\");\n",
      "    for g in hello.graphemes(true) {\n",
      "        print!(\"{}, \", g);\n",
      "    }\n",
      "    println!(\"\\x08\\x08]\");\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "use std::{ fs::File, io::{ ErrorKind, prelude::* } };\n",
    "let path: &str = \".\\\\src\\\\main.rs\";\n",
    "\n",
    "// this open method returns a result type,\n",
    "// because opening a file may fail in cases like file does not exist;\n",
    "let f = File::open(&path);\n",
    "\n",
    "let mut f = match f {\n",
    "\n",
    "    // if succesfully read, return file;\n",
    "    Ok(file) => file,\n",
    "\n",
    "    // if failed, match what kind of err occured;\n",
    "    Err(err) => match err.kind() {\n",
    "\n",
    "        // if file not found err, then create a file;\n",
    "        ErrorKind::NotFound => match File::create(&path){\n",
    "\n",
    "            // if file successfully created, return the file;\n",
    "            Ok(new_file) => new_file,\n",
    "\n",
    "            // else panic!\n",
    "            Err(create_err) => panic!(\"err finding or creating file: {} | error: {}\", &path, create_err)\n",
    "\n",
    "        },\n",
    "        // else panic!\n",
    "        other_error => panic!(\"problm opening file: {} | error: {}\", &path, other_error)\n",
    "    }\n",
    "};\n",
    "\n",
    "let mut buffer = String::new();\n",
    "f.read_to_string(&mut buffer);\n",
    "\n",
    "println!(\"{}\", buffer);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12fe6697-2c52-4169-b3ee-b87068c25961",
   "metadata": {},
   "source": [
    "### Error propagation, `?` operator\n",
    "\n",
    "```rs\n",
    "    fn open_file(path: &str) -> Result<File, io::Error> {\n",
    "        File::open(path)?\n",
    "    }\n",
    "```\n",
    "> **Note:** Err propagation does not work in the main function because you can return the `?` operator only in functions that return Result or Option buy main function returns neither.\n",
    "If the file exists and is read succesfully, it returns the file. But in case some error occurs, instead of panicking, it returns the err to the caller function.\n",
    "- Let's write code from above in a simplified manner."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25ae6d13-7d74-4f1e-8ceb-76b9ed8433ac",
   "metadata": {},
   "source": [
    "> **Note:** There is a better way to do this without all this nesting, using `closures`. It is in upcoming modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d15dcb91-16c9-43f2-829b-7747dd2fb8b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"extern crate unicode_segmentation;\\nuse unicode_segmentation::UnicodeSegmentation;\\n\\nfn main() {\\n    notebook_7_string_to_grapheme();\\n}\\n\\nfn notebook_7_string_to_grapheme() {\\n    let hello: String = String::from(\\\"नमस\\u{94d}त\\u{947}\\\");\\n    // to print graphemes\\n    print!(\\\"[\\\");\\n    for g in hello.graphemes(true) {\\n        print!(\\\"{}, \\\", g);\\n    }\\n    println!(\\\"\\\\x08\\\\x08]\\\");\\n}\\n\"\n"
     ]
    }
   ],
   "source": [
    "use std::{\n",
    "    fs::{ self, File },\n",
    "    io::{ self, Read, prelude::* }\n",
    "};\n",
    "\n",
    "fn open_file(path: &str) -> Result<String, io::Error> {\n",
    "    // method 1: read file, store in buffer, return buffer;\n",
    "    // let mut file = File::open(path)?;\n",
    "    // let mut buffer: String = String::new();\n",
    "    // file.read_to_string(&mut buffer)?;\n",
    "    // Ok(buffer)\n",
    "\n",
    "    // method 2: method 1 with chaining;\n",
    "    // chaining the method calls with ? operator;\n",
    "    // let mut buffer = String::new();\n",
    "    // File::open(path)?.read_to_string(&mut buffer)?;\n",
    "    // Ok(buffer)\n",
    "\n",
    "    // method 3: use fs::read_to_string;\n",
    "    // this method directly returns the contents of the file as a string;\n",
    "    fs::read_to_string(path)\n",
    "}\n",
    "\n",
    "\n",
    "println!(\"{:?}\", open_file(path).unwrap());\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
}