Lecture10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# R\n",
    "## Control Structures, Functions, and Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## If Statements\n",
    "- The if statement in `R` is very `C` like in it's syntax\n",
    "```R\n",
    "if (condition) {\n",
    "} else {\n",
    "}\n",
    "```\n",
    "- Addition else if clauses have the syntax of \n",
    "```R\n",
    "else if (condition) {\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in parse(text = x, srcfile = src): <text>:5:1: unexpected 'else'\n4: }\n5: else\n   ^\n",
     "output_type": "error",
     "traceback": [
      "Error in parse(text = x, srcfile = src): <text>:5:1: unexpected 'else'\n4: }\n5: else\n   ^\n"
     ]
    }
   ],
   "source": [
    "## This won't work, else needs to be on same line as end of if\n",
    "if( 4 > 5) {\n",
    "    print(\"Bad Math\")\n",
    "}\n",
    "else {\n",
    "    print(\"Seems right to me\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Seems right to me\"\n"
     ]
    }
   ],
   "source": [
    "if( 4 > 5) {\n",
    "    print(\"Bad Math\")\n",
    "} else {\n",
    "    print(\"Seems right to me\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"4 is even\"\n"
     ]
    }
   ],
   "source": [
    "a <- 4\n",
    "b <- 2\n",
    "if ( a %% b == 0)\n",
    "{\n",
    "    print(paste(a,\"is even\"))\n",
    "} else {\n",
    "     print(paste(a,\"is odd\"))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning message:\n",
      "In if (vec1%%2 == 0) {: the condition has length > 1 and only the first element will be used"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"All elements are even\"\n"
     ]
    }
   ],
   "source": [
    "## Produces warning only, probably not the intended test condition\n",
    "vec1 <- c(2,4,6,8)\n",
    "if( vec1 %% 2 == 0){\n",
    "    print(\"All elements are even\")\n",
    "} else{\n",
    "    print(\"Not all elements are even\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"All elements are even\"\n"
     ]
    }
   ],
   "source": [
    "vec1 <- c(2,4,6,8)\n",
    "if( all(vec1 %% 2 == 0)){\n",
    "    print(\"All elements are even\")\n",
    "} else{\n",
    "    print(\"Not all elements are even\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## If Tricks\n",
    "- `if` on the right hand side of an assignment\n",
    "```R\n",
    "var <- if (condition){\n",
    "        value \n",
    "        }\n",
    "    else{ \n",
    "        value\n",
    "    }\n",
    "```\n",
    "- The `ifelse` function to apply  to vectors\n",
    "```R\n",
    "ifelse(expression_generating_boolean_vector, value_if_true, value_if_false)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1000\n"
     ]
    }
   ],
   "source": [
    "num1 <- 100\n",
    "num2 <- 1000\n",
    "largest_num <- if(num1 > num2){\n",
    "    num1\n",
    "} else {\n",
    "    num2\n",
    "}\n",
    "print(largest_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 100\n"
     ]
    }
   ],
   "source": [
    "float <- 100.004\n",
    "truncated <- if (float %% 1 != 0){\n",
    "    float %/% 1\n",
    "} else{\n",
    "    float\n",
    "}\n",
    "print(truncated)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [1] \"Isn't Divisibly by 3\" \"Isn't Divisibly by 3\" \"Is Divisible by 3\"   \n",
      " [4] \"Isn't Divisibly by 3\" \"Isn't Divisibly by 3\" \"Is Divisible by 3\"   \n",
      " [7] \"Isn't Divisibly by 3\" \"Isn't Divisibly by 3\" \"Is Divisible by 3\"   \n",
      "[10] \"Isn't Divisibly by 3\"\n"
     ]
    }
   ],
   "source": [
    "vec3 <- 1:10\n",
    "print(ifelse(vec3 %% 3 == 0, \n",
    "             \"Is Divisible by 3\",\n",
    "             \"Isn't Divisibly by 3\" ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " [1] -1 -1 -1 -1 -1  1  1  1  1  1  1\n"
     ]
    }
   ],
   "source": [
    "vec4 <- -5:5\n",
    "print(ifelse(vec4 < 0,-1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Switch Statement\n",
    "- `R` doesn't have a switch statement, only a `switch` function\n",
    "```R\n",
    "switch(expression, value1, value2, value3...)\n",
    "switch(expression, key1 = value1, key2 = value2, default)\n",
    "```\n",
    "- The switch function takes an expression, followed by a list of things to return if matched\n",
    "    - With out any parameter keywords, the expression needs to be an integer\n",
    "    - When using keywords, a parameter with out a keyword is assumed to be a default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"three\"\n",
      "[1] \"tres\"\n",
      "[1] \"un numero\"\n"
     ]
    }
   ],
   "source": [
    "word <- switch(3,\"one\",\"two\",\"three\",\"four\",\"five\",\"six\",\"seven\")\n",
    "print(word)\n",
    "\n",
    "translation <- switch(word, one=\"uno\",two=\"dos\",\n",
    "                      three=\"tres\",four=\"quatro\",\n",
    "                      \"un numero\")\n",
    "print(translation)\n",
    "\n",
    "print(switch(\"seven\", one=\"uno\",two=\"dos\",\n",
    "             three=\"tres\",four=\"quatro\",\n",
    "             \"un numero\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## For Loops\n",
    "- For loops in `R` look like for-each loops, but are still numeric\n",
    "- The function `seq_along(X)` produces the sequence of indices for a given object to loop through\n",
    "```R\n",
    "for(var in integer_vector){\n",
    "    }\n",
    "```\n",
    "- Many libraries exist that attempt to produce better, faster for loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1\n",
      "[1] 4\n",
      "[1] 9\n",
      "[1] 16\n",
      "[1] 25\n"
     ]
    }
   ],
   "source": [
    "for(i in 1:5){\n",
    "    print(i ^ 2)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                     mpg cyl  disp  hp drat    wt  qsec vs am gear carb\n",
      "Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4\n",
      "Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4\n",
      "Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1\n",
      "Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1\n",
      "Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2\n",
      "Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1\n",
      "Duster 360          14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4\n",
      "Merc 240D           24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2\n",
      "Merc 230            22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2\n",
      "Merc 280            19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4\n",
      "Merc 280C           17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4\n",
      "Merc 450SE          16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3\n",
      "Merc 450SL          17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3\n",
      "Merc 450SLC         15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3\n",
      "Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4\n",
      "Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4\n",
      "Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4\n",
      "Fiat 128            32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1\n",
      "Honda Civic         30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2\n",
      "Toyota Corolla      33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1\n",
      "Toyota Corona       21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1\n",
      "Dodge Challenger    15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2\n",
      "AMC Javelin         15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2\n",
      "Camaro Z28          13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4\n",
      "Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2\n",
      "Fiat X1-9           27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1\n",
      "Porsche 914-2       26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2\n",
      "Lotus Europa        30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2\n",
      "Ford Pantera L      15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4\n",
      "Ferrari Dino        19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6\n",
      "Maserati Bora       15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8\n",
      "Volvo 142E          21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2\n"
     ]
    }
   ],
   "source": [
    "print(mtcars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"The median mpg is 19.2\"\n",
      "[1] \"The median cyl is 6\"\n",
      "[1] \"The median disp is 196.3\"\n",
      "[1] \"The median hp is 123\"\n",
      "[1] \"The median drat is 3.695\"\n",
      "[1] \"The median wt is 3.325\"\n",
      "[1] \"The median qsec is 17.71\"\n",
      "[1] \"The median vs is 0\"\n",
      "[1] \"The median am is 0\"\n",
      "[1] \"The median gear is 4\"\n",
      "[1] \"The median carb is 2\"\n"
     ]
    }
   ],
   "source": [
    "## How can I make this print thet names of the column?\n",
    "for (feature in seq_along(mtcars)){\n",
    "    print(paste(\"The median\",colnames(mtcars)[feature],\"is\",\n",
    "                median(mtcars[[feature]])))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Logic Controlled Loops\n",
    "- `R` offers only one truly controlled logic loop, the standard `while` loop\n",
    "```R\n",
    "    while(condition){\n",
    "    }\n",
    "```\n",
    "- `R` also provides a repeat loop, which repeats forever, and must be broken out of explicitly\n",
    "```R\n",
    "repeat{\n",
    "         if(condition) break\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"I found 6 at position 7\"\n"
     ]
    }
   ],
   "source": [
    "haystack <- c(1,34,5,5,1,4,6,0)\n",
    "i <- 1\n",
    "while(haystack[i] != 6){\n",
    "        i <- i + 1\n",
    "}\n",
    "print(paste(\"I found 6 at position\",i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n",
      "[1] \"This is the song that never ends, yes it goes on and on my friends,\\n           some people started singing it not knowing what it was, and they will keep on\\n           singing it forever just because...\"\n"
     ]
    }
   ],
   "source": [
    "end <- 1\n",
    "repeat{\n",
    "    print(\"This is the song that never ends, yes it goes on and on my friends,\n",
    "           some people started singing it not knowing what it was, and they will keep on\n",
    "           singing it forever just because...\")\n",
    "    if (end == 10) break\n",
    "    end <- end + 1\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lapply\n",
    "- Often times we are just looping over a data structure in `R` to apply a function to every member\n",
    "    - The `R` function `lapply` does this without writing out the entire loop\n",
    "- This is the first of many functional programming style statements we will encounter in `R`\n",
    "    - Entire libraries have been created to further this style of programming\n",
    "```R\n",
    "lapply(data,function)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$mpg\n",
      "[1] 19.2\n",
      "\n",
      "$cyl\n",
      "[1] 6\n",
      "\n",
      "$disp\n",
      "[1] 196.3\n",
      "\n",
      "$hp\n",
      "[1] 123\n",
      "\n",
      "$drat\n",
      "[1] 3.695\n",
      "\n",
      "$wt\n",
      "[1] 3.325\n",
      "\n",
      "$qsec\n",
      "[1] 17.71\n",
      "\n",
      "$vs\n",
      "[1] 0\n",
      "\n",
      "$am\n",
      "[1] 0\n",
      "\n",
      "$gear\n",
      "[1] 4\n",
      "\n",
      "$carb\n",
      "[1] 2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## What is the return type do you think?\n",
    "results_l <- lapply(mtcars,median)\n",
    "print(results_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    mpg     cyl    disp      hp    drat      wt    qsec      vs      am    gear \n",
      " 19.200   6.000 196.300 123.000   3.695   3.325  17.710   0.000   0.000   4.000 \n",
      "   carb \n",
      "  2.000 \n"
     ]
    }
   ],
   "source": [
    "## What is the return type do you think?\n",
    "results_s <- sapply(mtcars,median)\n",
    "print(results_s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions\n",
    "- A function in `R` is declared using the syntax\n",
    "```R\n",
    "function(parameter list){\n",
    "    function body\n",
    "    }\n",
    "```\n",
    "- The result of this is assigned to a variable which is then used as the function name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Hello!\"\n"
     ]
    }
   ],
   "source": [
    "my_first_function <- function(){\n",
    "    print(\"Hello!\")\n",
    "} \n",
    "\n",
    "my_first_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 5\n"
     ]
    }
   ],
   "source": [
    "my_second_function <- function(a,b,c){\n",
    "    print(a * b + c)\n",
    "}\n",
    "my_second_function(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Returning From Functions\n",
    "- To explicitly return from an `R` function, use the `return` function\n",
    "    - Note that this is a function, not a statement, and requires parentheses\n",
    "```R\n",
    "    return (x)\n",
    "```\n",
    "- If no return function is called, an `R` function will return the value of the last expression of the function by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 8\n"
     ]
    }
   ],
   "source": [
    "explicit_return <- function(a,b)\n",
    "    {\n",
    "    return (a %/% b + a %% b)\n",
    "}\n",
    "print(explicit_return(20,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 8\n"
     ]
    }
   ],
   "source": [
    "implicit_return <- function(a,b)\n",
    "{\n",
    "a %/% b + a %% b    \n",
    "}\n",
    "print(implicit_return(20,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Function Parameters and Arguments\n",
    "- `R` provides a wide variety of parameter options\n",
    "    - Keyword parameters\n",
    "    - Default parameters\n",
    "    - Positional parameters\n",
    "- `R` also allows a list to provide the arguments to a function, using the `do.call` function\n",
    "```\n",
    "do.call(function_name, list_of_arguments)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 20\n",
      "[1] 10\n",
      "[1] 4\n",
      "[1] 10\n"
     ]
    }
   ],
   "source": [
    "param_example <- function(a, b = 0, c = 1){\n",
    "    result <- if (b == 0){\n",
    "        a / c\n",
    "    } else {\n",
    "        a / b\n",
    "    }\n",
    "}\n",
    "print(param_example(20))\n",
    "print(param_example(20,c=2))\n",
    "print(param_example(20,c=2,b=5))\n",
    "print(param_example(20,2,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyword Parameters Detailed\n",
    "- `R` is a bit unique in that keyword parameters don't have to be completely spelled out when used\n",
    "- The order of evaluation is \n",
    "    - Attempt to find a perfect match\n",
    "    - Attempt to find a match of the keyword prefixes\n",
    "    - Use positional parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 19\n",
      "[1] 23\n",
      "[1] 19\n",
      "[1] 13\n"
     ]
    }
   ],
   "source": [
    "keywords <- function(a, power=2, d = 3, donut = 5)\n",
    "{\n",
    "        a ^ power + d * donut\n",
    "}\n",
    "print(keywords(2))\n",
    "print(keywords(2,p=3))\n",
    "print(keywords(2,d=3))\n",
    "print(keywords(2,do=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in keywords_trouble(2, d = 5): argument 2 matches multiple formal arguments\n",
     "output_type": "error",
     "traceback": [
      "Error in keywords_trouble(2, d = 5): argument 2 matches multiple formal arguments\n"
     ]
    },
    {
     "ename": "ERROR",
     "evalue": "Error in keywords_trouble(2, do = 5): argument 2 matches multiple formal arguments\n",
     "output_type": "error",
     "traceback": [
      "Error in keywords_trouble(2, do = 5): argument 2 matches multiple formal arguments\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 29\n"
     ]
    }
   ],
   "source": [
    "keywords_trouble <- function(a, power=2, dollop = 3, donut = 5)\n",
    "{\n",
    "        a ^ power + dollop * donut\n",
    "}\n",
    "print(keywords_trouble(2,d=5))\n",
    "print(keywords_trouble(2,do=5))\n",
    "print(keywords_trouble(2,dol=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lazy Evaluation\n",
    "- Parameters in `R` are not evaluated until they are absolutely needed\n",
    "    - Evaluation can be forced by using the `force` function\n",
    "    - Parameters in `R` are evaluated with respect to the current function\n",
    "        - If you pass a function as an argument, it will be evaluated lazily, in whatever environment currently exists in the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in \"String\" * \"string\": non-numeric argument to binary operator\n",
     "output_type": "error",
     "traceback": [
      "Error in \"String\" * \"string\": non-numeric argument to binary operator\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"I don't use my parameters\"\n"
     ]
    }
   ],
   "source": [
    "lazee <- function(a, b)\n",
    "    {\n",
    "    \"I don't use my parameters\"\n",
    "}\n",
    "print(\"String\"  * \"string\")\n",
    "print(lazee(\"String\" * \"string\",3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in \"String\" * \"string\": non-numeric argument to binary operator\n",
     "output_type": "error",
     "traceback": [
      "Error in \"String\" * \"string\": non-numeric argument to binary operator\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1\n"
     ]
    },
    {
     "ename": "ERROR",
     "evalue": "Error in \"String\" * \"string\": non-numeric argument to binary operator\n",
     "output_type": "error",
     "traceback": [
      "Error in \"String\" * \"string\": non-numeric argument to binary operator\n"
     ]
    }
   ],
   "source": [
    "not_lazee <- function(a, b,....)\n",
    "{\n",
    "    print(length(list(....)))\n",
    "    force(a)\n",
    "    \"I don't use my parameters\"\n",
    "}\n",
    "print(\"String\"  * \"string\")\n",
    "print(not_lazee(\"String\" * \"string\",3,43))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 9\n",
      "[1] 7\n"
     ]
    }
   ],
   "source": [
    "lazier <- function(a,b = 2*a)\n",
    "    {\n",
    "    a + b\n",
    "}\n",
    "print(lazier(3))\n",
    "print(lazier(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"command\" \"var1\"    \"var2\"   \n",
      "\n",
      " [1] \"a\"                  \"b\"                  \"end\"               \n",
      " [4] \"explicit_return\"    \"feature\"            \"float\"             \n",
      " [7] \"haystack\"           \"i\"                  \"implicit_return\"   \n",
      "[10] \"keywords\"           \"keywords_trouble\"   \"largest_num\"       \n",
      "[13] \"lazee\"              \"lazier\"             \"laziest\"           \n",
      "[16] \"my_first_function\"  \"my_second_function\" \"not_lazee\"         \n",
      "[19] \"num1\"               \"num2\"               \"param_example\"     \n",
      "[22] \"results_l\"          \"results_s\"          \"translation\"       \n",
      "[25] \"truncated\"          \"vec1\"               \"vec3\"              \n",
      "[28] \"vec4\"               \"word\"              \n"
     ]
    }
   ],
   "source": [
    "laziest <- function(command = ls())\n",
    "{\n",
    "    var1 <- 2\n",
    "    var2 <- 3\n",
    "    command\n",
    "}\n",
    "print(laziest())\n",
    "cat(\"\\n\")\n",
    "print(laziest(ls()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## User-Defined Infix Functions\n",
    "- It is possible in `R` to name a function such that it can be called as `arg FUNCTION_NAME arg`\n",
    "- Any function whose name begins and ends with the percent symbol (`%`) is an infix function\n",
    "    - When declaring this function, the name must be enclosed in backticks (`)\n",
    "```R\n",
    "`%FUNCTION%` <- function(a,b){}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"String another\"\n",
      "[1] \"String 45\"\n",
      "[1] \"45 String\"\n"
     ]
    }
   ],
   "source": [
    "`%+%` <- function(a,b){\n",
    "    paste(a,b)\n",
    "}\n",
    "print(\"String\" %+% \"another\")\n",
    "print(\"String\" %+% 45)\n",
    "\n",
    "print(45 %+% \"String\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"String another\"\n",
      "[1] \"String 45\"\n",
      "[1] \"45 String\"\n"
     ]
    }
   ],
   "source": [
    "#`% %` <- paste -- this works too\n",
    "`% %` <- function(a,b){\n",
    "    paste(a,b)\n",
    "}\n",
    "print(\"String\" % % \"another\")\n",
    "print(\"String\" % % 45)\n",
    "print(45 % % \"String\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assignment Functions\n",
    "- We have seen many uses of functions to perform assignment\n",
    "```R\n",
    "names(vec) <- c(NAMES)\n",
    "```\n",
    "- These are actually special functions, \n",
    "    - The assignment operator is the last two characters of the function name\n",
    "    - Must use backticks again when declaring the function\n",
    "```R\n",
    "`FUNCTION_NAME<-` <- function(object,value){}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1 2 3 4\n",
      "[1] 4 2 3 4\n",
      "[1] 8 2 3 4\n"
     ]
    }
   ],
   "source": [
    "`multiply_first<-` <- function(x,value)\n",
    "{\n",
    "    x[1] <- x[1] * value\n",
    "    x\n",
    "}\n",
    "vec_to_change <- c(1,2,3,4)\n",
    "print(vec_to_change)\n",
    "multiply_first(vec_to_change) <- 4\n",
    "print(vec_to_change)\n",
    "multiply_first(vec_to_change) <- 2\n",
    "print(vec_to_change)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operator Overriding\n",
    "- Every operator in `R` is just a call to a function\n",
    "- To override the definition, enclose the operator in backticks and assign a new function to is\n",
    "```R\n",
    "`+` <- function(a,b){ a - b}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 7\n",
      "[1] 7\n",
      "\n",
      "[1] 11\n",
      "[1] 11\n"
     ]
    }
   ],
   "source": [
    "print(3 + 4)\n",
    "print(`+`(3,4))\n",
    "\n",
    "cat(\"\\n\")\n",
    "vec_again <- 10:15\n",
    "print(vec_again[2])\n",
    "print(`[`(vec_again,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] -1\n",
      "[1] 99\n",
      "\n",
      "[1] 7\n",
      "[1] 101\n"
     ]
    }
   ],
   "source": [
    "`+` <- function(a,b){ a - b}\n",
    "print(3 + 4)\n",
    "print(100+1)\n",
    "rm(`+`)\n",
    "cat(\"\\n\")\n",
    "print(3 + 4)\n",
    "print(100+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Sorry, you can't do that\"\n",
      "[1] 11\n",
      "\n",
      "[1] 11\n"
     ]
    }
   ],
   "source": [
    "`[` <- function(obj,index){\n",
    "    \"Sorry, you can't do that\"\n",
    "}\n",
    "print(vec_again[2])\n",
    "print(vec_again[[2]])\n",
    "rm(`[`)\n",
    "cat(\"\\n\")\n",
    "print(vec_again[2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objects in R\n",
    "- `R` supports three different types of objects, all declared and used in different ways\n",
    "    - S3 objects\n",
    "    - S4 objects\n",
    "    - RC objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## S3 Objects\n",
    "- S3 objects are the simplest and most common type of object in `R`\n",
    "- Based of the design of objects in the third version of the `S` language\n",
    "    - Came out in 1988\n",
    "    - Switched from FORTRAN to C\n",
    "- Methods don't belong to objects, uses a form of object-oriented programming known as generics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating an S3 Object\n",
    "- Any existing object can be converted into an S3 object\n",
    "    - Use the `structure` function and assign the results to a variable\n",
    "    - Use the assignment version of the `class` function to give an existing variable a class attribute\n",
    "- Both of these methods create a single instance at a time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 1 2 3 4 5\n",
      "attr(,\"class\")\n",
      "[1] \"specialVector\"\n",
      "Class 'specialVector'  int [1:5] 1 2 3 4 5\n",
      "NULL\n"
     ]
    }
   ],
   "source": [
    "my_first_instance <- structure(1:5,class=\"specialVector\")\n",
    "print(my_first_instance)\n",
    "print(str(my_first_instance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$a_member\n",
      "[1] 2\n",
      "\n",
      "$another\n",
      "[1] \"A String\"\n",
      "\n",
      "List of 2\n",
      " $ a_member: num 2\n",
      " $ another : chr \"A String\"\n",
      " - attr(*, \"class\")= chr \"listClass\"\n",
      "NULL\n"
     ]
    }
   ],
   "source": [
    "my_second_instance <- list(a_member = 2, another= \"A String\")\n",
    "print(my_second_instance)\n",
    "\n",
    "class(my_second_instance) <- \"listClass\"\n",
    "print(str(my_second_instance))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## S3 Constructor\n",
    "- An S3 constructor is one that simply hides the call to `structure` or `class` inside of a function\n",
    "- By convention, it should have the same name as the class, although this isn't strictly necessary\n",
    "```R\n",
    "class_name <- function(parameters){\n",
    "    structure(list(parameters),class=\"class_name\")\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"vehicle\"\n"
     ]
    }
   ],
   "source": [
    "vehicle <- function(n_wheels,color){\n",
    "    structure(list(m_n_wheels = n_wheels, m_color = color ),\n",
    "              class=\"vehicle\")\n",
    "}\n",
    "\n",
    "myCar <- vehicle(4,'black')\n",
    "print(class(myCar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance\n",
    "- The class attribute of an object cab actually be a vector\n",
    "    - We can use this to simulate inheritance\n",
    "    - In the previous examples, we are inheriting from the list class\n",
    "```R\n",
    "child_class <- function(parameters)\n",
    "    {\n",
    "        self <- parent_class(parameters)\n",
    "        class(self) <- append(\"child_class\",class(self))\n",
    "        self\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"car\"     \"vehicle\"\n"
     ]
    }
   ],
   "source": [
    "car <- function(color){\n",
    "    self <- vehicle(4,color)\n",
    "    class(self) <- append(\"car\",\n",
    "                          class(self))\n",
    "    self\n",
    "}\n",
    "my_new_car <- car('black')\n",
    "print(class(my_new_car))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Methods \n",
    "- `R` uses a style of OOP known as generics\n",
    "    - An object is passed to a function, which then acts on the object\n",
    "    - By writing multiple different \"versions\" of the same function, we can specify how the function should interact on a given object\n",
    "- Most functions we have seen so far are actually generics, ie\n",
    "```R\n",
    "t(df) # actually t.data.frame(df)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   [,1] [,2] [,3] [,4] [,5]\n",
      "V1    1    2    3    4    5\n",
      "V2    6    7    8    9   10\n",
      "V3   11   12   13   14   15\n",
      "V4   16   17   18   19   20\n",
      "   [,1] [,2] [,3] [,4] [,5]\n",
      "V1    1    2    3    4    5\n",
      "V2    6    7    8    9   10\n",
      "V3   11   12   13   14   15\n",
      "V4   16   17   18   19   20\n"
     ]
    }
   ],
   "source": [
    "mm <- as.data.frame(matrix(1:20,ncol=4))\n",
    "print(t(mm))\n",
    "print(t.data.frame(mm))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function (x) \n",
      "UseMethod(\"t\")\n",
      "<bytecode: 0x404e170>\n",
      "<environment: namespace:base>\n",
      "function (x) \n",
      "{\n",
      "    x <- as.matrix(x)\n",
      "    NextMethod(\"t\")\n",
      "}\n",
      "<bytecode: 0x404ec08>\n",
      "<environment: namespace:base>\n"
     ]
    }
   ],
   "source": [
    "print(t)\n",
    "\n",
    "print(t.data.frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Generic Function\n",
    "- The top level function must be created and follows a very standard format.\n",
    "    - The `UseMethod` function denotes that this function should actually dispatch to a more appropriate function, based on the object that was passed in\n",
    "- The generic function for `t` might look like\n",
    "```R\n",
    "t <- function(obj){\n",
    "        UseMethod(\"t\")\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## User-Defined Generics\n",
    "- Write a generic function with the name of the function you want\n",
    "- For each class you want to define a different version of your function for, name it as `function_name.class_name`\n",
    "    - The generic function will use the class attribute of the function passed to it to determine which to call\n",
    "- A function named `function_name.default` can be defined to be run in the event no match is found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "'My vehicle is  black in color and  has 4 wheels.'"
      ],
      "text/latex": [
       "'My vehicle is  black in color and  has 4 wheels.'"
      ],
      "text/markdown": [
       "'My vehicle is  black in color and  has 4 wheels.'"
      ],
      "text/plain": [
       "[1] \"My vehicle is  black in color and  has 4 wheels.\""
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "'My vehicle is  black in color and  has 4 wheels.'"
      ],
      "text/latex": [
       "'My vehicle is  black in color and  has 4 wheels.'"
      ],
      "text/markdown": [
       "'My vehicle is  black in color and  has 4 wheels.'"
      ],
      "text/plain": [
       "[1] \"My vehicle is  black in color and  has 4 wheels.\""
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$m_n_wheels\n",
      "[1] 4\n",
      "\n",
      "$m_color\n",
      "[1] \"black\"\n",
      "\n",
      "attr(,\"class\")\n",
      "[1] \"car\"     \"vehicle\"\n"
     ]
    }
   ],
   "source": [
    "print(my_new_car)\n",
    "print.vehicle <- function(x)\n",
    "{\n",
    "    \"My vehicle is \" % % x[['m_color']] % % \"in color and  has\" % % x$m_n_wheels % % \"wheels.\"\n",
    "}\n",
    "print(my_new_car)\n",
    "#print.vehicle <- print.default\n",
    "rm(print.vehicle)\n",
    "print(my_new_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "makeNoise <- function(x){\n",
    "    print(class(x))\n",
    "    UseMethod(\"makeNoise\")\n",
    "}\n",
    "\n",
    "makeNoise.vehicle <-function(x){\n",
    "    \"Generic Vehicle Noise\"\n",
    "}\n",
    "\n",
    "makeNoise.car <- function(x){\n",
    "    \"BEEP BEEP\"\n",
    "}\n",
    "\n",
    "makeNoise.default <- function(x){\n",
    "    \"You can't make a noise\"\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"vehicle\"\n",
      "[1] \"Generic Vehicle Noise\"\n",
      "[1] \"car\"     \"vehicle\"\n",
      "[1] \"BEEP BEEP\"\n",
      "[1] \"character\"\n",
      "[1] \"You can't make a noise\"\n"
     ]
    }
   ],
   "source": [
    "print(makeNoise(myCar))\n",
    "print(makeNoise(my_new_car))\n",
    "print(makeNoise(\"Random String\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## S4 Classes\n",
    "- S4 is based on the object system from the 4th version of S, released in 1998\n",
    "- Not as commonly found, but some more complex libraries do make uses of it\n",
    "- Very similar to S3, but more formal\n",
    "    - Classes must be initialized using the `new` function\n",
    "    - The properties of the classes are part of the definition (called `slots` in `R`)\n",
    "    - Inheritance is done through use of the `contains` keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reference Classes\n",
    "- Reference classes are the newest object system in `R`\n",
    "    - Released around 2010\n",
    "- Behave much more like traditional classes in other languages\n",
    "    - Methods now belong to objects\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.3.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}