julia-object-model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9e314175",
   "metadata": {},
   "source": [
    "# Understanding Julia's Object Model For Python Developers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cec6064d",
   "metadata": {},
   "source": [
    "- Python is an object-oriented language.\n",
    "- Julia is not object-oriented.\n",
    "- It seems converting the Python object code to a Julia counterpart is not straightforward.\n",
    "- But it is not true."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37484b3c",
   "metadata": {},
   "source": [
    "__________"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1db32afb",
   "metadata": {},
   "source": [
    "## A Simple Python Class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03fead9",
   "metadata": {},
   "source": [
    "- Suppose we have **Vector2D** class that represents a vector in a 2-dimensional Euclidean space.\n",
    "- **Vector2d** implements a constructor with $x$ and $y$.\n",
    "- The vector summation operator is implemented by overloading the $+$ operator.\n",
    "- The implementation is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "218307ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2D:\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return Vector2D(self.x + other.x, self.y + other.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e28530e",
   "metadata": {},
   "source": [
    "- Now suppose the vector $u$ is defined as $u = [1, 2]$.\n",
    "- The vector $v$ is defined as $v = [3, 4]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bce7c3e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = Vector2D(1, 2)\n",
    "v = Vector2D(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c9e5b31",
   "metadata": {},
   "source": [
    "- Sum of $u$ and $v$ is obtained by the overloaded `__add__` for **Vector2D** class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a57c2642",
   "metadata": {},
   "outputs": [],
   "source": [
    "mysum = u + v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6621229",
   "metadata": {},
   "source": [
    "- As expected, newly created vector has components of $[1 + 3, 2 + 4] = [4, 6]$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d1d9f781",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a58d8b47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum.y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04cf046e",
   "metadata": {},
   "source": [
    "## The Julia Counterpart of Vector2D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9229b1ca",
   "metadata": {},
   "source": [
    "- Julia has a **struct** keyword for creating user-defined data types.\n",
    "- Note that a Python class is also a data type.\n",
    "- Julia supports defining multiple implementations of a single **function**.\n",
    "- Those instances are called **methods**. \n",
    "- Calling a function with different types of arguments is handled by **multiple dispatch**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a311a3",
   "metadata": {},
   "source": [
    "------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0c0d77d",
   "metadata": {},
   "source": [
    "- Let's define a new data type called **Vector2D**:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c11730e4",
   "metadata": {},
   "source": [
    "```julia\n",
    "struct Vector2D\n",
    "    x\n",
    "    y\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81054d9",
   "metadata": {},
   "source": [
    "- Creating an instance is similar to that in the Python code: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "397b891a",
   "metadata": {},
   "source": [
    "```julia\n",
    "u = Vector2D(1, 2)\n",
    "v = Vector2D(3, 4)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7675885",
   "metadata": {},
   "source": [
    "- The **Vector2D** struct does not encapsulate the summation operator.\n",
    "- The **Vector2D** data type only includes its data.\n",
    "- We would implement a constructor, however, we want to keep it simple at this stage.\n",
    "- $+$ operator defined in the **Base** can be re-implemented for the new type:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d13b6e",
   "metadata": {},
   "source": [
    "```julia\n",
    "Base.:+(u::Vector2D, v::Vector2D) = Vector2D(u.x + v.x, u.y + v.y)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1943098",
   "metadata": {},
   "source": [
    "- After creating a new **method** for the function `Base.:+`, we are able to sum $u$ and $v$:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a2164a",
   "metadata": {},
   "source": [
    "```julia\n",
    "mysum = u + v\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "043893fd",
   "metadata": {},
   "source": [
    "- The result is a new **Vector2D** with $x = 4$ and $y = 6$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a334870d",
   "metadata": {},
   "source": [
    "- Here is the whole code:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be667671",
   "metadata": {},
   "source": [
    "```julia\n",
    "struct Point2D\n",
    "    x\n",
    "    y\n",
    "end\n",
    "\n",
    "Base.:+(u::Vector2D, v::Vector2D) = Vector2D(u.x + v.x, u.y + v.y)\n",
    "\n",
    "u = Point2D(1, 2)\n",
    "v = Point2D(3, 4)\n",
    "\n",
    "mysum = u + v\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff14119f",
   "metadata": {},
   "source": [
    "## Defining Multiple Constructors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70670464",
   "metadata": {},
   "source": [
    "- Python does not support multiple-definition of `__init__`.\n",
    "- Multiple definition is handled by **default** values of arguments.\n",
    "- Suppose the default values for $x$ and $y$ are zero. \n",
    "- In Python class, we can update the constructor as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cbbc265b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2D:\n",
    "    \n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return Vector2D(self.x + other.x, self.y + other.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90d7f42f",
   "metadata": {},
   "source": [
    "- Now, creating an object of **Vector2D** without argumens will end up with a $[0, 0]$ vector.\n",
    "- Providing a single argument will result $[x, 0]$ or $[0, y]$, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9112226f",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = Vector2D()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dc436b25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(u.x, u.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "15bc9316",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector2D(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "59a49cb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 0)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v.x, v.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e55f4b65",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Vector2D(x = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "44f13f71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 0)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a.x, a.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "27b88374",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = Vector2D(y = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e8aacc2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 10)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(b.x, b.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62e43141",
   "metadata": {},
   "source": [
    "## The Julia Counterpart of Defining Multiple Constructors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "119ebe7e",
   "metadata": {},
   "source": [
    "- Recall `Vector2D(3, 4)` creates a vector with $x=3$ and $y = 4$. \n",
    "- We can define multiple methods with the same name with different number and type of arguments as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f34b96c",
   "metadata": {},
   "source": [
    "```julia\n",
    "Vector2D() = Vector2D(0,0)\n",
    "Vector2D(x) = Vector2D(x, x)\n",
    "Vector2D(; x = 0, y = 0) = Vector2D(x, y)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62ae5d80",
   "metadata": {},
   "source": [
    "- `Vector2D()` returns a new **Vector2D** with $x=0$ and $y=0$.\n",
    "- `Vector2D(5)` returns a new **Vector2D** with $x = 5$ and $y = 5$.\n",
    "- `Vector2D(x = 7, y = 9)` returns a new **Vector2D** with $x = 7$ and $y = 9$. In this case, the order of the arguments is not important and `Vector2D(y = 9, x = 7)` produces the same result.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6a83506",
   "metadata": {},
   "source": [
    "## In Short..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b350bf2",
   "metadata": {},
   "source": [
    "- Suppose the Python code is `a.f(x)` where **a** is an object, **f** is the object method, and **x** is the argument.\n",
    "- The Julia counterpart of this code is `f(a, x)` where **f** is the function, **a** is an instance of a **struct**, and **x** is the argument. If **f** is the reimplementation of a function than it is called a **method** and it is multiple dispacted for the specific types of **a** and **x**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5e2913b",
   "metadata": {},
   "source": [
    "## Immutability vs. Mutability"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac8ab7e4",
   "metadata": {},
   "source": [
    "- Object members in Python are **mutable**.\n",
    "- That means at any stage of the program, object members can be changed.\n",
    "- Julia user-defined data types are **immutable** by default.\n",
    "- **Mutability** of members should be declared explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "73aeedf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2D:\n",
    "    \n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7b9a1e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = Vector2D(5, 10)\n",
    "u.x = -20\n",
    "u.y = -20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "500859fb",
   "metadata": {},
   "source": [
    "- In the code above, members of vector $u$ are mutated.\n",
    "- The new state of the vector u is $[-20, -20]$.\n",
    "- Let's take a look at the Julia counterpart:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02379fb2",
   "metadata": {},
   "source": [
    "```julia\n",
    "struct Vector2D\n",
    "    x\n",
    "    y\n",
    "end\n",
    "\n",
    "u = Vector2D(5, 10)\n",
    "u.x = -20\n",
    "u.y = -20\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb4823b9",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> u.x = -20\n",
    "ERROR: setfield!: immutable struct of type Vector2D cannot be changed\n",
    "Stacktrace:\n",
    " [1] setproperty!(x::Vector2D, f::Symbol, v::Int64)\n",
    "   @ Base ./Base.jl:38\n",
    " [2] top-level scope\n",
    "   @ REPL[17]:1\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "047d5966",
   "metadata": {},
   "source": [
    "- By immutability, Julia compiles the source code into a more efficient binary code.\n",
    "- If **mutation** is needed, the data type can be implemented by **mutable** keyword:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae16ac2",
   "metadata": {},
   "source": [
    "```julia\n",
    "mutable struct Vector2D\n",
    "    x\n",
    "    y\n",
    "end\n",
    "\n",
    "u = Vector2D(5, 10)\n",
    "u.x = -20\n",
    "u.y = -20\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1068b77",
   "metadata": {},
   "source": [
    "- The new definion of **Vector2D** now allows mutating its member fields.\n",
    "- In latest versions of Julia, a specific member of a data type can be defined with keyword **mutable** by keeping the remaining fields **immutable**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe88b99b",
   "metadata": {},
   "source": [
    "## Implementing `__repr__` and `__str__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83c2ce05",
   "metadata": {},
   "source": [
    "- Python provides some methods for representing the objects.\n",
    "- `__repr__` and `__str__` are special functions for representing the object in REPL and obtaining a `str` representation of object, respectively.\n",
    "- Suppose the **Vector2D** is reimplemented with these methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c5d75757",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2D:\n",
    "    \n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"Vector2D({self.x}, {self.y})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"Vector2D({self.x}, {self.y})\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2764b961",
   "metadata": {},
   "source": [
    "- When we create an instance of this object, we can *pretty-print* it by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "47c12fc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector2D(5, 7)\n"
     ]
    }
   ],
   "source": [
    "u = Vector2D(5, 7)\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a47d588c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2D(5, 7)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9036b90",
   "metadata": {},
   "source": [
    "## The Julia Counterparts of `__repr__` and `__str__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56030bdb",
   "metadata": {},
   "source": [
    "- Julia provides default *printer*s for user-defined data types:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f575f1bf",
   "metadata": {},
   "source": [
    "```julia\n",
    "mutable struct Vector2D\n",
    "    x\n",
    "    y\n",
    "end\n",
    "\n",
    "u = Vector2D(5, 10)\n",
    "\n",
    "julia> u\n",
    "Vector2D(5, 10)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7bb904f",
   "metadata": {},
   "source": [
    "- `show` function can be redefined to create a method for printing **Vector2D**.\n",
    "- This function is defined in the **Base** module of Julia."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6752830",
   "metadata": {},
   "source": [
    "```julia \n",
    "Base.show(io::IO, v::Vector2D) = println(io, \"-> Vector2D($(v.x), $(v.y))\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16301a67",
   "metadata": {},
   "source": [
    "- Now, any object in type of **Vector2D** is represented in a new form:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f757911",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> u\n",
    "-> Vector2D(5, 10)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17a466b5",
   "metadata": {},
   "source": [
    "- `string` function converts its argument into string data type.\n",
    "- This function works for object in many types (by multiple dispatch).\n",
    "- Let's implement a method for this function for converting **Vector2D** to string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41ff4a38",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> Base.string(v::Vector2D) = \"Vector2D[x = $(v.x), y = $(v.y)]\"\n",
    "\n",
    "julia> string(u)\n",
    "\"Vector2D[x = 5, y = 10]\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0f85c8a",
   "metadata": {},
   "source": [
    "- `convert` defined in **Base** module can also be redefined to convert **Vector2D** to String."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f0e6fab",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> Base.convert(::Type{String}, v::Vector2D) = \"Vector2D[x = $(v.x), y = $(v.y)]\"\n",
    "\n",
    "julia> convert(String, u)\n",
    "\"Vector2D[x = 5, y = 10]\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c80983ce",
   "metadata": {},
   "source": [
    "## Type Hints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2297ab19",
   "metadata": {},
   "source": [
    "- Python's type system is dynamic (so does Julia's, but works in a different way!).\n",
    "- `def f(x, y)` accepts $x$ and $y$ of any types.\n",
    "- Type hints defines types for function arguments.\n",
    "- These type hintings doesn't prevent passing of arguments in illegal (or unsupported) types.\n",
    "- Suppose we redefine **Vector2D** with **float** data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "03402301",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2D:\n",
    "    \n",
    "    def __init__(self, x: float, y: float):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"Vector2D({self.x}, {self.y})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "51f4bd6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = Vector2D(5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6ef2dd03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2D(5, 6)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c833e70c",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector2D(5.0, 6.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "5cf5b0ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2D(5.0, 6.0)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff4b74fe",
   "metadata": {},
   "source": [
    "- Type hints don't have an effect here (at runtime).\n",
    "- Object creation for int types are also possible.\n",
    "- However, it is a useful feature for linting, documenting, and auto-completion of IDEs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a10fea23",
   "metadata": {},
   "source": [
    "## Julia Counterpart of Python's Type Hints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f752950f",
   "metadata": {},
   "source": [
    "- There is not a 1-1 correspondence between Python's Type Hints and Julia's type system.\n",
    "- Method invocation in Julia is based on real types.\n",
    "- Suppose **Vector2D** is defined for float data type in Julia"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4355e47",
   "metadata": {},
   "source": [
    "```julia\n",
    "struct Vector2D\n",
    "    x::Float64\n",
    "    y::Float64\n",
    "end \n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70860f8f",
   "metadata": {},
   "source": [
    "- Let's create an instance with $x=10$ and $y = 5$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bd08d9b",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> Vector2D(10.0, 5.0)\n",
    "Vector2D(10.0, 5.0)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b8091a7",
   "metadata": {},
   "source": [
    "- Object creation using **Complex** is not possible, because, user-defined type **Vector2D** is not defined for **Complex** data type."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e6bf1ea",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> Vector2D(3, 7 + 2im)\n",
    "ERROR: InexactError: Float64(7 + 2im)\n",
    "Stacktrace:\n",
    " [1] Real\n",
    "   @ ./complex.jl:44 [inlined]\n",
    " [2] convert\n",
    "   @ ./number.jl:7 [inlined]\n",
    " [3] Vector2D(x::Int64, y::Complex{Int64})\n",
    "   @ Main ./REPL[1]:2\n",
    " [4] top-level scope\n",
    "   @ REPL[7]:1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f819847f",
   "metadata": {},
   "source": [
    "- Function/Method definitons can be restricted for a small set of type of arguments:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa279adc",
   "metadata": {},
   "source": [
    "```julia\n",
    "julia> function f(x::Int64, y::Int64)::Int64\n",
    "           if x < y\n",
    "               return x\n",
    "           else\n",
    "               return x + y\n",
    "           end\n",
    "       end \n",
    "f (generic function with 1 method)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99f1b42b",
   "metadata": {},
   "source": [
    "- Calls like `f(2.3, 6)` is not allowed: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab4ea945",
   "metadata": {},
   "source": [
    "```julia\n",
    "ulia> f(2.3, 6)\n",
    "ERROR: MethodError: no method matching f(::Float64, ::Int64)\n",
    "\n",
    "Closest candidates are:\n",
    "  f(::Int64, ::Int64)\n",
    "   @ Main REPL[8]:1\n",
    "\n",
    "Stacktrace:\n",
    " [1] top-level scope\n",
    "   @ REPL[9]:1\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96b033c3",
   "metadata": {},
   "source": [
    "## Finally..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1afc716c",
   "metadata": {},
   "source": [
    "- Suppose you decide to migrate your Python codebase to Julia.\n",
    "- Implement **struct**s for each Python class in Julia.\n",
    "- If object members are mutable, use **mutable struct**.\n",
    "- Define new methods (or operators) that work with these new types."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d719e1f3",
   "metadata": {},
   "source": [
    "## A full example for **Vector2D**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d2b18b",
   "metadata": {},
   "source": [
    "### The Python Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7285a14a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2D:\n",
    "\n",
    "    def __init__(self, x, y): \n",
    "        self.x = x \n",
    "        self.y = y \n",
    "\n",
    "    def __add__(self, other):\n",
    "        return Vector2D(self.x + other.x, self.y + other.y)\n",
    "\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        return Vector2D(self.x - other.x, self.y - other.y)\n",
    "\n",
    "    def __mul__(self, other) -> float:\n",
    "        return self.x * other.x + self.y * other.y\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Vector2D({self.x}, {self.y})\"\n",
    "\n",
    "u = Vector2D(1, 2)\n",
    "v = Vector2D(2, 3)\n",
    "\n",
    "mysum = u + v \n",
    "mydiff = u - v \n",
    "mymul = u * v \n",
    "\n",
    "print(mysum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ccaa685",
   "metadata": {},
   "source": [
    "### The Julia Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0abb73c9",
   "metadata": {},
   "source": [
    "```julia\n",
    "struct Vector2D\n",
    "  x\n",
    "  y\n",
    "end \n",
    "\n",
    "Base.:+(u::Vector2D, v::Vector2D) = Vector2D(u.x + v.x, u.y + v.y)\n",
    "Base.:-(u::Vector2D, v::Vector2D) = Vector2D(u.x - v.x, u.y - v.y)\n",
    "Base.:*(u::Vector2D, v::Vector2D)::Float64 = Float64(u.x * v.x + u.y * v.y)\n",
    "\n",
    "u = Vector2D(1, 2)\n",
    "v = Vector2D(2, 3)\n",
    "\n",
    "mysum = u + v \n",
    "mydiff = u - v \n",
    "mymul = u * v \n",
    "\n",
    "println(mysum)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60400c70",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}