advanced_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oTbLPvPBfW3s"
   },
   "source": [
    "# What even is a Notebook?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B7Qv1MYofva1"
   },
   "source": [
    "Answer: A combination of ipython REPL and Markdown!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "3zXVqGfQbwbr",
    "outputId": "35df3bb7-34e0-4a4a-e35e-e00270e222d8"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ycla4xesf4We"
   },
   "source": [
    "You can save data to a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nYJCP-ZbfV1n"
   },
   "outputs": [],
   "source": [
    "a = \"Hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Xecwq-t6f8P7"
   },
   "source": [
    "\"Cells\" can use data from previously executed cells!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ED-vcLGwfbPK",
    "outputId": "f07c90e3-bea3-44ba-a321-2946f4ab755c"
   },
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "b0B38fRWgDLN"
   },
   "source": [
    "Running a cell multiple times is the same as executing a block of code in a REPL multiple times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "CKHEsvd2fian",
    "outputId": "09e86de2-c4c8-4214-c215-c175200087b2"
   },
   "outputs": [],
   "source": [
    "a += \"?!\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jWnuz3ZVgJIf"
   },
   "source": [
    "Raw values at the end of a cell will print their REPL representation \"repr\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "LEQ0YiOIfoBj",
    "outputId": "43d92177-1d30-4979-a428-58d2ccc79221"
   },
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 130
    },
    "colab_type": "code",
    "id": "9-JiF03kfonL",
    "outputId": "8030e7b7-3d9a-498a-882c-d9d4d0cdb612"
   },
   "outputs": [],
   "source": [
    "even errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "c1GQlrRsgV0g"
   },
   "source": [
    "# What even is Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "J8y5tJ1cgne3",
    "outputId": "0db4498f-29c9-4a17-eec1-60dc75c4b78e"
   },
   "outputs": [],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "fArVXXCZgqTT",
    "outputId": "97438b1a-706c-4584-ed51-812b6f585cdf"
   },
   "outputs": [],
   "source": [
    "type(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "INSMbIofgrPK",
    "outputId": "86564275-0e95-4caf-a6be-8c26b2a5f3d6"
   },
   "outputs": [],
   "source": [
    "type(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "KUwWG2GqgvhG",
    "outputId": "092abf63-79d6-4176-cbaa-061252a0e5d6"
   },
   "outputs": [],
   "source": [
    "type(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "-HVvB3fRgwtW",
    "outputId": "bf4762a7-910f-4df9-d55d-306320c4ee87"
   },
   "outputs": [],
   "source": [
    "type([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "HxqyRoyqgx7X",
    "outputId": "d8555819-316a-4410-d9d1-80ad6668b273"
   },
   "outputs": [],
   "source": [
    "type(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Ro3h0C43g3lu",
    "outputId": "6c803361-6029-49a6-9f9f-8f2cfa78766d"
   },
   "outputs": [],
   "source": [
    "class Things: pass\n",
    "\n",
    "type(Things)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "aodpwuJIg7TU",
    "outputId": "9237677f-d5a5-49ce-83b7-a9b3cffaa1ab"
   },
   "outputs": [],
   "source": [
    "class Stuff(Things): pass\n",
    "\n",
    "type(Stuff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "AIbCzfl9g_Lh",
    "outputId": "6690e607-5910-47e7-8b89-22e52cd965e5"
   },
   "outputs": [],
   "source": [
    "class OtherStuff(list): pass\n",
    "\n",
    "type(OtherStuff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "6MI09h1ShEBh",
    "outputId": "93fe1020-32b6-4854-fd75-6508c016eb39"
   },
   "outputs": [],
   "source": [
    "def func(): pass\n",
    "\n",
    "type(func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "zk_Ttr4m5ueY",
    "outputId": "7be9164f-fbf6-4d28-c5b7-3b3956f17eb1"
   },
   "outputs": [],
   "source": [
    "type(type(func))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kzwOB8NF7mZ_"
   },
   "source": [
    "# A Class on Python Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "m5mLqf5s8oSh",
    "outputId": "c28ce60e-5fe0-4e54-f55a-8360b4fca2a5"
   },
   "outputs": [],
   "source": [
    "class Card:\n",
    "  \"Playing Cards!\"\n",
    "  def __init__(self, rank, suit):\n",
    "    self.rank = rank\n",
    "    self.suit = suit\n",
    "  \n",
    "  def __repr__(self):\n",
    "    return f\"{self.__class__.__name__}(rank='{self.rank}',suit='{self.suit}')\"\n",
    "\n",
    "card = Card(rank=\"3\", suit=\"♥\")\n",
    "card"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 493
    },
    "colab_type": "code",
    "id": "-1rad1tE9vIA",
    "outputId": "f0de133d-1fba-4aa9-b5ce-f9c41b2e8ac6"
   },
   "outputs": [],
   "source": [
    "dir(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "JAUnt6Lp-u6u",
    "outputId": "ce1528d3-9c61-40a0-fca9-ca537eba08b0"
   },
   "outputs": [],
   "source": [
    "card.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "FXwKo-1W-yDd",
    "outputId": "54f2d8e5-1774-41bd-dd3c-f46c943ad3ec"
   },
   "outputs": [],
   "source": [
    "card.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Hq3aNokQB5k-",
    "outputId": "555e2041-ae2b-4304-dd66-a80d54fb7227"
   },
   "outputs": [],
   "source": [
    "card.__hash__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1RzQeF0ZCaKU",
    "outputId": "cb9706c4-d46e-45d3-d6df-32427d1d19bd"
   },
   "outputs": [],
   "source": [
    "hash(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "jHbiKL7_Cddv",
    "outputId": "2993cad4-3ed8-440f-8f60-b9594e0a9128"
   },
   "outputs": [],
   "source": [
    "type(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "4XcknDTCCus-",
    "outputId": "56378fc9-fd3f-4e6f-f827-9e2cfe72186a"
   },
   "outputs": [],
   "source": [
    "type(Card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 198
    },
    "colab_type": "code",
    "id": "suKcPFXBCwOY",
    "outputId": "ca378b71-ef57-4a2f-cc19-9db482526ab1"
   },
   "outputs": [],
   "source": [
    "two_diamonds = Card(rank=\"2\", suit=\"♦\")\n",
    "three_hearts = Card(rank=\"3\", suit=\"♥\")\n",
    "two_diamonds > three_hearts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QvjSmB2JDBI1"
   },
   "outputs": [],
   "source": [
    "from functools import total_ordering\n",
    "\n",
    "@total_ordering\n",
    "class Card:\n",
    "  \"Playing Cards!\"\n",
    "  def __init__(self, rank, suit):\n",
    "    self.rank = rank\n",
    "    self.suit = suit\n",
    "  \n",
    "  @property\n",
    "  def _value(self):\n",
    "    return (self.rank, self.suit)\n",
    "\n",
    "  def __lt__(self, other):\n",
    "    return self._value < other._value\n",
    "\n",
    "  def __eq__(self, other):\n",
    "    return self._value == other._value\n",
    "\n",
    "  def __repr__(self):\n",
    "    return f\"{self.__class__.__name__}(rank='{self.rank}',suit='{self.suit}')\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "NFo7L_11EB4i",
    "outputId": "6448648d-d569-4d2e-91df-5213762ca94b"
   },
   "outputs": [],
   "source": [
    "two_diamonds = Card(rank=\"2\", suit=\"♦\")\n",
    "three_hearts = Card(rank=\"3\", suit=\"♥\")\n",
    "three_hearts > two_diamonds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OEXz7IzyECqX"
   },
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "from random import shuffle\n",
    "\n",
    "class Deck:\n",
    "  ranks = \"A 2 3 4 5 6 7 8 9 10 J Q K\".split()\n",
    "  suits = \"♠ ♥ ♦ ♣\".split()\n",
    "  def __init__(self):\n",
    "    self.cards = [Card(rank=r, suit=s) for r, s in product(self.ranks, self.suits)]\n",
    "    self.shuffle()\n",
    "\n",
    "  def __getitem__(self, index):\n",
    "    return self.cards[index]\n",
    "\n",
    "  def __iter__(self):\n",
    "    return iter(self.cards)\n",
    "\n",
    "  def __len__(self):\n",
    "    return len(self.cards)\n",
    "\n",
    "  def shuffle(self):\n",
    "    shuffle(self.cards)\n",
    "\n",
    "  def draw(self):\n",
    "    return self.cards.pop()\n",
    "\n",
    "deck = Deck()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "erp0zubVEsAp",
    "outputId": "1552859e-55b1-4ee9-a849-50e93e8e2342"
   },
   "outputs": [],
   "source": [
    "len(deck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "q12Wu8NUGDW8",
    "outputId": "44741abf-1935-4897-8497-4f8ffb6e55ea"
   },
   "outputs": [],
   "source": [
    "deck[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "E0TMQXzlGEZJ",
    "outputId": "dc6035e3-e2ed-46e0-d340-8dcd1ce6eff3"
   },
   "outputs": [],
   "source": [
    "deck[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "bgZvqPggGLth",
    "outputId": "18c90e24-9573-4f52-e686-f6194f9552b1"
   },
   "outputs": [],
   "source": [
    "deck.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 884
    },
    "colab_type": "code",
    "id": "WjZy-981GvYw",
    "outputId": "525f2363-c43b-498b-aef5-e49520ec06d1"
   },
   "outputs": [],
   "source": [
    "for index, card in enumerate(deck):\n",
    "  print(index, card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vOmq2RSxKj3Z"
   },
   "outputs": [],
   "source": [
    "class Player:\n",
    "  def __init__(self, name, deck):\n",
    "    self.name = name\n",
    "    self.hand = []\n",
    "    self.deck = deck\n",
    "\n",
    "  def draw(self):\n",
    "    self.hand.append(self.deck.draw())\n",
    "\n",
    "  def __repr__(self):\n",
    "    return repr(self.hand)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hKLeRFQYG2jU"
   },
   "outputs": [],
   "source": [
    "class Game:\n",
    "  def __init__(self):\n",
    "    self.deck = Deck()\n",
    "    self.players = []\n",
    "\n",
    "  def new_player(self, name):\n",
    "    player = Player(name, self.deck)\n",
    "    self.players.append(player)\n",
    "    return player\n",
    "\n",
    "  def __enter__(self):\n",
    "    return self\n",
    "\n",
    "  def __exit__(self, *args):\n",
    "    print(f\"__exit__{args}\")\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Hb4YcJrzKGHb",
    "outputId": "73549bee-ba23-4beb-d68b-4475beab81fc"
   },
   "outputs": [],
   "source": [
    "with Game() as game:\n",
    "  tory = game.new_player(\"Tory\")\n",
    "  alex = game.new_player(\"Alex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 164
    },
    "colab_type": "code",
    "id": "XC4OOCCkKRRy",
    "outputId": "a2877c48-91d7-4906-8ee7-9dfb6d93956c"
   },
   "outputs": [],
   "source": [
    "tory.draw(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "-x9NQJ1_K1Pu",
    "outputId": "08ea3e97-55fc-418b-9185-6c1087d04d42"
   },
   "outputs": [],
   "source": [
    "with Game() as game:\n",
    "  tory = game.new_player(\"Tory\")\n",
    "  alex = game.new_player(\"Alex\")\n",
    "  tory.draw(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7WNYzE0_K786"
   },
   "outputs": [],
   "source": [
    "Cardz = type(\"Cardz\", (), {})\n",
    "\n",
    "Cardz.__doc__ = \"Playing Cardz!\"\n",
    "\n",
    "def init(self, rank, suit):\n",
    "  self.rank = rank\n",
    "  self.suit = suit\n",
    "\n",
    "Cardz.__init__ = init\n",
    "\n",
    "@property\n",
    "def _value(self):\n",
    "  return (self.rank, self.suit)\n",
    "\n",
    "Cardz._value = _value\n",
    "\n",
    "Cardz.__lt__ = lambda self, other: self._value < other._value\n",
    "Cardz.__eq__ = lambda self, other: self._value == other._value\n",
    "Cardz.__repr__ = lambda self: f\"{self.__class__.__name__}(rank='{self.rank}',suit='{self.suit}')\"\n",
    "\n",
    "Card = total_ordering(Cardz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass(frozen=True, order=True, eq=True)\n",
    "class Card:\n",
    "    rank: str\n",
    "    suit: str\n",
    "        \n",
    "card = Card(rank=\"3\", suit=\"♥\")\n",
    "card"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introspection into Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(Card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "\n",
    "inspect.getmembers(Card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inspect.getmembers(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fizzbuzz(n):\n",
    "    if n % 3 == 0 and n % 5 == 0:\n",
    "        return 'FizzBuzz'\n",
    "    elif n % 3 == 0:\n",
    "        return 'Fizz'\n",
    "    elif n % 5 == 0:\n",
    "        return 'Buzz'\n",
    "    else:\n",
    "        return str(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[fizzbuzz(i) for i in range(20)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(inspect.getsource(fizzbuzz))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inspect.signature(fizzbuzz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dis\n",
    "\n",
    "dis.dis(fizzbuzz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast\n",
    "\n",
    "source = inspect.getsource(fizzbuzz)\n",
    "astree = ast.parse(source)\n",
    "print(ast.dump(astree))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PbkqzcoNfjt0"
   },
   "source": [
    "# Asynchronous Programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 198
    },
    "colab_type": "code",
    "id": "bFLWJlqffndt",
    "outputId": "3a98cb4a-5c6c-4812-d96c-7b272eb52999"
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "async def hello(name, time):\n",
    "    await asyncio.sleep(time)\n",
    "    print(f\"Hello, {name}. I waited {time} second{'s' if time > 1 else ''} to pop up!\")\n",
    "    return name\n",
    "\n",
    "names = [\"Tory\", \"Alex\", \"Clyde\"]\n",
    "times = [1, 1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RK59xvnVgmGb"
   },
   "outputs": [],
   "source": [
    "for name, time in zip(names, times):\n",
    "    asyncio.create_task(hello(name, time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tasks = []\n",
    "for name, time in zip(names, times):\n",
    "    tasks.append(asyncio.create_task(hello(name, time)))\n",
    "\n",
    "await asyncio.gather(*tasks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def fib(n):\n",
    "    print(f\"Calculating fib({n})\")\n",
    "    await asyncio.sleep(0.5)\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    return await fib(n-1) + await fib(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "await asyncio.gather(fib(4), fib(5), fib(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "    \n",
    "async def syn(name):\n",
    "    await asyncio.sleep(randint(1, 2))\n",
    "    print(f\"SYN: {name}\")\n",
    "    \n",
    "async def ack(name):\n",
    "    await asyncio.sleep(randint(1, 2))\n",
    "    print(f\"ACK: {name}\")\n",
    "    \n",
    "async def synack(name):\n",
    "    await asyncio.sleep(randint(1, 2))\n",
    "    await syn(name)\n",
    "    await ack(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def connection(name):\n",
    "    print(f\"Starting connection: {name}\")\n",
    "    await syn(name)\n",
    "    await ack(name)\n",
    "    await synack(name)\n",
    "    print(f\"Completed connection: {name}\")\n",
    "    return name\n",
    "\n",
    "names = [\"ASDF\", \"SDFG\", \"DFGH\", \"FGHJ\"]\n",
    "connections = [connection(name) for name in names]\n",
    "\n",
    "await asyncio.gather(*connections)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Lv0Hl3hcOIYG"
   },
   "source": [
    "# Functional Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ef3H7jeiOWDs"
   },
   "source": [
    "- First Class Functions, functions are things\n",
    "- Higher-Order Functions, functions that take functions\n",
    "- Pure Functions, no side effects\n",
    "- Recusion, not loops\n",
    "- Lazy Evaluations, compute as needed\n",
    "- Immutable Data, Variables have Referential Transparency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Bg8SKDN1PGnR"
   },
   "source": [
    "## First Class Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "qW4qAOnpOKcQ",
    "outputId": "65a847ee-fd4f-461f-c44e-6f3a1cc6e42a"
   },
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "  return x + y\n",
    "\n",
    "type(add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l6sJj0EyPZf-"
   },
   "source": [
    "## Higher-Order Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = range(10)\n",
    "\n",
    "list(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square = lambda x: x ** 2\n",
    "list(map(square, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "anvnk4_EPP1V",
    "outputId": "d6e71b5e-1d10-41ae-c015-5143c7861e8d"
   },
   "outputs": [],
   "source": [
    "def printer(func):\n",
    "  def wrapper(*args, **kwargs):\n",
    "    name = func.__name__\n",
    "    result = func(*args, **kwargs)\n",
    "    print(f\"{name} was just called with {args} and {kwargs}: The result was {result}\")\n",
    "    return result\n",
    "  return wrapper\n",
    "\n",
    "_add = printer(add)\n",
    "\n",
    "_add(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "axKYm9QDQBxK",
    "outputId": "4590acaf-58ff-4d79-91f9-bfbf4d17da19"
   },
   "outputs": [],
   "source": [
    "@printer\n",
    "def mul(x, y):\n",
    "  return x * y\n",
    "\n",
    "mul(3, y=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "NN3rbJoHQUnN",
    "outputId": "27d4bdfd-a44a-472b-8e50-e44085267c5f"
   },
   "outputs": [],
   "source": [
    "double = lambda x: mul(x, y=2)\n",
    "\n",
    "double(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "Kc7j75D4QjVY",
    "outputId": "61f8680e-859b-46b3-969f-adfa9956d837"
   },
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "\n",
    "double = partial(mul, y=2)\n",
    "\n",
    "double(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hq9kLqCKRjvj"
   },
   "outputs": [],
   "source": [
    "import time                                                \n",
    "\n",
    "def timeit(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        name = func.__name__\n",
    "        start = time.time()\n",
    "        result = func(*args, **kwargs)\n",
    "        stop = time.time()\n",
    "        total = stop - start\n",
    "        print(f\"{name} took {total:.2f} seconds\")\n",
    "        return result\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lwcZfdfNTqz8"
   },
   "source": [
    "## Pure Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zCrfLhIATtei"
   },
   "outputs": [],
   "source": [
    "def get_hash(hasher, data):\n",
    "  return hasher(data)\n",
    "\n",
    "\n",
    "data = b\"this is a test this is a test this is a test this is a test this is a test this is a test this is a test\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 493
    },
    "colab_type": "code",
    "id": "lW9nYrp1U2ic",
    "outputId": "51306815-d30f-41b1-f1fb-556f70df29b1"
   },
   "outputs": [],
   "source": [
    "from hashlib import sha256\n",
    "\n",
    "for d in data:\n",
    "  print(get_hash(sha256, d).hexdigest())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 317
    },
    "colab_type": "code",
    "id": "4KHbqWo5U2x8",
    "outputId": "ddf2e592-f214-47f3-d3aa-d990e89f2faf"
   },
   "outputs": [],
   "source": [
    "from hashlib import pbkdf2_hmac\n",
    "\n",
    "for d in data:\n",
    "  print(get_hash(pbkdf2_hmac, d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 317
    },
    "colab_type": "code",
    "id": "odC7yHoLU2pS",
    "outputId": "42f07ba6-63e2-4526-d79c-920812562637"
   },
   "outputs": [],
   "source": [
    "from hashlib import pbkdf2_hmac\n",
    "from functools import partial\n",
    "\n",
    "hasher = partial(pbkdf2_hmac, hash_name='sha256', salt=b'YOLO', iterations=10000)\n",
    "\n",
    "for d in data:\n",
    "  print(get_hash(hasher, d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 493
    },
    "colab_type": "code",
    "id": "F8Hg9SheU2ZF",
    "outputId": "150172ca-f65c-407a-8227-8bc7eec7951f"
   },
   "outputs": [],
   "source": [
    "from hashlib import pbkdf2_hmac\n",
    "\n",
    "hasher = lambda d: pbkdf2_hmac(hash_name='sha256', password=d, salt=b'YOLO', iterations=1_000_000)\n",
    "\n",
    "for d in data:\n",
    "  timeit(get_hash)(hasher, d).hex()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zcMlqS_wWpHs"
   },
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "get_hash = lru_cache()(get_hash)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3TDEHfwyRFyo"
   },
   "source": [
    "## Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "teipg98yQmRS"
   },
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "  if n <= 1:\n",
    "    return n\n",
    "  return fib(n-1) + fib(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 545
    },
    "colab_type": "code",
    "id": "Yqc3G2_RRSfJ",
    "outputId": "87ba46ef-1b87-402d-f286-14e4433ab4b9"
   },
   "outputs": [],
   "source": [
    "for n in range(20, 40, 2):\n",
    "  print(f\"Calculating the {n}th fib number:\", timeit(fib)(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FjpVoB7qSK_R"
   },
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "fib = lru_cache()(fib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ABmBrAAEYIjX"
   },
   "source": [
    "## Lazy Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vltEvYjxTTkx"
   },
   "outputs": [],
   "source": [
    "items = range(100000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "wUVW6A8nYtsX",
    "outputId": "d453a78e-96a7-4621-c748-e845162e5c39"
   },
   "outputs": [],
   "source": [
    "len(items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "y7ok1l_oYuzT",
    "outputId": "478f0276-28d3-4174-be32-1c1b46824229"
   },
   "outputs": [],
   "source": [
    "@timeit\n",
    "def squares(items):\n",
    "    return [i ** 2 for i in items]\n",
    "\n",
    "result = squares(items)\n",
    "\n",
    "result.__sizeof__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result[40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 181
    },
    "colab_type": "code",
    "id": "GczxksX7Y1JJ",
    "outputId": "1b78cd44-d546-4a7b-8452-3e818acd7ad1"
   },
   "outputs": [],
   "source": [
    "@timeit\n",
    "def squares(items):\n",
    "    return (i ** 2 for i in items)\n",
    "\n",
    "result = squares(items)\n",
    "\n",
    "result.__sizeof__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result[40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "goCfKHC1Y2An",
    "outputId": "044cfecc-c54d-4017-8f4e-1e05ab180cb2"
   },
   "outputs": [],
   "source": [
    "from itertools import islice\n",
    "\n",
    "next(islice(result, 40, 41))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PAG0VR3oaulb"
   },
   "source": [
    "## Bonus Topic: Currying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ljKc2WGoZ40D"
   },
   "outputs": [],
   "source": [
    "add = lambda x: lambda y: x + y\n",
    "mul = lambda x: lambda y: x * y\n",
    "\n",
    "increment = add(1)\n",
    "decrement = add(-1)\n",
    "\n",
    "double = mul(2)\n",
    "triple = mul(3)\n",
    "\n",
    "identity = lambda x: x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rKyBSBYWbIS5"
   },
   "source": [
    "## Bonus Topic: Function Composition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1AYvtbHza3xu",
    "outputId": "0f24b9ed-5180-4c7f-c0f2-a6389f3b85ba"
   },
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "\n",
    "compose = lambda f, g: lambda x: g(f(x))\n",
    "\n",
    "operations = [increment, double, decrement, triple]\n",
    "\n",
    "chain = reduce(compose, operations, identity)\n",
    "\n",
    "chain(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus Topic: Pipelining Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pipeline:\n",
    "    def __init__(self, generator):\n",
    "        self.generator = generator\n",
    "        \n",
    "    def map(self, function):\n",
    "        return Pipeline(map(function, self.generator))\n",
    "    \n",
    "    def filter(self, function):\n",
    "        return Pipeline(filter(function, self.generator))\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self.generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count, islice\n",
    "from functools import partial\n",
    "\n",
    "def printer(x, stage):\n",
    "    print(f\"{stage}: {x}\")\n",
    "    return x\n",
    "\n",
    "def is_prime(x):\n",
    "    if x < 2:\n",
    "        return False\n",
    "    for i in range(2, x):\n",
    "        if x % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "pipeline = (Pipeline(count())\n",
    "    .map(lambda x: x ** 2)\n",
    "    .map(lambda x: x - 1)\n",
    "    .filter(lambda x: x % 3 == 0)\n",
    "    .map(lambda x: x + 1)\n",
    "    .map(lambda x: x % 1000)\n",
    "    .filter(is_prime)\n",
    ")\n",
    "\n",
    "list(islice(pipeline, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Hardest Part of Functional Programming: Words\n",
    "\n",
    "## \"All told, a monad in X is just a monoid in the category of endofunctors of X, with product × replaced by composition of endofunctors and unit set by the identity endofunctor.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 1. The Functor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples stolen [from here](https://medium.com/@lettier/your-easy-guide-to-monads-applicatives-functors-862048d61610) and [from here](https://github.com/dbrattli/oslash/wiki/Functors,-Applicatives,-And-Monads-In-Pictures)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABCMeta, abstractmethod\n",
    "from functools import reduce\n",
    "from typing import Callable, Iterable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Functor is a representation of data.\n",
    "\n",
    "Laws:\n",
    "1. Mapping Identity should return the input\n",
    "2. Mapping over composed functions should return the same result as mapping over each function individually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Functor(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def map(self, func: Callable) -> \"Functor\":\n",
    "        raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Just(Functor):\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        \n",
    "    def __repr__(self):\n",
    "        name = self.__class__.__name__\n",
    "        value = self.value\n",
    "        return f\"{name}({value})\"\n",
    "    \n",
    "    def map(self, func):\n",
    "        cls = self.__class__\n",
    "        return cls(func(self.value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Just(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "increment = lambda x: x + 1\n",
    "\n",
    "Just(3).map(increment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Applicative(Functor):\n",
    "    @abstractmethod\n",
    "    def apply(self, lifted) -> Iterable:\n",
    "        raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Just(Applicative):\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        \n",
    "    def __repr__(self):\n",
    "        name = self.__class__.__name__\n",
    "        value = self.value\n",
    "        return f\"{name}({value})\"\n",
    "    \n",
    "    def map(self, func):\n",
    "        cls = self.__class__\n",
    "        return cls(func(self.value))\n",
    "    \n",
    "    def pure(self):\n",
    "        return self.value\n",
    "    \n",
    "    def apply(self, other):\n",
    "        cls = self.__class__\n",
    "        return cls(other.map(self.value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plus = lambda x: lambda y: x + y\n",
    "\n",
    "Just(3).map(plus).apply(Just(4)).pure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Monad(Applicative):\n",
    "    @abstractmethod\n",
    "    def bind(self, function):\n",
    "        raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Just(Monad):\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "    def __repr__(self):\n",
    "        name = self.__class__.__name__\n",
    "        value = self.value\n",
    "        return f\"{name}({value})\"        \n",
    "\n",
    "    def map(self, func):\n",
    "        cls = self.__class__\n",
    "        return cls(func(self.value))\n",
    "    \n",
    "    def pure(self):\n",
    "        return self.value\n",
    "    \n",
    "    def apply(self, other):\n",
    "        cls = self.__class__\n",
    "        return cls(other.map(self.value))\n",
    "    \n",
    "    def bind(self, func):\n",
    "        return func(self.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "endo_increment = lambda x: Just(x + 1)\n",
    "\n",
    "Just(3).bind(endo_increment).bind(endo_increment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Collection(Functor):\n",
    "    def __init__(self, value):\n",
    "        self.value = lambda: value\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return iter(self.value())\n",
    "    \n",
    "    def __repr__(self):\n",
    "        name = self.__class__.__name__\n",
    "        value = self.value()\n",
    "        return f\"{name}({value})\"\n",
    "        \n",
    "    def map(self, func):\n",
    "        cls = self.__class__\n",
    "        return cls([func(x) for x in self])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Collection([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "increment = lambda x: x + 1\n",
    "\n",
    "Collection([1, 2, 3]).map(increment).map(increment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Collection(Applicative):\n",
    "    def __init__(self, value):\n",
    "        self.value = lambda: value\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return iter(self.value())\n",
    "    \n",
    "    def __repr__(self):\n",
    "        name = self.__class__.__name__\n",
    "        value = self.value()\n",
    "        return f\"{name}({value})\"\n",
    "\n",
    "    def map(self, func):\n",
    "        cls = self.__class__\n",
    "        return cls([func(x) for x in self.value()])\n",
    "    \n",
    "    def pure(self):\n",
    "        return self.value()\n",
    "    \n",
    "    def apply(self, other):\n",
    "        cls = self.__class__\n",
    "        return cls([func(x) for func in self for x in other])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plus = lambda x: lambda y: x + y\n",
    "\n",
    "Collection([1, 2, 3]).map(plus).apply(Collection([10, 20]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Collection(Monad):\n",
    "    def __init__(self, value):\n",
    "        self.value = lambda: value\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return iter(self.value())\n",
    "    \n",
    "    def __repr__(self):\n",
    "        name = self.__class__.__name__\n",
    "        value = self.value()\n",
    "        return f\"{name}({value})\"\n",
    "\n",
    "    def map(self, func):\n",
    "        cls = self.__class__\n",
    "        return cls([func(x) for x in self.value()])\n",
    "    \n",
    "    def pure(self):\n",
    "        return self.value()\n",
    "    \n",
    "    def apply(self, other):\n",
    "        cls = self.__class__\n",
    "        return cls([func(x) for func in self for x in other])\n",
    "\n",
    "    def bind(self, func):\n",
    "        cls = self.__class__\n",
    "        reducer = lambda x, y: cls(x.pure() + y.pure())\n",
    "        return reduce(reducer, self.map(func), cls([]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "endo_increment = lambda x: Collection([x + 1])\n",
    "\n",
    "Collection([1, 2, 3]).bind(endo_increment).bind(endo_increment)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Untitled0.ipynb",
   "provenance": []
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}