MyThinkJulia-Ch18-Subtyping.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 18: Subtyping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will practice subtyping, operator overloading, and other topics from the previous chapter by developing parts of a program for playing card games."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cards\n",
    "\n",
    "Perhaps the most important objects we need to deal with in this program are cards.  So we need to first decide on a new type that can effectively represent these cards.\n",
    "\n",
    "There are fifty-two cards in a deck, each of which belongs to one of four suits and one of thirteen ranks. The suits are Spades ( ♠ ), Hearts ( ♥ ), Diamonds ( ♦ ), and Clubs ( ♣ ). The ranks are Ace (A), 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack (J), Queen (Q), and King (K). Depending on the game that you are playing, an Ace may be higher than King or lower than 2.\n",
    "\n",
    "If we want to define a new object to represent a playing card, it is obvious what the attributes should be: rank and suit. It is not as obvious what type the attributes should be. One possibility is to use strings containing words like \"Spade\" for suits and \"Queen\" for ranks. One problem with this implementation is that it would not be easy to compare cards to see which had a higher rank or suit.\n",
    "\n",
    "An alternative is to use integers to encode the ranks and suits. In this context, “encode” means that we are going to define a mapping between numbers and suits, or between numbers and ranks. This kind of encoding is not meant to be a secret (that would be “encryption”).\n",
    "\n",
    "For example, this table shows the suits and the corresponding integer codes:\n",
    "\n",
    "♠ $\\rightarrow$ 4\n",
    "\n",
    "♥ $\\rightarrow$ 3\n",
    "\n",
    "♦ $\\rightarrow$ 2\n",
    "\n",
    "♣ $\\rightarrow$ 1\n",
    "\n",
    "This code makes it easy to compare cards; because higher suits map to higher numbers, we can compare suits by comparing their codes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Card\n",
    "    \n",
    "    suit :: Int64\n",
    "    rank :: Int64\n",
    "    \n",
    "    function Card(suit::Int64, rank::Int64)\n",
    "        @assert(1 ≤ suit ≤ 4, \"suit is not between 1 and 4\")\n",
    "        @assert(1 ≤ rank ≤ 13, \"rank is not between 1 and 13\")\n",
    "        new(suit, rank)\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Global Variables\n",
    "\n",
    "In order to print Card objects in a way that people can easily read, we need a mapping from the integer codes to the corresponding ranks and suits. A natural way to do that is with arrays of strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13-element Array{String,1}:\n",
       " \"A\"\n",
       " \"2\"\n",
       " \"3\"\n",
       " \"4\"\n",
       " \"5\"\n",
       " \"6\"\n",
       " \"7\"\n",
       " \"8\"\n",
       " \"9\"\n",
       " \"10\"\n",
       " \"J\"\n",
       " \"Q\"\n",
       " \"K\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const suit_names = [\"♣\", \"♦\", \"♥\", \"♠\"]\n",
    "const rank_names = [\"A\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"J\", \"Q\", \"K\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variables suit_names and rank_names are global variables. The `const` declaration means that the variable can only\n",
    "be assigned once. This solves the performance problem of global variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can implement an appropriate show method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "function Base.show(io::IO, card::Card)\n",
    "    print(io, rank_names[card.rank], suit_names[card.suit])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "J♥"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Card(3, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing Cards\n",
    "\n",
    "For built-in types, there are relational operators ( < , > , == , etc.) that compare values and determine when one is greater than, less than, or equal to another. For programmer-defined types, we can override the behavior of the built-in operators by providing a method named: `<`.\n",
    "\n",
    "The correct ordering for cards is not obvious. For example, which is better, the 3 of Clubs or the 2 of Diamonds? One has a higher rank, but the other has a higher suit. In order to compare cards, you have to decide whether rank or suit is more\n",
    "important. \n",
    "\n",
    "The answer might depend on what game you are playing, but to keep things simple, we’ll make the arbitrary choice that the suit is more important, so all of the Spades outrank all of the Diamonds, and so on. With that decided, we can write `<`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "< (generic function with 76 methods)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base.<\n",
    "function <(c1::Card, c2::Card)\n",
    "    (c1.suit, c1.rank) < (c2.suit, c2.rank)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unit Testing\n",
    "\n",
    "Unit testing allows you to verify the correctness of your code by comparing the results of your code to what you expect. This can be useful to be sure that your code still is correct after modifications, and it is also a way to predefine the correct behaviour of your code during development. \n",
    "\n",
    "Simple unit testing can be performed with the @test macros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Test\n",
    "@test Card(1, 4) < Card(2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@test Card(1, 3) < Card(1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Abstract Types and Subtyping\n",
    "\n",
    "Before we define a type \"Card,\" we also need to think about how to handle two other critical objects: a deck and a hand.  A hand is a set of the cards held by one player. \n",
    "\n",
    "A hand is similar to a deck: both are made up of a collection of cards, and both require operations like adding and removing cards.\n",
    "\n",
    "A hand is also different from a deck; there are operations we want for hands that don’t make sense for a deck. For\n",
    "example, in poker we might compare two hands to see which one wins. In bridge, we might compute a score for a hand in\n",
    "order to make a bid.\n",
    "\n",
    "So we need a way to group these two related concrete types. In Julia this is done by defining an abstract type that serves as a parent for both `Deck` and `Hand`.  As you may recall, this is subtyping.\n",
    "\n",
    "Let’s call this abstract type `CardSet`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "abstract type CardSet end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several kinds of relationship between types:\n",
    "\n",
    "* Objects of a concrete type might contain references to objects of another type. For example, each `Rectangle` contains a reference to a `Point`, and each `Deck` contains references to an array of `Card`s. This kind of relationship is called HAS-A, as in, “a Rectangle has a Point”.\n",
    "\n",
    "* A concrete type can have an abstract type as a supertype. This relationship is called IS-A, as in, “a Hand is a kind of a CardSet.”\n",
    "\n",
    "* One type might depend on another in the sense that objects of one type take objects of the second type as parameters, or use objects of the second type as part of a computation. This kind of relationship is called a dependency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now define some methods that can be used for all subtypes of `CardSet`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "function Base.show(io::IO, cs::CardSet)\n",
    "    for card in cs.cards   # every subtypes of CardSet should have cards\n",
    "        print(io, card, \" \")   # we already defined how to show a card\n",
    "    end\n",
    "    println()\n",
    "end\n",
    "\n",
    "\n",
    "function Base.pop!(cs::CardSet)\n",
    "    pop!(cs.cards)\n",
    "end\n",
    "\n",
    "\n",
    "function Base.push!(cs::CardSet, card::Card)\n",
    "    push!(cs.cards, card)\n",
    "    nothing\n",
    "end\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods like `pop!` and `push!` for CardSet that use another method without doing much work is sometimes called a **veneer**. The metaphor comes from woodworking, where a veneer is a thin layer of good quality wood glued to the surface of a cheaper piece of wood to improve the appearance.\n",
    "\n",
    "In this case these methods merely express array operations in terms appropriate for cardsets.  It improves the appearance, or interface, of the implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Deck"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Deck <: CardSet\n",
    "    cards :: Array{Card, 1}\n",
    "end\n",
    "\n",
    "function Deck()  # an outer constructor with no argument\n",
    "    cards =[]\n",
    "    for suit in 1:4\n",
    "        for rank in 1:13\n",
    "            push!(cards, Card(suit, rank))  # generate a card instance\n",
    "        end\n",
    "    end\n",
    "    deck = Deck(cards)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deck1 = Deck();\n",
    "\n",
    "deck1 isa CardSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A♣ 2♣ 3♣ 4♣ 5♣ 6♣ 7♣ 8♣ 9♣ 10♣ J♣ Q♣ K♣ A♦ 2♦ 3♦ 4♦ 5♦ 6♦ 7♦ 8♦ 9♦ 10♦ J♦ Q♦ K♦ A♥ 2♥ 3♥ 4♥ 5♥ 6♥ 7♥ 8♥ 9♥ 10♥ J♥ Q♥ K♥ A♠ 2♠ 3♠ 4♠ 5♠ 6♠ 7♠ 8♠ 9♠ 10♠ J♠ Q♠ K♠ "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "deck1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hand"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Hand <: CardSet\n",
    "    cards :: Array{Card, 1}\n",
    "    label :: String\n",
    "end\n",
    "\n",
    "function Hand(label::String=\"\")     # an outer constructor.  \n",
    "    Hand(Card[], label)     # Note that the interface (just one argument) is different from that of the default constructors\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0-element Array{Card,1}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Array{Card,1}()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0-element Array{Card,1}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Card[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now define a method called `move!` to deal cards:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "move! (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function move!(cs1::CardSet, cs2::CardSet, n::Int)\n",
    "    @assert 1 ≤ n ≤ length(cs1.cards)\n",
    "    \n",
    "    for i in 1:n\n",
    "        card = pop!(cs1)\n",
    "        push!(cs2, card)\n",
    "    end\n",
    "    nothing\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "K♠ Q♠ "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "deck_m = Deck()\n",
    "hand_m = Hand(\"testing move!\")\n",
    "\n",
    "move!(deck_m, hand_m,2)\n",
    "hand_m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally, lets' define a couple of methods specific to Deck:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shuffle! (generic function with 1 method)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Random\n",
    "\n",
    "function shuffle!(deck::Deck)\n",
    "    Random.shuffle!(deck.cards)\n",
    "    deck\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "K♠ 4♠ 7♥ A♠ 3♠ 5♣ J♣ 4♦ 7♦ A♣ J♠ 9♦ Q♥ 2♣ K♦ 3♦ 5♦ A♦ 6♥ 4♥ 6♦ Q♦ 10♦ Q♠ 9♥ 3♣ 2♥ K♣ J♥ 3♥ 9♠ 2♠ 10♥ 2♦ 7♠ 7♣ 8♣ 6♠ 6♣ 8♥ K♥ 4♣ A♥ 8♠ 10♠ 5♠ J♦ 9♣ Q♣ 8♦ 5♥ 10♣ "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "shuffle!(deck1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 18-2\n",
    "\n",
    "Write a function named `sort!` that uses the function `sort!` to sort the cards in a Deck. `sort!` uses the `isless` method to determine the order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "function Base.sort!(deck::Deck)\n",
    "    sort!(deck.cards)\n",
    "    deck\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isless (generic function with 42 methods)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base.isless\n",
    "isless(c1::Card, c2::Card) = c1 < c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A♣ 2♣ 3♣ 4♣ 5♣ 6♣ 7♣ 8♣ 9♣ 10♣ J♣ Q♣ K♣ A♦ 2♦ 3♦ 4♦ 5♦ 6♦ 7♦ 8♦ 9♦ 10♦ J♦ Q♦ K♦ A♥ 2♥ 3♥ 4♥ 5♥ 6♥ 7♥ 8♥ 9♥ 10♥ J♥ Q♥ K♥ A♠ 2♠ 3♠ 4♠ 5♠ 6♠ 7♠ 8♠ 9♠ 10♠ J♠ Q♠ K♠ "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "sort!(deck1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging\n",
    "\n",
    "Subtyping can make debugging difficult because when you call a function with an object as argument, it might be hard to figure out which method will be invoked.\n",
    "\n",
    "Any time you are unsure about the flow of execution through your program, the simplest solution is to add print statements at the beginning of the relevant methods. If shuffle! prints a message that says something like Running shuffle! Deck , then as the program runs it traces the flow of execution. \n",
    "\n",
    "As better alternative, you can also use the @which macro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "K♠ Q♠ J♠ 10♠ 9♠ 8♠ 7♠ 6♠ 5♠ 4♠ "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "deckD = Deck()\n",
    "hand = Hand(\"try which\")\n",
    "move!(deckD, hand,10)\n",
    "hand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "function Base.sort!(hand::Hand)\n",
    "    sort!(hand.cards)\n",
    "    hand\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "sort!(hand::<b>Hand</b>) in Main at In[28]:2"
      ],
      "text/plain": [
       "sort!(hand::Hand) in Main at In[28]:2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which sort!(hand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Here’s a design suggestion:**\n",
    "\n",
    "When you override a method, the interface of the new method should be the same as the old. It should take the same parameters, return the same type, and obey the same preconditions and postconditions. If you follow this rule, you will find that any function designed to work with an instance of a supertype, like a `CardSet`, will also work with instances of its subtypes `Deck` and `Hand`. \n",
    "\n",
    "If you violate this rule, which is called the “Liskov substitution principle”, your code will collapse like (sorry) a house of\n",
    "cards."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 18-5\n",
    "\n",
    "Write a method called `deal!` that takes three parameters, a Deck, the number of hands and the number of cards per hand. It should create the appropriate number of Hand objects, deal the appropriate number of cards per hand, and return an array of Hands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deal! (generic function with 1 method)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function deal!(deck::Deck, n::Int64, m::Int64)\n",
    "    \n",
    "    @assert n*m < length(deck.cards)\n",
    "    \n",
    "    shuffle!(deck)\n",
    "    \n",
    "    hands_array = Hand[]\n",
    "    \n",
    "    for ind_hand = 1:n\n",
    "        \n",
    "        push!(hands_array, Hand(\"Hand-$(ind_hand)\"))\n",
    "        move!(deck, hands_array[ind_hand], m)\n",
    "        \n",
    "    end\n",
    "    \n",
    "    return hands_array\n",
    "    \n",
    "end\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Hand,1}:\n",
       " 2♣ 4♠ 9♦ 8♠ 6♥ A♣ 5♥  \n",
       " K♦ 4♣ 3♠ Q♣ 3♥ 10♣ 8♥ \n",
       " 9♥ 7♦ J♠ 9♣ 8♦ Q♦ A♠  \n",
       " 5♠ 7♠ K♠ 10♥ 3♦ K♥ 6♠ "
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "deck_deal1 = Deck()\n",
    "deal!(deck_deal1, 4, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 18-6\n",
    "\n",
    "The following are the possible hands in poker, in increasing order of value and decreasing order of probability:\n",
    "\n",
    "- pair: two cards with the same rank\n",
    "\n",
    "- two pair: two pairs of cards with the same rank\n",
    "\n",
    "- three of a kind: three cards with the same rank\n",
    "\n",
    "- straight: five cards with ranks in sequence (aces can be high or low, so Ace-2-3-4-5 is a straight and so is 10-Jack-Queen-King-Ace, but Queen-King-Ace-2-3 is not.)\n",
    "\n",
    "- flush: five cards with the same suit\n",
    "\n",
    "- full house: three cards with one rank, two cards with another\n",
    "\n",
    "- four of a kind: four cards with the same rank\n",
    "\n",
    "- straight flush: five cards in sequence (as defined above) and with the same suit\n",
    "\n",
    "The goal of this exercise is to estimate the probability of drawing these various hands.\n",
    "\n",
    "1. Add methods named `haspair`, `hastwopair`, etc. that return true or false according to whether or not the hand meets the relevant criteria. Your code should work correctly for “hands” that contain any number of cards (although 5 and 7 are the most common sizes).\n",
    "\n",
    "2. Write a method named `classify` that figures out the highest-value classification for a hand and sets the label field accordingly. For example, a 7-card hand might contain a flush and a pair; it should be labeled “flush”.\n",
    "\n",
    "3. When you are convinced that your classification methods are working, the next step is to estimate the probabilities of the various hands. Write a function that shuffles a deck of cards, divides it into hands, classifies the hands, and counts the number of times various classifications appear.\n",
    "\n",
    "4. Print a table of the classifications and their probabilities. Run your program with larger and larger numbers of hands until the output values converge to a reasonable degree of accuracy. Compare your results to the values at\n",
    "https://en.wikipedia.org/wiki/Hand_rankings.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TIP: First, make up test hands for each classification.\n",
    "\n",
    "Second, write a function `process_hands` to build a histogram (for the ranks of cards) with a hand as an argument.  Use this to classify pair, two pair, three of a kind, four of a kind and  full house.  Test these methods using the test hands.\n",
    "\n",
    "Third, write a function `hasflush` that first buils a histogram (for the suits of cards).\n",
    "\n",
    "Fourth, write a function `hasstraight` using ∈ to check all correct ranks are in an array of the ranks in the hand.  We cannot use typical card program algorithms/tricks because our hands can have any number of cards (not just 5 or 6).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4♦ 5♣ 6♣ 7♣ 8♣ 10♥ Q♠ "
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "pair_hand = Hand([Card(1,2), Card(2,2), Card(1,1), Card(3,3), Card(4,4), Card(2,8), Card(3,7)],\"pair\")\n",
    "twopair_hand = Hand([Card(1,2), Card(2,2), Card(3,1), Card(4,1), Card(3,4), Card(1,5), Card(4,7)],\"twopair\")\n",
    "threeofakind_hand = Hand([Card(1,2), Card(2,2), Card(3,2), Card(4,1), Card(3,4), Card(1,5), Card(4,7)],\"threeofakind\")\n",
    "fourofakind_hand = Hand([Card(1,2), Card(2,2), Card(3,2), Card(4,2), Card(3,4), Card(1,5), Card(4,7)],\"fourofakind\")\n",
    "fullhouse_hand = Hand([Card(1,2), Card(2,2), Card(3,2), Card(4,3), Card(3,3), Card(1,5), Card(4,7)],\"fullhouse\")\n",
    "\n",
    "flush_hand = Hand([Card(1,2), Card(1,3), Card(1,4), Card(1,5), Card(1,10), Card(2,11), Card(4,7)],\"flush\")\n",
    "\n",
    "#Ace-2-3-4-5: straight\n",
    "#10-Jack-Queen-King-Ace: stright\n",
    "#Queen-King-Ace-2-3: NO straight\n",
    "\n",
    "straight_hand1 = Hand([Card(1,4), Card(2,5), Card(3,6), Card(4,7), Card(1,8), Card(1,1), Card(4,10)],\"straight\")\n",
    "straight_hand2 = Hand([Card(1,1), Card(2,2), Card(3,3), Card(4,4), Card(1,5), Card(1,10), Card(4,7)],\"straight\")\n",
    "straight_hand3 = Hand([Card(1,10), Card(2,11), Card(3,12), Card(4,13), Card(2,1), Card(3,9), Card(4,7)],\"straight\")\n",
    "straight_hand4 = Hand([Card(1,12), Card(2,13), Card(3,1), Card(4,2), Card(2,3), Card(3,10), Card(4,7)],\"nostraight\")\n",
    "straight_hand5 = Hand([Card(1,4), Card(2,5), Card(3,6), Card(4,8), Card(2,9), Card(3,10), Card(4,12)],\"nostraight\")\n",
    "\n",
    "straightflush_hand1 = Hand([Card(1,4), Card(1,5), Card(1,6), Card(1,7), Card(1,8), Card(2,1), Card(4,10)],\"straightflush\")\n",
    "straightflush_hand2 = Hand([Card(1,2), Card(1,3), Card(1,5), Card(2,7), Card(1,4), Card(1,6), Card(4,10)],\"straightflush\")\n",
    "straightflush_hand3 = Hand([Card(3,10), Card(3,11), Card(3,12), Card(3,13), Card(1,5), Card(3,1), Card(4,7)],\"straightflush\")\n",
    "straightflush_hand4 = Hand([Card(1,12), Card(2,13), Card(3,1), Card(3,2), Card(3,3), Card(3,4), Card(4,7)],\"straightflush\")\n",
    "straightflush_hand5 = Hand([Card(2,4), Card(1,5), Card(1,6), Card(1,7), Card(1,8), Card(3,10), Card(4,12)],\"straightbutnoflush\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16-element Array{Hand,1}:\n",
       " 2♣ 2♦ A♣ 3♥ 4♠ 8♦ 7♥  \n",
       " 2♣ 2♦ A♥ A♠ 4♥ 5♣ 7♠  \n",
       " 2♣ 2♦ 2♥ A♠ 4♥ 5♣ 7♠  \n",
       " 2♣ 2♦ 2♥ 2♠ 4♥ 5♣ 7♠  \n",
       " 2♣ 2♦ 2♥ 3♠ 3♥ 5♣ 7♠  \n",
       " 2♣ 3♣ 4♣ 5♣ 10♣ J♦ 7♠ \n",
       " 4♣ 5♦ 6♥ 7♠ 8♣ A♣ 10♠ \n",
       " A♣ 2♦ 3♥ 4♠ 5♣ 10♣ 7♠ \n",
       " 10♣ J♦ Q♥ K♠ A♦ 9♥ 7♠ \n",
       " Q♣ K♦ A♥ 2♠ 3♦ 10♥ 7♠ \n",
       " 4♣ 5♦ 6♥ 8♠ 9♦ 10♥ Q♠ \n",
       " 4♣ 5♣ 6♣ 7♣ 8♣ A♦ 10♠ \n",
       " 2♣ 3♣ 5♣ 7♦ 4♣ 6♣ 10♠ \n",
       " 10♥ J♥ Q♥ K♥ 5♣ A♥ 7♠ \n",
       " Q♣ K♦ A♥ 2♥ 3♥ 4♥ 7♠  \n",
       " 4♦ 5♣ 6♣ 7♣ 8♣ 10♥ Q♠ "
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "hands = [pair_hand, twopair_hand, threeofakind_hand, fourofakind_hand, fullhouse_hand, flush_hand,\n",
    "straight_hand1,straight_hand2,straight_hand3,straight_hand4,straight_hand5,\n",
    "straightflush_hand1,straightflush_hand2,straightflush_hand3,straightflush_hand4,straightflush_hand5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hasflush (generic function with 1 method)"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function process_hands(hand::Hand)\n",
    "    \n",
    "    dict = Dict()\n",
    "    for card in hand.cards\n",
    "        dict[card.rank] = get!(dict, card.rank, 0) + 1\n",
    "    end\n",
    "    \n",
    "    pairs = findall(isequal(2),dict)\n",
    "    trio = findall(isequal(3),dict)\n",
    "    quad = findall(isequal(4),dict)\n",
    "    \n",
    "    return pairs,trio,quad\n",
    "    \n",
    "end\n",
    "\n",
    "\n",
    "function haspair(hand::Hand)\n",
    "    \n",
    "    pairs,trio,quad = process_hands(hand)\n",
    "    \n",
    "    length(pairs) == 1 && length(trio) != 1\n",
    "        \n",
    "end \n",
    "\n",
    "function hastwopair(hand::Hand)\n",
    "    \n",
    "    pairs,trio,quad = process_hands(hand)\n",
    "    \n",
    "    length(pairs) == 2\n",
    "        \n",
    "end \n",
    "\n",
    "function hasthreeofakind(hand::Hand)\n",
    "    \n",
    "    pairs,trio,quad = process_hands(hand)\n",
    "    \n",
    "    length(trio) == 1 && length(pairs) != 1\n",
    "        \n",
    "end \n",
    "\n",
    "function hasfourofakind(hand::Hand)\n",
    "    \n",
    "    pairs,trio,quad = process_hands(hand)\n",
    "    \n",
    "    length(quad) == 1\n",
    "        \n",
    "end \n",
    "\n",
    "function hasfullhouse(hand::Hand)\n",
    "    \n",
    "    pairs,trio,quad = process_hands(hand)\n",
    "    \n",
    "    length(trio) == 1 && length(pairs) == 1\n",
    "        \n",
    "end \n",
    "\n",
    "function hasflush(hand::Hand)\n",
    "    \n",
    "    dict = Dict()\n",
    "    for card in hand.cards\n",
    "        dict[card.suit] = get!(dict, card.suit, 0) + 1\n",
    "    end\n",
    "    \n",
    "     length(findall(isequal(5),dict)) >= 1\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hasstraight (generic function with 1 method)"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function hasstraight(hand::Hand)\n",
    "    \n",
    "    s = []\n",
    "    for card in hand.cards\n",
    "        push!(s,card.rank)\n",
    "    end\n",
    "    \n",
    "    if 1 ∈ s && 10 ∈ s && 11 ∈ s && 12 ∈ s && 13 ∈ s\n",
    "        return true\n",
    "    end\n",
    "        \n",
    "    \n",
    "    for i = 1:length(s)\n",
    "                \n",
    "        if s[i] + 1 ∈ s && s[i] + 2 ∈ s && s[i] + 3 ∈ s && s[i] + 4 ∈ s\n",
    "            return true\n",
    "        end\n",
    "        \n",
    "    end\n",
    "            \n",
    "    \n",
    "    return false\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hasstraightflush (generic function with 1 method)"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function hasstraightflush(hand::Hand)\n",
    "    \n",
    "    dict = Dict()\n",
    "    for card in hand.cards\n",
    "        dict[card.suit] = get!(dict, card.suit, 0) + 1\n",
    "    end\n",
    "    \n",
    "    flushsuits = findall(isequal(5),dict)\n",
    "\n",
    "    for flushsuit in flushsuits\n",
    "        flush_cards = filter(p->p.suit == flushsuit, hand.cards)\n",
    "        if hasstraight(Hand(flush_cards,\"test\"))\n",
    "            return true\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return false\n",
    "    \n",
    "end\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(haspair(hand))  \")\n",
    "end\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  true  false  false  false  false  false  false  false  false  false  false  false  false  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hastwopair(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  false  true  false  false  false  false  false  false  false  false  false  false  false  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hasthreeofakind(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  false  false  true  false  false  false  false  false  false  false  false  false  false  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hasfourofakind(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  false  false  false  true  false  false  false  false  false  false  false  false  false  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hasfullhouse(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  false  false  false  false  true  false  false  false  false  false  true  true  true  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hasflush(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  false  false  false  false  false  true  true  true  false  false  true  true  true  false  true  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hasstraight(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false  false  false  false  false  false  false  false  false  false  false  true  true  true  false  false  "
     ]
    }
   ],
   "source": [
    "for hand in hands\n",
    "    print(\"$(hasstraightflush(hand))  \")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that shuffles a deck of cards, divides it into hands, classifies the hands, and counts the number of times various classifications appear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8-element Array{Float64,1}:\n",
       " 0.422799\n",
       " 0.047598\n",
       " 0.021319\n",
       " 0.000223\n",
       " 0.001468\n",
       " 0.00396 \n",
       " 0.001985\n",
       " 1.3e-5  "
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_array = Int.(zeros(8))  # pair, twopair, threeofakind, fourofakind, fullhouse, stright, flush, straightflush\n",
    "\n",
    "numberhands = 10\n",
    "numbertrials = 100000\n",
    "\n",
    "for trials = 1:numbertrials\n",
    "    \n",
    "    hands = deal!(Deck(), numberhands, 5)\n",
    "    for hand in hands\n",
    "        if haspair(hand)\n",
    "            count_array[1] += 1\n",
    "        end\n",
    "        if hastwopair(hand)\n",
    "            count_array[2] += 1\n",
    "        end\n",
    "        if hasthreeofakind(hand)\n",
    "            count_array[3] += 1\n",
    "        end\n",
    "        if hasfourofakind(hand)\n",
    "            count_array[4] += 1\n",
    "        end\n",
    "        if hasfullhouse(hand)\n",
    "            count_array[5] += 1\n",
    "        end\n",
    "        if hasstraight(hand) && ! hasstraightflush(hand)\n",
    "            count_array[6] += 1\n",
    "        end\n",
    "        if hasflush(hand) && ! hasstraightflush(hand)\n",
    "            count_array[7] += 1\n",
    "        end\n",
    "        if hasstraightflush(hand)\n",
    "            count_array[8] += 1\n",
    "        end\n",
    "    end\n",
    "        \n",
    "end\n",
    "\n",
    "probability = count_array ./(numberhands*numbertrials)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For 5 cards\n",
    "\n",
    "Hand\tProbability\tNumber of Hands\n",
    "\n",
    "Single Pair\t0.422569\t1098240\n",
    "\n",
    "Two Pair\t0.047539\t123552\n",
    "\n",
    "Triple\t0.0211285\t54912\n",
    "\n",
    "Four of a Kind\t0.000240096\t624\n",
    "\n",
    "Full House\t0.00144058\t3744\n",
    "\n",
    "Straight(excluding Straight Flush and Royal Flush)\t0.00392465\t10200\n",
    "\n",
    "Flush (but not a Straight)\t0.0019654\t5108\n",
    "\n",
    "Straight Flush (but not Royal)\t0.0000138517\t36\n",
    "\n",
    "<Royal Flush\t0.00000153908\t4>: not considered"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Encapsulation\n",
    "\n",
    "In our example on Markov analys, we used two variables— suffixes and prefix —that are read and written from several functions.\n",
    "\n",
    "If these variables are global, we can only run one analysis at a time. If we read two texts, their prefixes and suffixes would be added to the same data structures (which makes for some interesting generated text). \n",
    "\n",
    "To run multiple analyses, and keep them separate, we can encapsulate the state of each analysis in an object. Here’s what that looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Markov"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Markov\n",
    "    order :: Int64\n",
    "    suffixes :: Dict{Tuple{String,Vararg{String}}, Array{String, 1}}\n",
    "    prefix :: Array{String, 1}\n",
    "end\n",
    "\n",
    "function Markov(order::Int64=2)\n",
    "    new(order, Dict{Tuple{String,Vararg{String}}, Array{String, 1}}(), Array{String, 1}())\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we transform the functions into methods. For example, here’s processword :\n",
    "\n",
    "Transforming a program like this—changing the design without changing the behavior—is another example of refactoring\n",
    "(see Refactoring). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function processword(markov::Markov, word::String)\n",
    "    \n",
    "    if length(markov.prefix) < markov.order\n",
    "        push!(markov.prefix, word)\n",
    "        return\n",
    "    end\n",
    "    \n",
    "    get!(markov.suffixes, (markov.prefix...,), Array{String, 1}())\n",
    "    push!(markov.suffixes[(markov.prefix...,)], word)\n",
    "    popfirst!(markov.prefix)\n",
    "    push!(markov.prefix, word)\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example suggests a development plan for designing types:\n",
    "\n",
    "* Start by writing functions that read and write global variables (when necessary).\n",
    "\n",
    "* Once you get the program working, look for associations between global variables and the functions that use them.\n",
    "\n",
    "* Encapsulate related variables as fields of a struct.\n",
    "\n",
    "* Transform the associated functions into methods with as argument objects of the new type.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.0",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}