1_intro_to_scala.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"top\"></a><img src=\"images/chisel_1024.png\" alt=\"Chisel logo\" style=\"width:480px;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 1: Scala简介\n",
    "**Next: [你的第一个 Chisel 模块](2.1_first_module.ipynb)**\n",
    "\n",
    "## 目标\n",
    "这些教程使用 *Jupyter* notebook 环境，让您可以对代码片段进行阅读，更改和运行。 我们鼓励您尝试使用教程代码块来加快您对 Chisel 掌握的速度。\n",
    "\n",
    "在第一个模块中，您将学习如何编写基础的Scala代码以及如何阅读更高级的Scala代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 了解 Scala\n",
    "Scala 是一种支持常见编程范式的语言。我们选择使用它有几个原因：\n",
    "\n",
    "- 它可以很好地作为DSL(Domain Specific Language)的宿主语言；\n",
    "- 它有强大而优雅的函数库，用于处理各种数据集合；\n",
    "- 它具有严格的类型系统，有助于在开发周期的早期（即编译时）捕获大部分错误；\n",
    "- 它具有强大的能力去表达和传递函数；\n",
    "- Chi*p*el, Chi*j*el, and Chi*c*el 不要Chisel那样顺利地发音。\n",
    "\n",
    "当我们稍后讨论Chisel时，所有这些要点都将变得容易理解，但是现在，我们将专注于阅读和编写 Scala 代码的基础知识。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 变量和常量 - var and val\n",
    "创建变量和常量值的语句前面分别带有关键字 *var* 和 *val*。通常的做法是尽可能使用 *val*。为什么？主要是为了减少因为重复使用变量而引入的错误同时使得代码更加容易阅读。Scala的语言设计使这种做法比您预期的更容易。\n",
    "\n",
    "<span style=\"color:blue\">**例子:**</span><br>\n",
    "后续代码块可以在直接此 notebook 中执行。请通过单击选择它。当单元格处于活动状态时，左侧会出现一个带有绿色条的框。选择后，可以使用 notebook 顶部的 **play** 按钮运行含有 *code block* 的单元格（下面以红色突出显示以供参考）。\n",
    "![](images/playbutton.png)\n",
    "\n",
    "或者，您可以使用键盘快捷键。 **Shift+enter** 来运行当前活动的单元格并将焦点移动到下一个单元格。 **Ctrl+enter** 运行当前单元格并使其保持焦点。\n",
    "\n",
    "关键示例以蓝色粗体<span style=\"color:blue\">**例子**</span>标出, 练习以红色粗体 <span style=\"color:red\">**练习**</span>. 第1单元完全由简短的示例组成，因此我们省略了该模块其余部分的示例声明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var numberOfKittens = 6\n",
    "val kittensPerHouse = 101\n",
    "val alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "var done = false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先要注意的是，与Java和C不同，Scala每行通常不需要分号结尾。当有换行符时，Scala 会推断分号。例如，当行末需要额外代码的操作符时，它通常可以判断单个语句是否分布在多行中。需要分号的唯一情况是您希望将多个语句放在一行上。\n",
    "You use variables in obvious ways. The two `var`s may be reassigned to, while the two `val`s are immutable once created.\n",
    "您以显示方式使用变量。上述两个 `var` 变量代表可以重新分配，而另外两个 `val` 表示该变量一旦创建就是不可变的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numberOfKittens += 1\n",
    "\n",
    "// kittensPerHouse = kittensPerHouse * 2 // 不会被编译 kittensPerHouse 不能被更新\n",
    "\n",
    "println(alphabet)\n",
    "done = true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 条件语句\n",
    "\n",
    "Scala 像其他编程语言一样拥有条件语句。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// 一个简单的条件语句例子; 另外，注释以 // 开头\n",
    "if (numberOfKittens > kittensPerHouse) { \n",
    "    println(\"太多 kittens 了！！！\") \n",
    "}\n",
    "// 当括号里只含有一行的时候，不需要括号。但是 Scala 样式指南仅在包含 “else” 子句时才更喜欢大括号。\n",
    "// (即使它可以编译也最好不要这样做)\n",
    "if (numberOfKittens > kittensPerHouse) \n",
    "    println(\"太多 kittens 了！！！\")\n",
    "\n",
    "// 当然也有 else 关键词\n",
    "// 在这儿你可以省略括号!\n",
    "if (done) \n",
    "    println(\"我们搞定了\")\n",
    "else \n",
    "    numberOfKittens += 1\n",
    "\n",
    "// 和 else if 语法\n",
    "// 为了良好的 Scala style，请保证每一个分支都有括号，因为不是每个分支都只有一行。 \n",
    "if (done) {\n",
    "    println(\"我们搞定了\")\n",
    "}\n",
    "else if (numberOfKittens < kittensPerHouse) {\n",
    "    println(\"更多的 Kitten！\")\n",
    "    numberOfKittens += 1\n",
    "}\n",
    "else {\n",
    "    done = true\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但在 Scala 中，“if” 条件会返回一个值。但这个值是多少了？其实它由所选分支的最后一行给出。它非常强大，特别是在用于初始化函数和类中的值时。它长得像这样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val likelyCharactersSet = if (alphabet.length == 26)\n",
    "    \"英语\"\n",
    "else \n",
    "    \"不是英语\"\n",
    "\n",
    "println(likelyCharactersSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们创建了一个在运行时其由 *alphabet* 的长度决定的 *possibleCharactersSet* 常量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 类的方法 (函数)\n",
    "\n",
    "类的方法使用关键词 `def` 进行定义。在此，我们将滥用一些记号用于函数名。函数的参数列表使用逗号作为分隔符，该列表指定了参数的名称，类型以及可选的默认值。为清楚起见，函数应指定返回类型。\n",
    "没有任何参数的 Scala 函数不需要空括号。在类的成员是一个函数的情况下，使得引用的到它的一些相关计算变得更加简单，这通常符合开发者们的喜好。按照惯例，没有副作用（即调用它们不会改变任何东西，它们只是返回一个值）的无参数函数将不使用括号，而是有副作用的函数（也许它们会改变类的变量或有输出相关信息）应该要求包含空括号。\n",
    "\n",
    "## 简单定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// 带一个输入参数的简单函数提供缩放功能, 例如： times2(3) 返回 6\n",
    "// 对于单行函数，大括号可以被省略\n",
    "def times2(x: Int): Int = 2 * x\n",
    "\n",
    "// 一个复杂一些的例子\n",
    "def distance(x: Int, y: Int, returnPositive: Boolean): Int = {\n",
    "    val xy = x * y\n",
    "    if (returnPositive) xy.abs else -xy.abs\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 函数重载\n",
    "一个函数名可以被多次使用，因为函数通过函数名加上参数列表才能确定一个函数签名，这允许编译器通过比对参数类型来确定应该调用哪个版本的函数。但是应当注意的是我们应该使用避免函数重载的功能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// 函数重载\n",
    "def times2(x: Int): Int = 2 * x\n",
    "def times2(x: String): Int = 2 * x.toInt\n",
    "\n",
    "times2(5)\n",
    "times2(\"7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 函数递归和嵌套\n",
    "大括号定义代码作用域。 在函数作用域内可能调用其他函数或递归本身。在某个作用域内定义的函数只能在该作用域内进行访问。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "/** 打印用 \"X\" 做的三角形\n",
    "  * 这是另一种注释格式\n",
    "  */\n",
    "def asciiTriangle(rows: Int) {\n",
    "    \n",
    "    //机智的做法: 一个 Int 乘以 \"X\" 产生包含 columns 个 \"X\" 的 String\n",
    "    def printRow(columns: Int): Unit = println(\"X\" * columns)\n",
    "    \n",
    "    if(rows > 0) {\n",
    "        printRow(rows)\n",
    "        asciiTriangle(rows - 1) // 这是一个递归函数\n",
    "    }\n",
    "}\n",
    "\n",
    "// printRow(1) // 这会导致编译错误，因为我们在定义 printRow 作用域之外调用它"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 列表(List)\n",
    "Scala 实现了各种聚合或有序对象。列表与数组非常相似，但支持更多的操作用于进行追加和提取。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val x = 7\n",
    "val y = 14\n",
    "val list1 = List(1, 2, 3)\n",
    "val list2 = x :: y :: y :: Nil       // 构建列表的另一种方法\n",
    "\n",
    "val list3 = list1 ++ list2           // 将第二个列表放在第一个列表的末尾\n",
    "val m = list2.length\n",
    "val s = list2.size\n",
    "\n",
    "val headOfList = list1.head          // 得到列表的第一个成员\n",
    "val restOfList = list1.tail          // 去掉列表的第一个成员得到后续成员\n",
    "\n",
    "val third = list1(2)                 // 得到列表的第三个成员（因为从0开始计数）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# `for` 语句\n",
    "\n",
    "Scala 有一个 `for` 语句，它的工作方式与传统语言类似。您可以用它迭代一系列值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (i <- 0 to 7) { print(i + \" \") }\n",
    "println()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 `until` 代替 `to` 来实现从 0 到 6 的迭代 (不包含 7)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (i <- 0 until 7) { print(i + \" \") }\n",
    "println()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "添加 `by` 设定特定步长。 下列函数将输出 0 到 10 的偶数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for(i <- 0 to 10 by 2) { print(i + \" \") }\n",
    "println()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就像在 Java 和 Python 中的 *iterator* 一样，你可以使用 `for` 去访问某种类型集合中的所有元素。在这里，我们列出 4 个随机整数，然后对它们求和。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val randomList = List(scala.util.Random.nextInt(), scala.util.Random.nextInt(), scala.util.Random.nextInt(), scala.util.Random.nextInt())\n",
    "var listSum = 0\n",
    "for (value <- randomList) {\n",
    "  listSum += value\n",
    "}\n",
    "println(\"sum is \" + listSum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "针对 Scala 的 `for` 有很多小技巧。它可以直观地完成传统的迭代需求，但是它也可能是（或者不是）最方便的使用方法。使用称为 *comprehensions* 的丰富函数系列，可以更容易地完成对数组元素求和之类的操作，这些函数可用于许多不同的元素集合。后面的部分将提供更多关于 `for` 及相关函数的信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 阅读 Scala\n",
    "能够阅读Scala代码并理解常见的命名约定，设计模式和最佳实践是成为高效的Chisel工程师的重要一步。代码重用的特性是Chisel的优势之一，但如果您无法阅读其他人的代码，则重用很困难。有效地解析其他人的代码也可以更容易地寻求帮助，尤其是来自StackOverflow等资源。\n",
    "\n",
    "以下部分显示了您将看到的常见代码模式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 模块及引入模块 \n",
    "\n",
    "```scala\n",
    "package mytools\n",
    "class Tool1 { ... }\n",
    "```\n",
    "\n",
    "当外部引用包含上述行的文件中定义的代码时，应使用：\n",
    " \n",
    "```scala\n",
    "import mytools.Tool1\n",
    "```\n",
    "\n",
    "注意：包名称 **应该** 与目录层次结构匹配。 这虽然不是强制性的，但如果不遵守本指南，可能会产生一些不寻常且难以诊断的问题。包名称是小写的，不包含下划线之类的分隔符，但这有时会使描述性名称变得困难。一种解决方案是添加一层层次结构，例如 `package good.tools`。 尽你所能。Chisel没有遵循这些规则而是用了一些包名的小技巧。\n",
    "\n",
    "As shown above, `import` statements inform the compiler that you are using some additional libraries.  Some common imports you will use when programming in Chisel are:\n",
    "如上所示， `import` 语句会通知编译器您正在使用一些其他库。在Chisel中编程时使用的一些常见库是：\n",
    "\n",
    "```scala\n",
    "import chisel3._\n",
    "import chisel3.iotesters.{ChiselFlatSpec, Driver, PeekPokeTester}\n",
    "```\n",
    "\n",
    "第一个导入 `chisel3` 包中的所有类和方法，这里的下划线用作通配符。第二个从 `chisel3.iotesters` 包中导入特定的类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Scala 作为面向对象语言\n",
    "Scala 是面向对象的，为了获得Scala和Chisel的最大优势了解这一点很重要。而且毫无疑问，不止一种方式来描述这一切。\n",
    "1. 变量是对象。\n",
    "1. 通过 `val` 申明的常量，在 Scala 内部也是对象。\n",
    "1. 即使是字面值也是对象。\n",
    "1. 甚至函数本身也是对象。 稍后会详细介绍。\n",
    "1. 对象是类的实例。\n",
    "  1. 事实上，在Scala中几乎所有方面中，*面向对象* 中的 *对象* 都将被称为实例。\n",
    "1. 在定义类时，程序员指定：\n",
    "  1. 使用 (`val`, `var`) 定义的数据与类关联。\n",
    "  1. 类的实例可以执行的操作，称为方法或函数。\n",
    "1. 类可以继承其他类。\n",
    "  1. 被基础的类是父类，继承的类是子类。\n",
    "  1. 在此情况下，子类可以继承父类中的数据和方法。\n",
    "  1. 有许多有用而且可控的途径使得类可以扩展或覆盖父类的属性。\n",
    "1. 类可以继承特征。可以将特征视为轻量级的类，允许从多个特征中继承特定的，有限的函数。  \n",
    "1. 单例对象是一个特殊的 Scala 的类。\n",
    "  1. 它们不是上面所描述的对象。请注意，我们把它们叫做实例。\n",
    "\n",
    "接下来我们看看如何创建一个 Scala 的类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 一个类的例子\n",
    "下面是一个简单的 Scala 类的例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// WrapCounter 根据位宽计算最大的值\n",
    "class WrapCounter(counterBits: Int) {\n",
    "\n",
    "  val max: Long = (1 << counterBits) - 1\n",
    "  var counter = 0L\n",
    "    \n",
    "  def inc(): Long = {\n",
    "    counter = counter + 1\n",
    "    if (counter > max) {\n",
    "        counter = 0\n",
    "    }\n",
    "    counter\n",
    "  }\n",
    "  println(s\"创建了位宽是 $max 的计数器\")\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对上述代码的分析:\n",
    "* ```class WrapCounter``` -- 这是对 **WrapCounter** 的定义.\n",
    "* ```(counterBits: Int)``` -- 创建 WrapCounter 需要一个 Int 参数, 这个参数的命名很不错，暗示了它是计数器的位宽。\n",
    "* 大括号用来 ({}) 分隔代码块。 大多数类使用代码块来定义变量，常量和方法（函数）。\n",
    "* `val max: Long =` -- 该类包含一个成员变量 **max**，声明为 `Long` 类型，并在创建该类时进行初始化。\n",
    "* `(1 << counterBits) - 1` computes the maximum value that can be contained in **counterBits** bits.  Since **max** was created with `val` it cannot be changed.\n",
    "* `(1 << counterBits) - 1` 计算可以包含在 **counterBits** 位中的最大值。 由于 **max** 是用 `val` 创建的，因此无法更改。\n",
    "* A variable **counter** is created and initialized to **0L**. The **L** says that 0 is a long value; thus, **counter** is inferred to be Long.\n",
    "* 创建变量 **counter** 并将其初始化为 **0L**。**L** 表示0是一个 `Long` 类型； 因此，**counter** 被 Scala 推断为 Long。\n",
    "\n",
    "* **max** and **counter** are commonly called _member variables_ of the class.\n",
    "* **max** and **counter** 通常称为该类的成员变量。\n",
    "* 定义了一个返回 **Long** 类型不带任何参数的类方法 **inc**。\n",
    "* **inc** 函数是一个代码块，包含：\n",
    "  * `counter = counter + 1` 对 **counter** 进行自增；\n",
    "  * `if (counter > max) { counter = 0 }` 确定 **counter** 是否大于 **max**，如果是的话将其赋值为 0。\n",
    "  * `counter` -- 代码块的最后一行十分重要。\n",
    "    * 表示为代码块最后一行的任何值均视为该代码块的返回值。返回值可以被调用语句使用或忽略。\n",
    "    * This applies quite generally; for example, since an `if` then `else` statement defines its true and false clauses with code blocks, it can return a value i.e., `val result = if (10 * 10 > 90) \"greater\" else \"lesser\"` would create a `val` with the value \"greater\".\n",
    "    * 这个做法很普遍。例如，由于 `if else`语句使用代码块定义了它的true和false子句，因此它可以返回一个值，即 `val result = if(10 * 10 > 90) \"greater\" else \"lesser\"`。 将创建一个值为 `greater`的变量。\n",
    "  * 因此，在这种情况下，函数 **inc** 返回 **counter** 的值\n",
    "  \n",
    "* `println(s\"创建了位宽是 $max 的计数器\")` 将字符串输出到标准输出。 因为 **println** 直接位于定义代码块中，所以它是类初始化代码的一部分并运行，即每次创建该类的实例时都会打印出字符串。\n",
    "\n",
    "* 在这种情况下打印的字符串是插值字符串.\n",
    "  * 第一个双引号前面的前缀 **s** 将其标识为插值字符串。\n",
    "  * 插值的字符串在运行时处理。  \n",
    "  * **\\$max** 将被替换为 max 的值.\n",
    "  * 如果 **\\$** 后跟一个代码块，则该代码块中可以包含任意Scala代码。\n",
    "    * 举个例子， **`println(s\"双倍的 max 是 ${max + max}\")`**.\n",
    "    * 该代码块的返回值将代替 `${...}`.\n",
    "    * 如果返回值不是字符串，则将其转换为字符串。实际上，Scala 中的每个类或类型都有对定义的字符串的隐式转换方法。\n",
    "  * 除非在调试的时候，您应避免在每次创建类实例时都打印某些内容，以免淹没标准输出。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 创建一个类的实例\n",
    "让我们使用上面的示例创建一个类。 Scala 的实例是通过内置的魔术关键字 `new` 创建的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val x = new WrapCounter(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may see instances being created without the keyword `new` i.e., `val y = WrapCounter(6)`.\n",
    "This occurs often enough to merit special attention, but requires the use of a companion object. It is described later.\n",
    "\n",
    "您可能会看到实例创建时没有关键字 `new` ，即 `val y = WrapCounter(6)`。\n",
    "这种情况经常发生，需要引起特别注意，但是需要使用伴随对象。稍后将详细描述。\n",
    "\n",
    "接下来给出了刚刚创建的实例的用法示例。（请尝试运行下面的单元格两次。）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.inc() // 对 counter 进行自增\n",
    "\n",
    "// 实例 x 的成员变量对外部是可见的，除非将其声明为 private\n",
    "if(x.counter == x.max) {              \n",
    "    println(\"counter is about to wrap\")\n",
    "}\n",
    "\n",
    "x inc() // Scala允许省略点，这对于使用 Embedded DSL 的人来说看起来更自然而且很有用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 代码块\n",
    "代码块由花括号分隔。一个块可以包含零个或更多行的 Scala 代码。 Scala 代码的最后一行成为代码块的返回值（可以忽略）。没有代码行的代码块将返回一个特殊的类似 `null` 的对象，称为 `Unit`。 代码块在整个 `Scala` 中普遍被使用：它可以类定义的主体，定义函数和方法，它也是 `if` 语句的子句，是 `for` 和其他许多 Scala 运算符的主体。\n",
    "\n",
    "## 参数化代码块\n",
    "代码块可以带有参数。对于类和方法定义，这些参数看起来像大多数常规编程语言中的参数。在下面的示例中， `c` 和 `s` 是代码块的参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// A one-line code block doesn't need to be enclosed in {}\n",
    "def add1(c: Int): Int = c + 1\n",
    "\n",
    "class RepeatString(s: String) {\n",
    "  val repeatedString = s + s\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**重要**: 还有另一种方式可以对代码块进行参数化。以下是一个例子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val intList = List(1, 2, 3)\n",
    "val stringList = intList.map { i =>\n",
    "  i.toString\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "该代码块被传递到 `List` 类的方法 `map` 中。 `map` 方法要求其代码块具有一个参数。`map` 将为列表中的每个成员调用该代码块，并且该代码块将转换为 `String` 的后返回。 Scala 几乎偏执地接受此类语法的变体。您可能会在多种不同的情况下看到此内容。这种类型的代码块称为匿名函数，后面的模块中提供了有关匿名函数的更多详细信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的目标是帮助您在遇到不同的表示方法时识别它们。当您使用 Scala 时，这些看起来会更加舒适和熟悉。不同作者倾向于使用特定的样式，并且在个别句法情况下，某种表示方法看起来更自然。One-liners倾向于使用更简洁的形式。复杂的块通常具有更直观的表达方式。为了简化协作，应该考虑浏览为了简化协作，应该考虑浏览 [Scala样式指南](http://docs.scala-lang.org/style/) ，参考其中的的最佳做法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 参数名和参数默认值\n",
    "考虑以下的方法定义\n",
    "```scala\n",
    "def myMethod(count: Int, wrap: Boolean, wrapValue: Int = 24): Unit = { ... }\n",
    "```\n",
    "调用该方法时，通常会看到参数名称以及传入的值。\n",
    "```scala\n",
    "myMethod(count = 10, wrap = false, wrapValue = 23)\n",
    "```\n",
    "使用参数名，甚至可以以不同的顺序调用该函数。\n",
    "```scala\n",
    "myMethod(wrapValue = 23, wrap = false, count = 10)\n",
    "```\n",
    "对于经常调用的方法，参数排序可能很明显。但是对于不太常用的方法，尤其是布尔参数，调用时包含参数名可以使您的代码更具可读性。如果方法的参数类型列表很长，则使用名称也可以减少出错的机会。定义类的参数也应使用此命名参数方案（它们实际上只是该类的构造方法的参数）。\n",
    "\n",
    "当某些参数具有默认值（不需要覆盖）时，调用方只需传递不使用默认值的特定参数。请注意，`wrapValue` 的默认值为24。因此，\n",
    "```scala\n",
    "myMethod(wrap = false, count = 10)\n",
    "```\n",
    "将像24已被传递一样工作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 你搞定了！\n",
    "\n",
    "[回到开头](#top)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala",
   "language": "scala",
   "name": "scala"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "mimetype": "text/x-scala",
   "name": "scala",
   "nbconvert_exporter": "script",
   "version": "2.12.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}