{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 隐式转换系统\n",
    "Scala的隐式转换系统提供了一套定义良好的查找机制，让编译器能够调整代码。当用Scala写代码时可以故意漏掉一些信息，而让编译器去尝试在编译期自动推导出来。\n",
    "\n",
    "Scala编译器可以推导下面两种情况：\n",
    "- 缺少参数的方法调用或构造器调用\n",
    "- 缺少了从一个类型到另一个类型的转换，这也适用于需要转换才能进行的对象方法调用\n",
    "\n",
    "使用隐式转换能够减少代码，能够向已有类型中注入新的方法，也能够创建领域特定语言（DSL）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 隐式参数\n",
    "### 1.1 隐式参数的例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction \u001b[36mcalcTax\u001b[0m\n",
       "defined \u001b[32mobject \u001b[36mSimpleStateSalesTax\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mComplicatedSalesTaxData\u001b[0m\n",
       "defined \u001b[32mobject \u001b[36mComplicatedSalesTax\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// 需求场景：\n",
    "// 提供一个计算销售税的方法\n",
    "// 条件：\n",
    "// 1. 某些应用需要知道当前事务发生的具体地点，以便增收税\n",
    "// 2. 为了促进购物消费,某些地方可能将年假最后几天定位“免税期”\n",
    "\n",
    "def calcTax(amount: Float)(implicit rate: Float): Float = amount*rate\n",
    "\n",
    "object SimpleStateSalesTax {\n",
    "    implicit val rate: Float = 0.05F\n",
    "}\n",
    "\n",
    "case class ComplicatedSalesTaxData(\n",
    "    baseRate: Float,\n",
    "    isTaxHoliday: Boolean,\n",
    "    storeId: Int\n",
    ")\n",
    "\n",
    "object ComplicatedSalesTax {\n",
    "    private def extraTaxRateForStore(id: Int): Float = {\n",
    "        // 可以通过id推断商铺地点，再计算附加税\n",
    "        0.0F\n",
    "    }\n",
    "    \n",
    "    implicit def rate(implicit cstd: ComplicatedSalesTaxData): Float =\n",
    "        if (cstd.isTaxHoliday) 0.0F\n",
    "        else cstd.baseRate + extraTaxRateForStore(cstd.storeId)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tax on 100.0 = 5.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[36mSimpleStateSalesTax.rate\u001b[0m\n",
       "\u001b[36mamount\u001b[0m: \u001b[32mFloat\u001b[0m = \u001b[32m100.0\u001b[0mF"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "{\n",
    "    import SimpleStateSalesTax.rate\n",
    "    \n",
    "    val amount = 100F\n",
    "    println(s\"Tax on $amount = ${calcTax(amount)}\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tax on 100.0 = 6.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[36mComplicatedSalesTax.rate\u001b[0m\n",
       "\u001b[36mmyStore\u001b[0m: \u001b[32mComplicatedSalesTaxData\u001b[0m = \u001b[33mComplicatedSalesTaxData\u001b[0m(\u001b[32m0.06\u001b[0mF, false, \u001b[32m1010\u001b[0m)\n",
       "\u001b[36mamount\u001b[0m: \u001b[32mFloat\u001b[0m = \u001b[32m100.0\u001b[0mF"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "{\n",
    "    import ComplicatedSalesTax.rate\n",
    "    implicit val myStore = ComplicatedSalesTaxData(0.06F, false, 1010)\n",
    "    \n",
    "    val amount = 100F\n",
    "    println(s\"Tax on $amount = ${calcTax(amount)}\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 1.2 implicitly方法\n",
    "使用Predef对象定义的implicitly方法与附加类别签名结合，可以使用一种便捷的方式定义一个**接受参数化类型隐式参数的函数**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[36mmath.Ordering\u001b[0m\n",
       "defined \u001b[32mclass \u001b[36mMyList\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import math.Ordering\n",
    "\n",
    "case class MyList[A](list: List[A]) {\n",
    "    def sortBy1[B](f: A => B)(implicit ord: Ordering[B]): List[A] = \n",
    "        list.sortBy(f)(ord)\n",
    "    \n",
    "    def sortBy2[B: Ordering](f: A => B): List[A] =\n",
    "        list.sortBy(f)(implicitly[Ordering[B]])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mlist\u001b[0m: \u001b[32mMyList\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mMyList\u001b[0m(\u001b[33mList\u001b[0m(\u001b[32m1\u001b[0m, \u001b[32m3\u001b[0m, \u001b[32m5\u001b[0m, \u001b[32m2\u001b[0m, \u001b[32m4\u001b[0m))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val list = MyList(List(1, 3, 5, 2, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mres5\u001b[0m: \u001b[32mList\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mList\u001b[0m(\u001b[32m5\u001b[0m, \u001b[32m4\u001b[0m, \u001b[32m3\u001b[0m, \u001b[32m2\u001b[0m, \u001b[32m1\u001b[0m)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "list sortBy1 (i => -i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mres6\u001b[0m: \u001b[32mList\u001b[0m[\u001b[32mInt\u001b[0m] = \u001b[33mList\u001b[0m(\u001b[32m5\u001b[0m, \u001b[32m4\u001b[0m, \u001b[32m3\u001b[0m, \u001b[32m2\u001b[0m, \u001b[32m1\u001b[0m)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "list sortBy2 (i => -i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MyList类提供了两种sorBy方法：\n",
    "- 第一种使用常规方法，该方法接受一个类型为Ordering[B]的隐式值作为输入，**在当前作用域中一定存在某个Ordering[B]的对象实例，该实例清楚地知道对B类型对象如何进行排序。**所以，这个例子中，上下文限定了B对实例排序的能力。\n",
    "- 第二种方法提供了简化版的语法，类型参数`B: Ordering`被上下文定界（context bound），它安置隐式参数列表将接受Ordering[B]实例。\n",
    "\n",
    "implicitly方法会对传给函数的所有标记为隐式参数的实例进行解析。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 1.3 绕开类型擦除带来的限制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "``` scala\n",
    "object M {\n",
    "    def m(seq: Seq[Int]): Unit = println(s\"Seq[Int]: $seq\")\n",
    "    \n",
    "    def m(seq: Seq[String]): Unit = println(s\"Seq[String]: $seq\")\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将会出现这样的报错：\n",
    "```\n",
    "Compilation Failed\n",
    "Main.scala:50: double definition:\n",
    "def m(seq: Seq[Int]): Unit at line 49 and\n",
    "def m(seq: Seq[String]): Unit at line 50\n",
    "have same type after erasure: (seq: Seq)Unit\n",
    "    def m(seq: Seq[String]): Unit = println(s\"Seq[String]: $seq\")\n",
    "        ^\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为上面的两个m方法的字节码是一样的，编译器不允许同时出现这些方法定义。\n",
    "\n",
    "不过我们可以添加隐式参数来消除这些方法的二义性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mobject \u001b[36mM\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "object M {\n",
    "    implicit object IntMarker\n",
    "    implicit object StringMarker\n",
    "    \n",
    "    def m(seq: Seq[Int])(implicit i: IntMarker.type): Unit = println(s\"Seq[Int]: $seq\")\n",
    "    def m(seq: Seq[String])(implicit s: StringMarker.type): Unit = println(s\"Seq[String]: $seq\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[36mM._\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import M._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seq[Int]: List(1, 2, 3)\r\n"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "m(List(1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seq[String]: List(one, two, three)\n"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "m(List(\"one\", \"two\", \"three\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mres11\u001b[0m: \u001b[32mIntMarker\u001b[0m.type = cmd7$$user$M$IntMarker$@39546a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "IntMarker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mres12\u001b[0m: \u001b[32mStringMarker\u001b[0m.type = cmd7$$user$M$StringMarker$@a1f49b"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "StringMarker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了尽量避免使用Int和String这样常用类型作为隐式参数和对应值（这些类型还可能出现多处定义，而导致二义性和编译器抛出错误），比较安全的做法是专门设计特有的类型作为隐式参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 @implicitNotFound注解\n",
    "@implicitNotFound注解告诉编译器在不能构造出带有该注解的类型的参数时给出错误提示。这样做事给程序员有意义的错误提示。\n",
    "\n",
    "比如CanBuildFrom构造器和<:<类有相关注解：\n",
    "\n",
    "``` scala\n",
    "@implicitNotFound(msg = \"Cannot construct a collection of type ${To} with elements of type ${Elem} based on a collection of type ${From}.\")\n",
    "trait CanBuildFrom[-From, -Elem, +To] {...}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "``` scala\n",
    "@implicitNotFound(msg = \"Cannot prove that ${From} <:< ${To}.\")\n",
    "sealed abstract class <:<[-From, +To] extends (From => To) with Serializable\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2 隐式参数的规则\n",
    "- 只有最后一个参数列表允许出现隐式参数\n",
    "- implicit关键字必须出现在参数列表的最左边，而且只能出现一次\n",
    "- 假如参数列表以implicit关键字开头，那么所有的参数都是隐式的"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala 2.11",
   "language": "scala211",
   "name": "scala211"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "mimetype": "text/x-scala",
   "name": "scala211",
   "pygments_lexer": "scala",
   "version": "2.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}