Real World Ocaml第六章（Variants）.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that variant tags must be capitalized:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "open Core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type basic_color =\n",
       "    Black\n",
       "  | Red\n",
       "  | Green\n",
       "  | Yellow\n",
       "  | Blue\n",
       "  | Magenta\n",
       "  | Cyan\n",
       "  | White\n"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type basic_color =\n",
    "   | Black | Red | Green | Yellow | Blue | Magenta | Cyan | White ;;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "- : basic_color = Cyan\n"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Cyan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "- : basic_color list = [Yellow; Blue; Cyan]\n"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[Yellow; Blue; Cyan]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "File \"[40]\", line 1, characters 25-133:\n",
      "Warning 8: this pattern-matching is not exhaustive.\n",
      "Here is an example of a case that is not matched:\n",
      "White\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "val basic_color_to_int : basic_color -> int = <fun>\n"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let basic_color_to_int = function\n",
    "  | Black -> 0 | Red     -> 1 | Green -> 2 | Yellow -> 3\n",
    "  | Blue  -> 4 | Magenta -> 5 | Cyan  -> 6 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val basic_color_to_int : basic_color -> int = <fun>\n"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let basic_color_to_int = function\n",
    "  | Black -> 0 | Red     -> 1 | Green -> 2 | Yellow -> 3\n",
    "  | Blue  -> 4 | Magenta -> 5 | Cyan  -> 6 | White  -> 7 ;;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val color_by_number : int -> string -> string = <fun>\n"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let color_by_number number text =\n",
    "    sprintf \"\\027[38;5;%dm%s\\027[0m\" number text;;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val blue : string = \"\\027[38;5;4mBlue\\027[0m\"\n"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let blue = color_by_number (basic_color_to_int Blue) \"Blue\";;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "- : unit = ()\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "printf \"Hello %s World!\\n\" blue;;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type weight = Regular | Bold\n"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type weight = Regular | Bold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type color =\n",
       "    Basic of basic_color * weight\n",
       "  | RGB of int * int * int\n",
       "  | Gray of int\n"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "  type color =\n",
    "  | Basic of basic_color * weight (* basic colors, regular and bold *)\n",
    "  | RGB   of int * int * int       (* 6x6x6 color cube *)\n",
    "  | Gray  of int                   (* 24 grayscale levels *)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll also represent this more complicated color space as a variant, but this time, the different tags will have arguments that describe the data available in each case. Note that variants can have multiple arguments, which are separated by *s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "- : color list = [RGB (250, 70, 70); Basic (Green, Regular)]\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " [RGB (250,70,70); Basic (Green, Regular)];;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type color =\n",
       "    Basic of basic_color\n",
       "  | Bold of basic_color\n",
       "  | RGB of int * int * int\n",
       "  | Gray of int\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type color = \n",
    "|Basic of basic_color\n",
    "|Bold of basic_color\n",
    "| RGB of int * int * int\n",
    "|Gray of int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "File \"[49]\", line 1, characters 20-138:\n",
      "Warning 8: this pattern-matching is not exhaustive.\n",
      "Here is an example of a case that is not matched:\n",
      "Bold _\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "val color_to_int : color -> int = <fun>\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let color_to_int  = function\n",
    "|Basic (basic_color) -> basic_color_to_int basic_color\n",
    "|RGB (r,g,b) -> 16 + b + g * 6 + r *36\n",
    "|Gray i->232+ i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们已经看到，类型错误指出了需要修正哪些方面来完成重构的代码。这非常有用，不过，要让它正确、可靠地发挥作用，需要采用一种合适的方式编写代码、尽可能的增加编译器百年关注你发现`bug`的机会。为了达到这个目的，有一个有用的经验：要避免模式匹配中的`catch-all`全包情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module Log_entry :\n",
       "  sig\n",
       "    type t = {\n",
       "      session_id : string;\n",
       "      time : Core.Time.t;\n",
       "      important : bool;\n",
       "      message : string;\n",
       "    }\n",
       "  end\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Log_entry = struct\n",
    "type t = \n",
    "{\n",
    "session_id: string;\n",
    "time: Time.t;\n",
    "important: bool;\n",
    "message: string;\n",
    "}\n",
    "end\n",
    ";;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module Log_entry :\n",
       "  sig\n",
       "    type t = {\n",
       "      session_id : string;\n",
       "      time : Core.Time.t;\n",
       "      important : bool;\n",
       "      message : string;\n",
       "    }\n",
       "  end\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "module Heartbeat :\n",
       "  sig\n",
       "    type t = {\n",
       "      session_id : string;\n",
       "      time : Core.Time.t;\n",
       "      user : string;\n",
       "      credentials : string;\n",
       "    }\n",
       "  end\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "module Logon :\n",
       "  sig\n",
       "    type t = {\n",
       "      session_id : string;\n",
       "      time : Core.Time.t;\n",
       "      user : string;\n",
       "      credentials : string;\n",
       "    }\n",
       "  end\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Log_entry = struct\n",
    "type t = \n",
    "{\n",
    "session_id: string;\n",
    "time: Time.t;\n",
    "important: bool;\n",
    "message: string;\n",
    "}\n",
    "end\n",
    "module Heartbeat = struct\n",
    "type t = \n",
    "{\n",
    "session_id: string;\n",
    "time: Time.t;\n",
    "user:string;\n",
    "credentials: string;\n",
    "}\n",
    "end\n",
    "\n",
    "module Logon = struct\n",
    "type t = {\n",
    "session_id: string;\n",
    "time: Time.t;\n",
    "user:string;\n",
    "credentials: string;\n",
    "}\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "client_message是一个`Logon`，或是一个`Log_entry`，如果我们像编写采用通用方式处理消息的代码，而不是特定于某一个固定消息类型，就需要使用类似`client_message`的类型作为洞中个不同消息的一个“总体”类型，然后可以匹配`client_message`来确定所处理的特定消息的类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type client_message =\n",
       "    Logon of Logon.t\n",
       "  | Heartbeat of Heartbeat.t\n",
       "  | Log_entry of Log_entry.t\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type client_message = | Logon of Logon.t\n",
    "|Heartbeat of Heartbeat.t\n",
    "|Log_entry of Log_entry.t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val messages_for_user :\n",
       "  string -> client_message Core.List.t -> client_message Core.List.t = <fun>\n"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let messages_for_user user messages = \n",
    "let (user_messages,_) = \n",
    "List.fold messages ~init:([], String.Set.empty)\n",
    "~f:(fun ((message, user_sessions) as acc) message ->\n",
    "match message with\n",
    "|Logon m ->\n",
    "if m.Logon.user = user then\n",
    "(message::messages, Set.add user_sessions m.Logon.session_id)\n",
    "else acc\n",
    "|Heartbeat _ | Log_entry _ ->\n",
    "let session_id = match message with\n",
    "| Logon m -> m.Logon.session_id\n",
    "|Heartbeat m -> m.Heartbeat.session_id\n",
    "|Log_entry m -> m.Log_entry.session_id\n",
    "in\n",
    "if Set.mem user_sessions session_id then\n",
    "(message::messages,user_sessions) else acc)\n",
    "in \n",
    "List.rev user_messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前面的代码中有一部分看起来很笨拙，即用来确定会话ID的逻辑。这个代码有些重复，它考虑了每一种可能的消息类型（包括`Logon`，而代码执行到这里实际上不可能有这种消息），并对每一种情况抽取会话ID。像着这样诸葛消息类型进行处理看起来没有必要。因为对于所有消息类型，会话ID的工作都是一样的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module Log_entry : sig type t = { important : bool; message : string; } end\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Log_entry = struct \n",
    "type t= {\n",
    "important: bool;\n",
    "message: string;\n",
    "}\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module Heartbeat : sig type t = { status_message : string; } end\n"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Heartbeat = struct\n",
    "type t = {status_message: string;}\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module Logon : sig type t = { user : string; credentials : string; } end\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Logon = struct\n",
    "type t = {user:string;\n",
    "credentials:string}\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type details =\n",
       "    Logon of Logon.t\n",
       "  | Heartbeat of Heartbeat.t\n",
       "  | Log_entry of Log_entry.t\n"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type details = \n",
    "|Logon of Logon.t\n",
    "|Heartbeat of Heartbeat.t\n",
    "|Log_entry of Log_entry.t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module Common : sig type t = { session_id : string; time : Core.Time.t; } end\n"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Common = struct\n",
    "type t = {session_id: string;\n",
    "time: Time.t}\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val messages_for_user :\n",
       "  string ->\n",
       "  (Common.t * details) Core.List.t -> (Common.t * details) Core.List.t =\n",
       "  <fun>\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let messages_for_user user messages = \n",
    "let(user_messages,_) = \n",
    "List.fold messages ~init:([], String.Set.empty)\n",
    "~f:(fun ((message, user_sessions) as acc) ((common,details) as message) ->\n",
    "let session_id = common.Common.session_id in\n",
    "match details with\n",
    "| Logon m -> if m.Logon.user = user then\n",
    "(message::messages, Set.add user_sessions session_id)\n",
    "else acc\n",
    "|Heartbeat _ | Log_entry _ ->\n",
    "if Set.mem user_sessions session_id then\n",
    "(message::messages,user_sessions)\n",
    "else acc\n",
    ")\n",
    "in List.rev user_messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type 'a expr =\n",
       "    Base of 'a\n",
       "  | Const of bool\n",
       "  | And of 'a expr list\n",
       "  | Or of 'a expr list\n",
       "  | Not of 'a expr\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type 'a expr = \n",
    "|Base of 'a\n",
    "|Const of bool\n",
    "|And of 'a expr list\n",
    "|Or of 'a expr list\n",
    "|Not of 'a expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type mail_field = To | From | CC | Date | Subject\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type mail_field = To | From | CC |Date |Subject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type mail_predicate = { field : mail_field; contains : string; }\n"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type mail_predicate = {field: mail_field; contains:string}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val test : mail_field -> string -> mail_predicate expr = <fun>\n"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let test field contains = Base {field; contains};;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "- : mail_predicate expr =\n",
       "And\n",
       " [Or\n",
       "   [Base {field = To; contains = \"doligez\"};\n",
       "    Base {field = CC; contains = \"doligez\"}]]\n"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "And [ Or [test To \"doligez\"; test CC \"doligez\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val eval : 'a expr -> ('a -> bool) -> bool = <fun>\n"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let rec eval expr base_eval = \n",
    "let eval' expr = eval expr base_eval in\n",
    "match expr with\n",
    "| Base base -> base_eval base\n",
    "| Const bool -> bool\n",
    "| And exprs -> List.for_all exprs ~f:eval'\n",
    "| Or exprs -> List.exists exprs ~f:eval'\n",
    "| Not expr -> not (eval' expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "OCaml 4.04.1",
   "language": "OCaml",
   "name": "ocaml-jupyter"
  },
  "language_info": {
   "codemirror_mode": "text/x-ocaml",
   "file_extension": ".ml",
   "mimetype": "text/x-ocaml",
   "name": "OCaml",
   "nbconverter_exporter": null,
   "pygments_lexer": "OCaml",
   "version": "4.04.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}