MyThinkJulia-Ch15-StructsObjects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 15: Structs and Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Composite Types\n",
    "\n",
    "We have used many of Julia’s built-in types; now we are going to define a new type. As an example, we will create a type called Point that represents a point in two-dimensional space.\n",
    "\n",
    "There are several ways we might represent points in Julia:\n",
    "\n",
    "* We could store the coordinates separately in two variables, $x$ and $y$.\n",
    "\n",
    "* We could store the coordinates as elements in an array or tuple.\n",
    "\n",
    "* We could create a new type to represent points as objects.\n",
    "\n",
    "Creating a new type is more complicated than the other options, but it has advantages that will be apparent soon.\n",
    "\n",
    "**A programmer-defined composite type is also called a struct.** The struct definition for a point looks like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Point\n",
    "    x\n",
    "    y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The header indicates that the new struct is called `Point`. The body defines the attributes or fields of the struct. The `Point` struct has two fields: $x$ and $y$.\n",
    "\n",
    "A struct is like a factory for creating objects. To create a point, you call Point as if it were a function having as arguments the values of the fields. When Point is used as a function, it is called a **constructor**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(3.0, 4.0)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Point(3.0, 4.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a new object is called **instantiation**, and the object is an **instance** of the type.\n",
    "When you print an instance, Julia tells you what type it belongs to and what the values of the atributes are."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structs are Immutable\n",
    "\n",
    "You can get the values of the fields using . notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = p.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The expression `p.x` means, “Go to the object $p$ refers to and get the value of $x$.” In the example, we assign that value to a variable named $x$. \n",
    "\n",
    "Note that there is no conflict between the variable $x$ and the field $x$.\n",
    "\n",
    "You can use dot notation as part of any expression. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance = sqrt(p.x^2 + p.y^2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Structs are, however, by default immutable,** after construction the fields can not change value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "ErrorException",
     "evalue": "setfield! immutable struct of type Point cannot be changed",
     "output_type": "error",
     "traceback": [
      "setfield! immutable struct of type Point cannot be changed",
      "",
      "Stacktrace:",
      " [1] setproperty!(::Point, ::Symbol, ::Float64) at .\\Base.jl:21",
      " [2] top-level scope at In[6]:1"
     ]
    }
   ],
   "source": [
    "p.y = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This may seem odd at first, but it has several advantages:\n",
    "\n",
    "* It can be more efficient.\n",
    "\n",
    "* It is not possible to violate the invariants provided by the type’s constructors (see Constructors).\n",
    "\n",
    "* Code using immutable objects can be easier to reason about."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutable Structs\n",
    "\n",
    "Where required, mutable composite types can be declared with the keyword mutable struct . Here is the definition of a mutable point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "mutable struct MPoint\n",
    "    x\n",
    "    y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blank = MPoint(0.0, 0.0)\n",
    "blank.x = 3.0\n",
    "blank.y = 4.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rectangles\n",
    "\n",
    "Sometimes it is obvious what the fields of an object should be, but other times you have to make decisions. For example, imagine you are designing a type to represent rectangles.\n",
    "\n",
    "There are at least two possibilities:\n",
    "\n",
    "* You could specify one corner of the rectangle (or the center), the width, and the height.\n",
    "\n",
    "* You could specify two opposing corners.\n",
    "\n",
    "At this point it is hard to say whether either is better than the other, so we’ll implement the first one, just as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Represents a rectangle.\n",
    "fields: width, height, corner.\n",
    "\"\"\"\n",
    "struct Rectangle\n",
    "    width\n",
    "    height\n",
    "    corner\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The docstring lists the fields: `width` and `height` are numbers; `corner` is a Point object that specifies the lower-left corner. \n",
    "\n",
    "To represent a rectangle, you have to instantiate a Rectangle object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(100.0, 200.0, MPoint(0.0, 0.0))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "origin = MPoint(0.0, 0.0)\n",
    "box = Rectangle(100.0, 200.0, origin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An object that is a field of another object is **embedded**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instances as Arguments\n",
    "\n",
    "You can pass an instance as an argument in the usual way. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "printpoint (generic function with 1 method)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function printpoint(p)\n",
    "    println(\"($(p.x), $(p.y))\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3.0, 4.0)\n"
     ]
    }
   ],
   "source": [
    "printpoint(blank)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 15-1\n",
    "\n",
    "Write a function called `distancebetweenpoints` that takes two points as arguments and returns the distance between\n",
    "them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "distancebetweenpoints (generic function with 1 method)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function distancebetweenpoints(p1,p2)\n",
    "    d = sqrt( (p1.x-p2.x)^2 + (p1.y-p2.y)^2 )\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point1 = Point(0.,0.)\n",
    "point2 = Point(1.,1.)\n",
    "\n",
    "distancebetweenpoints(point1,point2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**If a mutable struct object is passed to a function as an argument, the function can modify the fields of the object.** \n",
    "\n",
    "For example, `movepoint!` takes a mutable Point object and two numbers, $dx$ and $dy$, and adds the numbers to respectively the $x$ and the $y$ attribute of the Point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "movepoint! (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function movepoint!(p, dx, dy)\n",
    "    p.x += dx\n",
    "    p.y += dy\n",
    "    nothing\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MPoint(1.0, 2.0)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "origin = MPoint(0.0, 0.0)\n",
    "movepoint!(origin, 1.0, 2.0)\n",
    "origin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the function, $p$ is an alias for origin, so when the function modifies $p$, origin changes.\n",
    "\n",
    "Passing an immutable Point object to `movepoint!` causes an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "ErrorException",
     "evalue": "setfield! immutable struct of type Point cannot be changed",
     "output_type": "error",
     "traceback": [
      "setfield! immutable struct of type Point cannot be changed",
      "",
      "Stacktrace:",
      " [1] setproperty! at .\\Base.jl:21 [inlined]",
      " [2] movepoint!(::Point, ::Float64, ::Float64) at .\\In[13]:2",
      " [3] top-level scope at In[15]:1"
     ]
    }
   ],
   "source": [
    "movepoint!(p, 1.0, 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**You can however modify the value of a mutable attribute of an immutable object.**\n",
    "\n",
    "For example, moverectangle! has as arguments a Rectangle object and two numbers, $dx$ and $dy$, and uses `movepoint!` to move the corner of the rectangle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "moverectangle! (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function moverectangle!(rect, dx, dy)\n",
    "    movepoint!(rect.corner, dx, dy)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now $p$ in `movepoint!` is an alias for $rect.corner$, so when $p$ is modified, $rect.corner$ changes also:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(100.0, 200.0, MPoint(1.0, 2.0))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "moverectangle!(box, 1.0, 2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(100.0, 200.0, MPoint(2.0, 4.0))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "box"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**WARNING: You cannot, however, reassign a mutable attribute of an immutable object.**  Reassignment would create a new object and thus modify the immutable struct object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "ErrorException",
     "evalue": "setfield! immutable struct of type Rectangle cannot be changed",
     "output_type": "error",
     "traceback": [
      "setfield! immutable struct of type Rectangle cannot be changed",
      "",
      "Stacktrace:",
      " [1] setproperty!(::Rectangle, ::Symbol, ::MPoint) at .\\Base.jl:21",
      " [2] top-level scope at In[20]:1"
     ]
    }
   ],
   "source": [
    "box.corner = MPoint(1.0, 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instances as Return Values\n",
    "\n",
    "Functions can return instances. For example, `findcenter` takes a Rectangle as an argument and returns a Point that contains the coordinates of the center of the rectangle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "findcenter (generic function with 1 method)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function findcenter(rect)\n",
    "    Point(rect.corner.x + rect.width / 2, rect.corner.y + rect.height / 2)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The expression `rect.corner.x` means, “Go to the object rect refers to and select the field named $corner$; then go to that object and select the field named $x$.\n",
    "”\n",
    "Here is an example that passes box as an argument and assigns the resulting Point to center:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(51.0, 102.0)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "center = findcenter(box)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying\n",
    "\n",
    "Aliasing can make a program difficult to read because changes in one place might have unexpected effects in another place. It is hard to keep track of all the variables that might refer to a given object. Copying an object is often an alternative to aliasing. Julia provides a function called deepcopy that can duplicate any object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, false)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 = MPoint(3.0, 4.0)\n",
    "\n",
    "p2 = deepcopy(p1)\n",
    "\n",
    "p1 ≡ p2, p1 == p2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ≡ operator indicates that `p1` and `p2` are not the same object, which is what we expected. \n",
    "\n",
    "But you might have expected == to yield true because these points contain the same data. In that case, you will be disappointed to learn that for mutable objects, the default behavior of the == operator is the same as the === operator; it checks object identity, not object equivalence. That’s because for mutable composite types, Julia doesn’t know what should be considered equivalent. \n",
    "\n",
    "At least, not yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 15-2\n",
    "\n",
    "Create a Point instance, make a copy of it and check the equivalence and the egality of both. The result can surprise you but it explains why aliasing is a non issue for an immutable object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, true)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "immutable_point = Point(1,1)\n",
    "deepcopy_immutable_point = deepcopy(immutable_point)\n",
    "\n",
    "immutable_point === deepcopy_immutable_point, immutable_point == deepcopy_immutable_point\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging\n",
    "\n",
    "When you start working with objects, you are likely to encounter some new exceptions.\n",
    "\n",
    "If you are not sure what type an object is, you can ask:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p isa Point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(:x, :y)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fieldnames(Point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isdefined(p, :x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first argument can be any object; the second argument is a symbol, : followed by the name of the field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}