10_Traits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Traits\n",
    "In OOP languages, we have a concept called interfaces and inheritance.<br>\n",
    "We can write methods that will be shared by multiple classes in an interface<br>\n",
    "with or without concrete implementation or in a class with concrete implementation<br>\n",
    "and any class that needs those methods can simply inherit them.<br>\n",
    "\n",
    "Similarly,\n",
    "> **`Traits` are entities that can hold some behaviour that can then be shared between multiple structs**\n",
    "\n",
    ">**Note:** To implement a trait you have to use following syntax: <br> `impl TraitName for StructName{}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 new tweet: read more from horse_ebooks...\n",
      "New article available! Penguins win the Stanley Cup Championship!, by Iceburgh (Pittsburgh, PA, USA)\n",
      "Breaking news! read more from horse_ebooks...\n",
      "Breaking news! read more from horse_ebooks...\n",
      "Breaking news! read more from horse_ebooks...\n",
      "list2\n",
      "Breaking news! Penguins win the Stanley Cup Championship!, by Iceburgh (Pittsburgh, PA, USA)\n",
      "Breaking news! Penguins win the Stanley Cup Championship!, by Iceburgh (Pittsburgh, PA, USA)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\n",
    "    // lets have these 2 structs that needs behaviour,\n",
    "    // to summarize the content;\n",
    "    pub struct NewsArticle {\n",
    "        pub headline: String,\n",
    "        pub location: String,\n",
    "        pub author: String,\n",
    "        pub content: String,\n",
    "    }\n",
    "    pub struct Tweet {\n",
    "        pub username: String,\n",
    "        pub content: String,\n",
    "        pub reply: bool,\n",
    "        pub retweet: bool,\n",
    "    }\n",
    "\n",
    "    // we can define a trait that will be implemented by both;\n",
    "    pub trait Summary {\n",
    "\n",
    "        // we can either leave a function unimplemented,\n",
    "        // fn summarize(&self) -> String;\n",
    "    \n",
    "        fn summarize_author(&self) -> String{\n",
    "            String::from(\"unknown\")\n",
    "        }\n",
    "        // or we can provide a default implementation,\n",
    "        // which can be overriden by the implementor;\n",
    "        fn summarize(&self) -> String{\n",
    "            format!(\"read more from {}...\", self.summarize_author())\n",
    "        }   \n",
    "    }\n",
    "\n",
    "    impl Summary for NewsArticle {\n",
    "        fn summarize_author(&self) -> String {\n",
    "            format!(\"{}\", self.author)\n",
    "        }\n",
    "        // here we override the default implementation;\n",
    "        fn summarize(&self) -> String {\n",
    "            format!(\"{}, by {} ({})\", self.headline, self.author, self.location)\n",
    "        }\n",
    "    }\n",
    "    impl Summary for Tweet {\n",
    "        // here we implement the unimplemented method summarize_author;\n",
    "        fn summarize_author(&self) -> String {\n",
    "            format!(\"{}\", self.username)\n",
    "        }\n",
    "        // here we let the default implementation of summarize be used;\n",
    "    }\n",
    "\n",
    "    let tweet = Tweet {\n",
    "        username: String::from(\"horse_ebooks\"),\n",
    "        content: String::from(\"of course, as you probably already know, people\"),\n",
    "        reply: false,\n",
    "        retweet: false,\n",
    "    };\n",
    "    println!(\"1 new tweet: {}\", tweet.summarize());\n",
    "\n",
    "    let article = NewsArticle {\n",
    "        headline: String::from(\"Penguins win the Stanley Cup Championship!\"),\n",
    "        location: String::from(\"Pittsburgh, PA, USA\"),\n",
    "        author: String::from(\"Iceburgh\"),\n",
    "        content: String::from(\"The Pittsburgh Penguins once again are the best hockey team in the NHL.\"),\n",
    "    };\n",
    "    \n",
    "    println!(\"New article available! {}\", article.summarize());\n",
    "\n",
    "\n",
    "    // we can also use traits as parameters;\n",
    "    // this is called a trait bound;\n",
    "    // this way we can use the same function for different types;\n",
    "\n",
    "    // this function will only work for types that implement Summary;\n",
    "    // the following implementation of the notify function is just syntactic sugar;\n",
    "    // fn notify(item: &impl Summary) {\n",
    "    //     println!(\"Breaking news! {}\", item.summarize());\n",
    "    // }\n",
    "\n",
    "    // the following implementation is the same as the one above;\n",
    "    fn notify<T: Summary>(item: &T) {\n",
    "        println!(\"Breaking news! {}\", item.summarize());\n",
    "    }\n",
    "    \n",
    "    notify(&tweet);\n",
    "\n",
    "    // this type of implementation helps us in cases like following;\n",
    "    // here we want both item1 and item2 to be the entities of the same struct;\n",
    "    // this is not possible with the first implementation of notify;\n",
    "    fn list<T: Summary>(item1: &T, item2: &T) {\n",
    "        println!(\"Breaking news! {}\", item1.summarize());\n",
    "        println!(\"Breaking news! {}\", item2.summarize());\n",
    "    }\n",
    "    list(&tweet, &tweet);\n",
    "\n",
    "    // we can also use where clause to make the code more readable;\n",
    "    // where clause is especially useful when we have multiple parameters;\n",
    "    // it makes the code more readable;\n",
    "    // we can just write a generic type in the function signature and\n",
    "    // specify the trait bound in the where clause;\n",
    "    fn list2<T>(item1: &T, item2: &T)\n",
    "    where T: Summary\n",
    "    {\n",
    "        println!(\"list2\");\n",
    "        println!(\"Breaking news! {}\", item1.summarize());\n",
    "        println!(\"Breaking news! {}\", item2.summarize());   \n",
    "    }\n",
    "    list2(&article, &article);\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": ""
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}