08_callable_objects.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "08_callable_objects.ipynb",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0lydXhp2x2KU",
    "colab_type": "text"
   },
   "source": [
    "# Callable Object: Functor\n",
    "\n",
    "In Python the most common type of functor is the Function. There are many other types of functors in Python: Lambda, Method, Module, Package and Class.\n",
    "\n",
    "It may seem odd to see module and package on that list. We will come back to this idea in the Module section. Here we will focus on the three functors that typically come to mind first when thinking of callable objects: \n",
    "\n",
    "- Function\n",
    "- Lambda\n",
    "- Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "07WQiHAJzXUU",
    "colab_type": "text"
   },
   "source": [
    "## Function"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "This is a simple function to test if an integer is even or odd."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "QVIZ_7IYv7O3",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "def is_even(number: int) -> bool:\n",
    "    return number % 2 == 0"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qPkG9r8O8xsm",
    "colab_type": "text"
   },
   "source": [
    "Functions are the most common type of callable object in Python, perhaps in all of programming. \n",
    "\n",
    "The function above has several parts:\n",
    "\n",
    "- `def` This is the function definition keyword. Everything indented under it is considered inside that function. This is function scope. Everything in the function scope must be defined before it is used. This is the closest thing to block scope that we have in Python.\n",
    "- `is_even()` This is the name of the function. This is used to invoke the function later, this is also known as calling the function.\n",
    "- `number` This is the parameter named \"number\", it asks for an `int` type input argument.  \n",
    "- `: int` This is a type hint, they come after a colon after an argument. Type hints are not enforced by Python, and they are relatively new to the language. Type hints are always optional and rarely used.\n",
    "- `-> bool` This is the return type hint, it is also optional.\n",
    "- `return` This is the return statement of the function. Python supports the use of multiple returns in a single function. This is frowned upon in some circles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "csqjF6jjBtOA",
    "colab_type": "text"
   },
   "source": [
    "Lets test our function in a loop:"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "60Yj9las9SGe",
    "colab_type": "code",
    "outputId": "0d707189-34a3-48b8-d44d-fbb240244de6",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 187
    }
   },
   "source": [
    "for num in range(10):\n",
    "    print(num, is_even(num))"
   ],
   "execution_count": 2,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "0 True\n",
      "1 False\n",
      "2 True\n",
      "3 False\n",
      "4 True\n",
      "5 False\n",
      "6 True\n",
      "7 False\n",
      "8 True\n",
      "9 False\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YOp3V1PPJYjY",
    "colab_type": "text"
   },
   "source": [
    "The `is_even()` function above takes only one positional argument. Functions, lambdas and methods can be defined in such a way to take an arbitrary number of arguments with the `*args` parameter. This is related to the `**kwargs` parameter, we'll see more about `**kwargs` in a future lesson. They are often seen together, but they do not depend on one another. Each of them are capable of allowing you to define functions that take an arbitrary number of arguments. This difference is that `args` is more like a list of arguments and `kwargs` is more like a dictionary of named arguments."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "jbHYo-m3LCRw",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "def print_all(*args):\n",
    "    for itm in args:\n",
    "        print(itm)"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "r5LlxxEyMaUr",
    "colab_type": "code",
    "outputId": "c44fa502-407c-410f-9ff5-9213a7fb0a96",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    }
   },
   "source": [
    "print_all(\"One to Five:\", 1, 2, 3, 4, 5)"
   ],
   "execution_count": 5,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "One to Five:\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EH0anIgzNRG7",
    "colab_type": "text"
   },
   "source": [
    "We can combine these ideas with the `map()` function.\n",
    "\n",
    "[Map Function | python.org](https://docs.python.org/3/library/functions.html#map)"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "N2KpaDByNU0c",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "def is_even_map(*args):\n",
    "    return list(map(is_even, args))"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "geD9D18CNh5n",
    "colab_type": "code",
    "outputId": "3eda2e3a-e7f3-4c23-df3b-1b2616727b75",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(is_even_map(1, 2, 3, 4, 5, 6))"
   ],
   "execution_count": 7,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "[False, True, False, True, False, True]\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OxM0eeebzdO9",
    "colab_type": "text"
   },
   "source": [
    "## Lambda\n",
    "\n",
    "Lambdas are very similar to anonymous functions in other languages. They're defined in-line and they're considered beautiful when done properly. Lambdas have one clear advantage over other types of callable objects: they're very terse. They also have one subtle advantage: they can be defined in places where function cannot. However, no matter what you're doing, if a lambda can do it, then there's also a way to use a proper function or method instead.\n",
    "\n",
    "Generally speaking if your lambda is over 30 characters, you're doing it wrong. This is not a hard limit, however you only get one line to define a lambda, and they often don't begin at the beginning of a line, do the math.\n",
    "\n",
    "A wise hacker once said...\n",
    "\n",
    "`lambda(lambda) -> lambda` always solves everything - for arbitrary definitions of \"always\", \"solves\" and \"everything\". \n",
    "\n",
    "Let that sink in. It's called Lambda Calculus, and unfortunately - it's totally beyond the scope of this teaching guide. Lambda Calculus is one of the most fundamental ideas in programming, please go check it out. It will blow your mind... in a good way."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "wfMsBeYAdAuw",
    "colab_type": "code",
    "outputId": "4090d133-52cf-46ef-9452-53606ca00b64",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "# Named Lambda\n",
    "callable_lambda = lambda x: 2**x\n",
    "print(callable_lambda(8))"
   ],
   "execution_count": 8,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "256\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nPixMDM8dZ8v",
    "colab_type": "text"
   },
   "source": [
    "This same thing can be done in one line (see below), it resembles what in JavaScript is known as an IIFE or Immediately Invoked Function Expression. Notice that the lambda suddenly requires a pair of enclosing parens. This is to disambiguate the calling perens from the lambda itself."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "XKe73jlCE5zt",
    "colab_type": "code",
    "outputId": "0369a86c-e822-4d8d-ced7-7bd5b072969a",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "# Immediately Invoked Annonymous Lambda\n",
    "# print(lambda x: 2**x(8))  # This doesn't work\n",
    "print((lambda x: 2**x)(8))"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "256\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_t0Li_Omzaam",
    "colab_type": "text"
   },
   "source": [
    "## Method\n",
    "\n",
    "Methods are similar to functions, but they live inside classes. While this is true, it kinda misses the point. Methods will be discussed in more detail in the Classes Module. \n",
    "\n",
    "Here's a simple example of a classmethod featuring the builtin `sum()` function and the `randint()` function from the random module.\n",
    "\n",
    "[Sum Function | python.org](https://docs.python.org/3/library/functions.html#sum)\n",
    "\n",
    "[Random Module | python.org](https://docs.python.org/2/library/random.html)"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "qzehjRTxkvLo",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "import random"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "X35zUbXozcyc",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "class Wizard:\n",
    "    hit_dice = 6\n",
    "    level = 10\n",
    "\n",
    "    @classmethod\n",
    "    def total_health(cls):\n",
    "        return sum(random.randint(1, cls.hit_dice) for _ in range(cls.level))"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "TVGoFkysfrN4",
    "colab_type": "code",
    "outputId": "b6452c1f-688c-42ad-9a9b-94a310912f97",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(Wizard.total_health())"
   ],
   "execution_count": 12,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "27\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U2J7hPL7f_Sr",
    "colab_type": "text"
   },
   "source": [
    "Here's a simple example of an instance method...\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "cy5iW9GigN91",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "class Fighter:\n",
    "    damage = 6\n",
    "    attacks = 4\n",
    "\n",
    "    def calculate_damage(self):\n",
    "        return sum(random.randint(1, self.damage) for _ in range(self.attacks))"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "NKsVp8AqgvzC",
    "colab_type": "code",
    "outputId": "22f1e263-45e5-4418-c0b9-acc5a31fd5cc",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "fighter = Fighter()\n",
    "print(fighter.calculate_damage())"
   ],
   "execution_count": 14,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "15\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r_yZsn77hBz2",
    "colab_type": "text"
   },
   "source": [
    "The above example is contrived to illustrate two types of methods. This is not intended to be a good example of how to write classes. The Fighter and Wizard classes should be polymorphic and these are not. More information on polymorphism and other OOP concepts will be found in the Classes Module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3Cpft2Qn6H_i",
    "colab_type": "text"
   },
   "source": [
    "## The ID Functor, in Three Forms...\n",
    "\n",
    "The ID Function is really simple, it might be the most simple function that does something, because it nearly does nothing. It takes one argument and returns it. While this function may seem useless, it really isn't (see lambda calculus). However, it's only used here as a simple example to compare the syntax of the three functor types.\n",
    "\n",
    "The choice between creating a function, lambda or method is largely one of style. Your team may establish norms and you should follow them, project consistancy is paramount. When in doubt, choose the function style, it will never let you down."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4XeLqkWJ3tdo",
    "colab_type": "text"
   },
   "source": [
    "__ID Function:__"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "igY1P-YF3war",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "def id_func(obj):\n",
    "    return obj"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "tFUAX4jm6tfR",
    "colab_type": "code",
    "outputId": "cd6963c9-24a9-4d3d-903e-1d34cab92342",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(id_func(42))"
   ],
   "execution_count": 16,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "42\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zx2NLAsD-Iuk",
    "colab_type": "text"
   },
   "source": [
    "__ID Lambda:__"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "lI1f4Jlbzknq",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "id = lambda obj: obj"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "_5-T88ls6zLd",
    "colab_type": "code",
    "outputId": "c7c8d29c-a2d5-4a0b-b5cd-10c078cca9f7",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(id(42))"
   ],
   "execution_count": 18,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "42\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dpgt_3VTF5gL",
    "colab_type": "text"
   },
   "source": [
    "> For the lambda expression itself, you can't use any annotations (the syntax on which Python's type hinting is built). ~StackOverflow\n",
    "\n",
    "[Lambda Type Hints | Stack Overflow](https://stackoverflow.com/questions/33833881/is-it-possible-to-type-hint-a-lambda-function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P1Kbd75u35Ai",
    "colab_type": "text"
   },
   "source": [
    "__ID Method:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Za-qdHhUy-i7",
    "colab_type": "text"
   },
   "source": [
    "In C++ this method is known as the call operator. If this method is defined on a Python class, the resulting instance(s) will be callable."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Svx_Ys2R369Y",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "class Identity:\n",
    "    \"\"\" Produces a callable instance. \"\"\"\n",
    "\n",
    "    def __call__(self, obj):\n",
    "        \"\"\" Models the identity function. \"\"\"\n",
    "        return obj\n",
    "        "
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "t4SpgvlO64W0",
    "colab_type": "code",
    "outputId": "f53161ae-e081-4273-c243-0c1bd272be4b",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "id_object = Identity()\n",
    "print(id_object(42))"
   ],
   "execution_count": 20,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "42\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vdjszeJVxjp6",
    "colab_type": "text"
   },
   "source": [
    "This is wrong:\n",
    "```\n",
    "Identity.__call__()  # Magic Methods are never called by name\n",
    "```\n",
    "Prefered way to invoke a callable instance:\n",
    "```\n",
    "obj = Identity()     # instantiation\n",
    "obj()                # invocation\n",
    "```\n",
    "Curious Alternative:\n",
    "```\n",
    "Identity()()         # both at once\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c23Ut7Kia7di",
    "colab_type": "text"
   },
   "source": [
    "It should be noted that all three of the id functors above are also higher-order functors. Which leads us to the next section of this module...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7rQHaFEmHeRO",
    "colab_type": "text"
   },
   "source": [
    "## Higher Order Functor\n",
    "\n",
    "Unlike first-order functors, the higher-order functor is a functor that takes another functor as input, or returns an uncalled functor as output. Functions, lambdas and methods are all first-class objects in Python, so if you want to pass a functor to another functor, you can treat it as any other object.\n",
    "\n",
    "For this example we will look at `apply()`, a functor that takes a functor and an arbitrary number of additional arguments as input. This functor will call the input functor with the other arguments as its input, and then it will return the result."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Yv-xQGuWG-Cf",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "def apply(func, *args, **kwargs):\n",
    "    return func(*args, **kwargs)"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "n_OW7NuZRPxY",
    "colab_type": "code",
    "outputId": "bcfd4710-8039-4916-b6f1-ee9e31d57868",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(apply(id, 42))"
   ],
   "execution_count": 22,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "42\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M6ZHsCKLPwXf",
    "colab_type": "text"
   },
   "source": [
    "The opposite of `apply()` might be `bind()`. Bind takes a functor and its arguments as input, then returns a callable rather than returning the result of calling it. The functor is wrapped in a lambda, composed with its arguments and made ready to be called later with no additional inputs."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZMS8l_-3Jxen",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "def bind(func, *args, **kwargs):\n",
    "    return lambda: func(*args, **kwargs)"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ADQT_jghQkyI",
    "colab_type": "code",
    "colab": {}
   },
   "source": [
    "bound_id = bind(id, 42)"
   ],
   "execution_count": 0,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zSTFoL3qVrJC",
    "colab_type": "text"
   },
   "source": [
    "Don't forget to call the bound functor..."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "eQI1SZtWQyy_",
    "colab_type": "code",
    "outputId": "7983bcae-99c2-411f-9437-4fd1d76e4d6c",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(bound_id)  # not called"
   ],
   "execution_count": 25,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "<function bind.<locals>.<lambda> at 0x7f7b701c6b70>\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "pJtgwNCOVm1H",
    "colab_type": "code",
    "outputId": "839ddd87-3208-4afd-c662-04866b77dac9",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    }
   },
   "source": [
    "print(bound_id())  # called\n"
   ],
   "execution_count": 26,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "42\n"
     ],
     "name": "stdout"
    }
   ]
  }
 ]
}