Closures-Decorators-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Closures and Decoratros in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reza Bagheri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scope of variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local variable x = 2\n",
      "Global variable y = 6\n",
      "Local variable z = 10\n",
      "Global variable  x = 1\n",
      "Global variable y = 6\n"
     ]
    }
   ],
   "source": [
    "x = 1 # x is a global variable  \n",
    "y = 5 # y is a global variable \n",
    "def f():\n",
    "    global y \n",
    "    x = 2   # x is a local variable\n",
    "    y += 1  # Reassigning the global variable y\n",
    "    z = 10   # z is a local variable\n",
    "    print(\"Local variable x =\", x)\n",
    "    print(\"Global variable y =\", y)\n",
    "    print(\"Local variable z =\", z)\n",
    "f()\n",
    "print(\"Global variable  x =\", x)\n",
    "print(\"Global variable y =\", y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a= [1, 2, 3, 4]\n",
      "b= 5\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = 5\n",
    "def func(x, y):\n",
    "    x.append(4)\n",
    "    y = y + 1\n",
    "\n",
    "func(a, b)\n",
    "print(\"a=\", a)  \n",
    "print(\"b=\", b)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local variable t = 10\n",
      "Nonlocal variable x = 5\n",
      "Local variable z = 20\n",
      "Nonlocal variable x = 5\n",
      "Nonlocal variable y = 6\n",
      "Local variable z = 10\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    y = 5\n",
    "    z = 10\n",
    "    t = 10\n",
    "    def g():\n",
    "        nonlocal y\n",
    "        y += 1\n",
    "        z = 20\n",
    "        print(\"Nonlocal variable x =\", x)\n",
    "        print(\"Local variable z =\", z) \n",
    "    print(\"Local variable t =\", t)    \n",
    "    g()\n",
    "    print(\"Nonlocal variable x =\", x)\n",
    "    print(\"Nonlocal variable y =\", y)\n",
    "    print(\"Local variable z =\", z)\n",
    "f(5)\n",
    "# This does not work:\n",
    "# g()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    x = 5\n",
    "    y = 10\n",
    "    return x\n",
    "h=f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def g(y):\n",
    "        return y\n",
    "    return g\n",
    "a = 5\n",
    "b = 1\n",
    "h=f(a)\n",
    "h(b)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    def g(y):\n",
    "        return y\n",
    "    return g(y)\n",
    "a = 5\n",
    "b = 1\n",
    "h=f(a) \n",
    "# This does not work:\n",
    "# h(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def g(y):\n",
    "        return y\n",
    "    return g\n",
    "a = 5\n",
    "b = 1\n",
    "f(a)(b)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def g(y):\n",
    "        def h(z):\n",
    "            return z\n",
    "        return h\n",
    "    return g\n",
    "a = 5\n",
    "b = 2\n",
    "c = 1\n",
    "f(a)(b)(c)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    z = 2\n",
    "    def g(y):\n",
    "        return z*x + y\n",
    "    return g\n",
    "a = 5\n",
    "b = 1\n",
    "h = f(a)\n",
    "h(b)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('x', 'z')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.__code__.co_freevars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5\n",
      "z = 2\n"
     ]
    }
   ],
   "source": [
    "print(h.__code__.co_freevars[0], \"=\", h.__closure__[0].cell_contents) \n",
    "print(h.__code__.co_freevars[1], \"=\", h.__closure__[1].cell_contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    z = 2\n",
    "    def g(y):\n",
    "        return y\n",
    "    return g\n",
    "a = 5\n",
    "b = 1\n",
    "h = f(a)\n",
    "h(b)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.__code__.co_freevars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('t',)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    z = 2\n",
    "    t = 3\n",
    "    def g(y):\n",
    "        nonlocal t\n",
    "        return y\n",
    "    return g\n",
    "a = 5\n",
    "b = 1\n",
    "h = f(a)\n",
    "h(b)  \n",
    "h.__code__.co_freevars  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def g(y = x):\n",
    "        return y\n",
    "    return g\n",
    "a = 5\n",
    "b = 1\n",
    "h = f(a)\n",
    "h()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def g(y):\n",
    "        def h(z):\n",
    "            return x * y * z\n",
    "        return h\n",
    "    return g\n",
    "a = 5\n",
    "b = 2\n",
    "c = 1\n",
    "f(a)(b)(c)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('x', 'y')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a)(b).__code__.co_freevars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('x',)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a).__code__.co_freevars  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def g(y):\n",
    "        def h(z):\n",
    "            return y * z\n",
    "        return h\n",
    "    return g\n",
    "a = 5\n",
    "b = 2\n",
    "c = 1\n",
    "f(a).__code__.co_freevars  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    z = 2\n",
    "    return lambda y: z*x+y\n",
    "a = 5\n",
    "b = 1\n",
    "f(a)(b)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "class NthRoot:\n",
    "    def __init__(self, n=2):\n",
    "        self.n = n\n",
    "    def set_root(n):\n",
    "        self.n = n\n",
    "    def calc(self, x):\n",
    "        return x ** (1/self.n)\n",
    "    \n",
    "thirdRoot = NthRoot(3)\n",
    "print(thirdRoot.calc(27))  \n",
    "def nth_root(n=2):\n",
    "    def calc(x):\n",
    "        return x ** (1/n)\n",
    "    return calc\n",
    "third_root = nth_root(3)\n",
    "print(third_root(27))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Composition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compose(g, f):\n",
    "    def h(*args, **kwargs):\n",
    "        return g(f(*args, **kwargs))\n",
    "    return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3048"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inch_to_foot= lambda x: x/12\n",
    "foot_meter= lambda x: x * 0.3048\n",
    "inch_to_meter = compose(foot_meter, inch_to_foot)\n",
    "inch_to_meter(12)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Partial application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def partial(f, *f_args, **f_keywords):\n",
    "    def g(*args, **keywords):\n",
    "        new_keywords = f_keywords.copy()\n",
    "        new_keywords.update(keywords)\n",
    "        return f(*(f_args + args), **new_keywords)\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func = lambda x,y,z: x**2 + 2*y + z\n",
    "pfunc = partial(func, 1)\n",
    "pfunc(2, 3)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Currying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def curry(f):\n",
    "    argc = f.__code__.co_argcount\n",
    "    f_args = []\n",
    "    f_kwargs = {}\n",
    "    def g(*args, **kwargs):\n",
    "        nonlocal f_args, f_kwargs\n",
    "        f_args += args\n",
    "        f_kwargs.update(kwargs)\n",
    "        if len(f_args)+len(f_kwargs) == argc:\n",
    "            return f(*f_args, **f_kwargs)\n",
    "        else:\n",
    "            return g          \n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.curry.<locals>.g(*args, **kwargs)>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cfunc = curry(func)\n",
    "cfunc(1)(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cfunc(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cfunc = curry(func)\n",
    "cfunc(1, 2)\n",
    "cfunc(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decoration and decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f is referring to  f definition\n",
      "g is referring to  g definition\n",
      "Swapping f and g\n",
      "f is referring to  g definition\n",
      "g is referring to  f definition\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    return(\"f definition\")\n",
    "def g():\n",
    "    return(\"g definition\")\n",
    "print(\"f is referring to \", f())\n",
    "print(\"g is referring to \", g())\n",
    "print(\"Swapping f and g\")\n",
    "temp = f\n",
    "f = g\n",
    "g = temp\n",
    "print(\"f is referring to \", f())\n",
    "print(\"g is referring to \", g())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco(f):\n",
    "    def g(*args, **kwargs):\n",
    "        return f(*args, **kwargs)\n",
    "    return g\n",
    "def func(x):\n",
    "     return 2*x\n",
    "func = deco(func)\n",
    "func(2)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling  func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco(f):\n",
    "    def g(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__)\n",
    "        return f(*args, **kwargs)\n",
    "    return g\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func = deco(func)\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 "
     ]
    }
   ],
   "source": [
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "for i in range(6):\n",
    "    print(fib(i), end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def memoize(f):\n",
    "    memo = {}\n",
    "    def memoized_func(n):\n",
    "        if n not in memo:            \n",
    "            memo[n] = f(n)\n",
    "        return memo[n]\n",
    "    return memoized_func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "832040"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib = memoize(fib)\n",
    "fib(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tracing recursive functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace(f):\n",
    "    level = 1\n",
    "    def helper(*arg):\n",
    "        nonlocal level\n",
    "        print((level-1)*\"  │\",  \"  ┌\",  f.__name__, \"(\", \",\".join(map(str, arg)), \")\", sep=\"\")\n",
    "        level += 1\n",
    "        result = f(*arg)\n",
    "        level -= 1\n",
    "        print((level-1)*\"  │\", \"  └\",  result, sep=\"\")\n",
    "        return result\n",
    "    return helper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ┌fib(4)\n",
      "  │  ┌fib(3)\n",
      "  │  │  ┌fib(2)\n",
      "  │  │  │  ┌fib(1)\n",
      "  │  │  │  └1\n",
      "  │  │  │  ┌fib(0)\n",
      "  │  │  │  └0\n",
      "  │  │  └1\n",
      "  │  │  ┌fib(1)\n",
      "  │  │  └1\n",
      "  │  └2\n",
      "  │  ┌fib(2)\n",
      "  │  │  ┌fib(1)\n",
      "  │  │  └1\n",
      "  │  │  ┌fib(0)\n",
      "  │  │  └0\n",
      "  │  └1\n",
      "  └3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "fib = trace(fib)\n",
    "fib(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntactic sugar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling  func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco(f):\n",
    "    def g(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__)\n",
    "        return f(*args, **kwargs)\n",
    "    return g\n",
    "@deco\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stacked decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling  g1 using deco2\n",
      "Calling  func using deco1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco1(f):\n",
    "    def g1(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__, \"using deco1\")\n",
    "        return f(*args, **kwargs)\n",
    "    return g1\n",
    "def deco2(f):\n",
    "    def g2(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__, \"using deco2\")\n",
    "        return f(*args, **kwargs)\n",
    "    return g2\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func = deco2(deco1(func))\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling  g1 using deco2\n",
      "Calling  func using deco1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco1(f):\n",
    "    def g1(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__, \"using deco1\")\n",
    "        return f(*args, **kwargs)\n",
    "    return g1\n",
    "def deco2(f):\n",
    "    def g2(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__, \"using deco2\")\n",
    "        return f(*args, **kwargs)\n",
    "    return g2\n",
    "@deco2\n",
    "@deco1\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling  g1 using deco2\n",
      "Calling  func using deco1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco1(f):\n",
    "    def g1(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__, \"using deco1\")\n",
    "        return f(*args, **kwargs)\n",
    "    return g1\n",
    "def deco2(f):\n",
    "    def g2(*args, **kwargs):\n",
    "        print(\"Calling \", f.__name__, \"using deco2\")\n",
    "        return f(*args, **kwargs)\n",
    "    return g2\n",
    "deco = compose(deco2, deco1) \n",
    "@deco\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tracing with memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ┌memoized_func(5)\n",
      "  │  ┌memoized_func(4)\n",
      "  │  │  ┌memoized_func(3)\n",
      "  │  │  │  ┌memoized_func(2)\n",
      "  │  │  │  │  ┌memoized_func(1)\n",
      "  │  │  │  │  └1\n",
      "  │  │  │  │  ┌memoized_func(0)\n",
      "  │  │  │  │  └0\n",
      "  │  │  │  └1\n",
      "  │  │  │  ┌memoized_func(1)\n",
      "  │  │  │  └1\n",
      "  │  │  └2\n",
      "  │  │  ┌memoized_func(2)\n",
      "  │  │  └1\n",
      "  │  └3\n",
      "  │  ┌memoized_func(3)\n",
      "  │  └2\n",
      "  └5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@trace\n",
    "@memoize\n",
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "fib(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ┌memoized_func(6)\n",
      "  │  ┌memoized_func(5)\n",
      "  │  └5\n",
      "  │  ┌memoized_func(4)\n",
      "  │  └3\n",
      "  └8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decorators with additional parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting func\n",
      "Finished func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco(msg_before, msg_after):\n",
    "    def original_deco(f):\n",
    "        def g(*args, **kwargs):\n",
    "            print(msg_before + \" \" + f.__name__)\n",
    "            result =  f(*args, **kwargs)\n",
    "            print(msg_after + \" \" + f.__name__)\n",
    "            return result\n",
    "        return g\n",
    "    return original_deco\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func = deco(\"Starting\", \"Finished\")(func)\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting func\n",
      "Finished func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco(msg_before, msg_after):\n",
    "    def original_deco(f):\n",
    "        def g(*args, **kwargs):\n",
    "            print(msg_before + \" \" + f.__name__)\n",
    "            result =  f(*args, **kwargs)\n",
    "            print(msg_after + \" \" + f.__name__)\n",
    "            return result\n",
    "        return g\n",
    "    return original_deco\n",
    "@deco(\"Starting\", \"Finished\")\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting func\n",
      "Finished func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deco(msg_before, msg_after, f):\n",
    "    def g(*args, **kwargs):\n",
    "        print(msg_before + \" \" + f.__name__)\n",
    "        result =  f(*args, **kwargs)\n",
    "        print(msg_after + \" \" + f.__name__)\n",
    "        return result\n",
    "    return g\n",
    "    \n",
    "def func(x):\n",
    "    return 2*x\n",
    "func = deco(\"Starting\", \"Finished\", func)\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This does not work:\n",
    "#@deco(\"Starting\", \"Finished\")\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting func\n",
      "Finished func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@curry\n",
    "def deco(msg_before, msg_after, f):\n",
    "    def g(*args, **kwargs):\n",
    "        print(msg_before + \" \" + f.__name__)\n",
    "        result =  f(*args, **kwargs)\n",
    "        print(msg_after + \" \" + f.__name__)\n",
    "        return result\n",
    "    return g\n",
    "    \n",
    "@deco(\"Starting\", \"Finished\")\n",
    "def func(x):\n",
    "    return 2*x\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wrapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wraps(f):\n",
    "    def decorator(g):\n",
    "        def helper(*args, **kwargs):\n",
    "            return g(*args, **kwargs)\n",
    "        attributes = ('__module__', '__name__', '__qualname__',\n",
    "                      '__doc__', '__annotations__')         \n",
    "        for attr in attributes:\n",
    "            try:\n",
    "                value = getattr(f, attr)\n",
    "            except AttributeError:\n",
    "                pass\n",
    "            else:\n",
    "                setattr(helper, attr, value)\n",
    "        return helper\n",
    "    return decorator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def memoize(f):\n",
    "    memo = {}\n",
    "    @wraps(f)\n",
    "    def memoized_func(n):\n",
    "        if n not in memo:            \n",
    "            memo[n] = f(n)\n",
    "        return memo[n]\n",
    "    return memoized_func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ┌fib(5)\n",
      "  │  ┌fib(4)\n",
      "  │  │  ┌fib(3)\n",
      "  │  │  │  ┌fib(2)\n",
      "  │  │  │  │  ┌fib(1)\n",
      "  │  │  │  │  └1\n",
      "  │  │  │  │  ┌fib(0)\n",
      "  │  │  │  │  └0\n",
      "  │  │  │  └1\n",
      "  │  │  │  ┌fib(1)\n",
      "  │  │  │  └1\n",
      "  │  │  └2\n",
      "  │  │  ┌fib(2)\n",
      "  │  │  └1\n",
      "  │  └3\n",
      "  │  ┌fib(3)\n",
      "  │  └2\n",
      "  └5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@trace\n",
    "@memoize\n",
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "fib(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ┌fib(6)\n",
      "  │  ┌fib(5)\n",
      "  │  └5\n",
      "  │  ┌fib(4)\n",
      "  │  └3\n",
      "  └8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}