Learning Chisel and Scala

//example 1：single line

scala> val str = "hello world"
<console>：str: String = hello world

//example 2: multiline

scala> val str_m = """ hello
     | world """
<console>: str_m: String =
" hello
world "

//example 1: escaped characters

scala> val str = "hello \nworld"
<console>: str: String =
hello
world

//example 2: support math operators

scala> println("hello "*3)
<console>: hello hello hello

scala> val str = "aloha"
<console>: str: String = aloha

scala> str_e + " heja he" == "aloha heja he"
<console>: res0:Boolean = true

scala> val fval: Double = 3.1415926
<console>: fval: Double = 3.1415926
scala> "PI is: " + fval
<console>: res0: String = PI is: 3.1415926

//syntax: 类似于shell中的变量引用

s"characters + ${value/variable}" //s开头，${}引用变量，而且{}这里也是可选的


//example

scala> val item = "apple"
<console>: item: String = apple

scala> s"How do you like them ${item}s?"
<console>: res0: String = How do you like them apples?

scala> s"Fish n chips n vinegar, ${"pepper "*3}salt"
<console>: res1: String = Fish n chips n vinegar, pepper pepper pepper salt

//syntax: 类似于c语言中的printf函数

f"characters + ${value/variable}with format" //f开头，在引用变量上加格式控制


//example

scala> val item = "apple"
<console>: item: String = apple

scala> f"I wrote a new $item%.3s today"
<console>: res2: String = I wrote a new app today

scala> f"Enjoying this $item ${355/113.0}%.5f times today"
<console>: res3: String = Enjoying this apple 3.14159 times today

//example 1: 括号内的逗号表达式

scala> val lyric = ("country","road", "take me", 2, "home")
<console>: lyric：(Sring, String, String, Int, String) = (country, road, take me, 2, home)

//example 2: 使用操作符->构造二元组，是二元组

scala> val lyric = "country" -> 2
<console>: lyric: (String, Int) = (country, 2)  //如果连续多个就会生成嵌套Tuple


scala> val lyric = "country" -> "road" -> 2
<console>: lyric: ((String, String), Int) = ((country, road), 2) //如果这是你想要的，你也可以这么干

//example 3：直接使用TupleX[Y]

scala> val lyric = Tuple3("country", "road", 2)
<console>: lyric: (String, String, Int) = (country, road, 2)

//example

scala> val tval = 1 -> "0xff0000"
<console>: tval: (Int, String) = (1, 0xff0000)

scala> tval._1
<console>: res0: Int = 1

//example 1: 使用List直接创建对象

scala> val numbers = List(32, 95, 24, 21, 17)
<console>: numbers: List[Int] = List(32, 95, 24, 21, 17)

scala> val colors = List("red", "green", "blue")
<console>: colors: List[String] = List(red, green, blue)

scala> colors(0)
<console>: res0: String = red

//example 2: 使用双冒号::操作符创建对象

scala> val numbers = 1 :: 2 :: 3 :: Nil
<console>: numbers: List[Int] = List(1, 2, 3)

//example 1: 调用::方法

scala> val first = Nil.::(1) //元素1是新建List的head元素，Nil作为主调对象是新建List的tail元素

<console>: first: List[Int] = List(1)

scala> first.tail == Nil
<console>: res0: Boolean = true

//example 2: ::右关联性

scala> val second = 2 :: first  //左侧添加新元素，成为新的head元素

<console>: second: List[Int] = List(2, 1)

scala> second.tail == first
<console>: res1: Boolean = true

//example

scala> val l: List[Int] = List()
<console>: l: List[Int] = List()

scala> l == Nil  //空List就是以Nil结尾的列表

<console>: res0: Boolean = true

example

scala> val colors = List("red", "green", "blue")
<console>: colors: List[String] = List(red, green, blue)

scala> colors.head
<console>: res0: String = red

scala> colors.tail
<console>: res1: List[String] = List(green, blue)

//example 1: List[Tuple]

scala> val keyValues = List(('A', 65), ('B',66), ('C',67))
<console>: keyValues: List[(Char, Int)] = List((A,65), (B,66), (C,67))

//example 2: List[List]

scala> val oddsAndEvents = List(List(1, 3, 5), List(2, 4, 6))
<console>: oddsAndEvents: List[List[Int]] = List(List(1, 3, 5), List(2, 4, 6))

//example 1

scala> Set(2,3) ++ List(1,2)
<console>: res0: scala.collection.immutable.Set[Int] = Set(2, 3, 1)

//example 2

scala> List(1,2) ++ Set(" hello")  
<console>: res0: List[Any] = List(1, 2, hello) //因为类型不一致，直接推断出root类型


scala> val t = res0(2) //取出字符串

<console>: t: Any = " hello"  //变成了多态形式，即父类引用指向子类对象

scala> t match {
     | case x: String => s"is ${x}s"
     | case x: Any => s"is${x}A"
     | }
<console>: res1: String = is hellos   //说明Scala可以玩出很多可能性

//example 1: map

scala> val sizes = colors.map( (c: String) => c.size ) //将原来的String类型元素逐一替换为size方法输出的Int类型元素

<console>: sizes: List[Int] = List(3, 5, 4)

//example 2: select

scala> List(0, 1, 0) collect {case 1 => "ok"}
<console>: res0: List[String] = List(ok)

//example 3: flatMap

scala> List("milk,tea") flatMap (_.split(','))  //具有map函数映射功能，flat表示由函数字面量输出构成的List内部元素为非复合类型的单一列表

<console>: res1: List[String] = List(milk, tea)

//example 1：reduce

scala> val numbers = List(32, 95, 24, 21, 17)
<console>: numbers: List[Int] = List(32, 95, 24, 21, 17)

scala> val total = numbers.reduce( (a: Int, b: Int) => a + b ) //规约就是指按照传入的函数字面量的逻辑，生成唯一的一个输出，这里是求和

<console>: total: Int = 189

//example

scala> val colorMap = Map("red" -> 0xFF0000, "green" -> 0xFF00, "blue" -> 0xFF) //构造

<console>: colorMap: scala.collection.immutable.Map[String,Int] = Map(red -> 16711680, green -> 65280, blue -> 255)

scala> val redRGB = colorMap("red") //通过key访问value

<console>: redRGB: Int = 16711680

scala> val cyanRGB = colorMap("green") | colorMap("blue") //算术运算

<console>: cyanRGB: Int = 65535

scala> for (pairs <- colorMap) { println(pairs) } //应用于for循环

<console>: (red,16711680) (green,65280) (blue,255)

//example 1

scala> Map(1->"st", 2->"nd") ++ Map(3->"rd") //同类型++，输出依然是Map

<console>: res0: scala.collection.immutable.Map[Int,String] = Map(1 -> st, 2 -> nd, 3 -> rd)  

//example 2

scala> Map(1->"st", 2->"nd") ++ List((3，"rd")) //List类型内部元素为Tuple，输出也是Map

<console>: res1: scala.collection.immutable.Map[Int,String] = Map(1 -> st, 2 -> nd, 3 -> rd)  

//example 3
scala> Map(1->"st", 2->"nd") ++ List(3, "rd") //List内部元素不是Tuple了，输出变成了List，且原Map中的元素在List中变成了二元元组

<console>: res2: scala.collection.immutable.Iterable[Any] = List((1,st), (2,nd), 3, rd)  

//example

scala> val unique = Set(10, 20, 30, 20, 20, 10)
unique: scala.collection.immutable.Set[Int] = Set(10, 20, 30)

scala> unique(0)
<console>: res0: Boolean = false //0并未在集合中

scala> unique(10)
<console>: res1: Boolean = true

scala> val sum = unique.reduce( (a: Int, b: Int) => a + b )  //支持高阶函数

<console>: sum: Int = 60

scala> unique.foreach((i: Int) => println(i))  //使用高阶函数进行遍历

<console>:
10
20
30

//example 1: 元素匹配

scala> val statuses = List(500, 404)
<console>: statuses: List[Int] = List(500, 404)

scala> val msg = statuses.head match {  //使用List中的首元素进行匹配，无特别之处

     | case x if x < 500 => "okay"
     | case _ => "whoah, an error"
     | }
<console>: msg: String = whoah, an error

//example 2: 使用collection方法做模式匹配

scala> val msg = statuses match {
     | case x if x contains(500) => "has error" //在guard中使用contains方法
     
     | case _ => "okay"
     | }
<console>: msg: String = has error

//example 3: 匹配collection对象

scala> val msg = statuses match {
     | case List(404, 500) => "not found & error" //List作为匹配参数
     
     | case List(500, 404) => "error & not found"
     | case List(200, 200) => "okay"
     | case _ => "not sure what happened"
     | }
<console>: msg: String = error & not found

//example 4: 值绑定

scala> val msg = statuses match {
     | case List(500, x) => s"Error followed by $x" //x与404绑定
     
     | case List(e, x) => s"$e was followed by $x"
     | }
<console>: msg: String = Error followed by 404

//example 5: head + tail分裂匹配

scala> val head = List('r','g','b') match {
     | case x :: xs => x   //x与List('r','g','b') 的head绑定，xs与tail绑定
     
     | case Nil => ' '
     | }
<console>: head: Char = r

//exampe

scala> val code = ('h', 204, true) match {
     | case (_, _, false) => 501
     | case ('c', _, true) => 302
     | case ('h', x, true) => x
     | case (c, x, true) => {
     |   println(s"Did not expect code $c")
     |   x
     |  }
     | }
<console>: code: Int = 204

//example 1.1: 直接例化

scala> val nums = collection.mutable.Buffer(1) //创建包含一个元素的可变列表

<console>: nums: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1)

scala> for (i <- 2 to 10) nums += i //为可变列表添加元素

scala> println(nums)
<console>: Buffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

//example 1.2

scala> val nums = collection.mutable.Buffer[Int]() //构建空列表，由于不包含初始元素，无法进行类型推断，所以必须在创建的时候指明类型

<console>: nums: scala.collection.mutable.Buffer[Int] = ArrayBuffer()

scala> for (i <- 1 to 10) nums += i
scala> println(nums)
Buffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

//example 2: immutable与mutable相互转化, List, Set, Map都可以使用toBuffer转换为Buffer类型

scala> val conv = Map("a"->1,"b"->2).toBuffer  //Map转换为Buffer

<console>: conv: scala.collection.mutable.Buffer[(String, Int)] = ArrayBuffer((a,1), (b,2))  //Map内部元素为二元Tuple


//相互转化

scala> conv.toMap  
<console>: res0: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)

scala> conv.toList
<console>: res1: List[(String, Int)] = List((a,1), (b,2))

scala> conv.toSet
<console>: res2: scala.collection.immutable.Set[(String, Int)] = Set((a,1), (b,2))

//example 3：collection builder, 若创建mutable对象的目的是为了转化为immutable对象可以考虑该方法

scala> val nSet = Set.newBuilder[Char] //第一步：任意不可变类型使用newBuilder方法创建一个Builder(实际上builder是一个简化形式的Buffer)

<console>: nSet: scala.collection.mutable.Builder[Char,scala.collection.immutable.
Set[Char]] = scala.collection.mutable.SetBuilder@726dcf2c

scala> nSet += 'h'  //第二步：nSet此时是一个"可变类型对象"，所以可以添加元素

<console>: res0: nSet.type = scala.collection.mutable.SetBuilder@d13d812

scala> nSet ++= List('e', 'l', 'l', 'o')
<console>: res1: nSet.type = scala.collection.mutable.SetBuilder@d13d812

scala> val helloSet = nSet.result //第三步：调用result方法，转化为immutable

<console>: helloSet: scala.collection.immutable.Set[Char] = Set(h, e, l, o)

//example

scala> val colors = Array("red", "green", "blue")
<console>: colors: Array[String] = Array(red, green, blue)

scala> colors(0) = "purple"  //起始index为0

scala> colors  //调用默认的toString方法

<console>: res0: Array[String] = Array(purple, green, blue)

//example

scala> val links_1 = Seq('C','M','Y','K')
<console>: links_1: Seq[Char] = List(C, M, Y, K)

scala> val links_2 = IndexedSeq(1,2,3,43)
<console>: links_2: IndexedSeq[Int] = Vector(1, 2, 3, 43) //Vector类似于C++中的vector，是一个动态数组


scala> links_2(3)  //数组index起始值为0

<console>: Int = 43

//example 1: 调用Stream.cons创建无界Streams

scala> def inc(i: Int): Stream[Int] = Stream.cons(i, inc(i+1)) //通过Stream.cons创建Stream，第一个参数是生成元素值，第二个是生成器

<console>: inc: (i: Int)Stream[Int]

scala> val s = inc(1) //指明尺寸为1

<console>: s: Stream[Int] = Stream(1, ?) //？表示可以"无穷"生成元素


scala> val l = s.take(5).toList  //调用Stream的take方法生成指定尺寸stream，这里的1已经生成，2~5在本次访问时产生

<console>: l: List[Int] = List(1, 2, 3, 4, 5)

scala> s
<console>: res1: Stream[Int] = Stream(1, 2, 3, 4, 5, ?)

//example 2: 使用#::操作符创建Streams，右关联

scala> def inc(head: Int): Stream[Int] = head #:: inc(head+1)
<console>: inc: (head: Int)Stream[Int]

scala> inc(10).take(10).toList
<console>: res0: List[Int] = List(10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

//example 3: 使用Stream.empty创建有界Streams

scala> def to(head: Char, end: Char): Stream[Char] = (head > end) match { //加了结尾参数进行限定

     | case true => Stream.empty
     | case false => head #:: to((head+1).toChar, end)
     | }
<console>: to: (head: Char, end: Char)Stream[Char]

scala> val hexChars = to('A', 'F').take(20).toList
<console>: hexChars: List[Char] = List(A, B, C, D, E, F)

//example 1

scala> var x: String = "Indeed"
<console>: x: String = Indeed

scala> var a = Option(x) //判断x是否为空

<console>: a: Option[String] = Some(Indeed) //Some指明不为空，且值为Indeed

scala> x = null
x: String = null

scala> var b = Option(x)
b: Option[String] = None //None判断为空

//example 1

scala> def divide(amt: Double, divisor: Double): Option[Double] = { //返回类型为Option，这样检查返回值类型便知是否为合法运算

     | if (divisor == 0) None
     | else Option(amt / divisor)
     | }
<console>: divide: (amt: Double, divisor: Double)Option[Double]

scala> val legit = divide(5, 2)
<console>: legit: Option[Double] = Some(2.5)

scala> val illegit = divide(3, 0)
<console>: illegit: Option[Double] = None

//example 2: scala为一些类型内置了Option选项的方法，如读取空列表的head元素

scala> List().head  //直接使用head会报异常

<console>: java.util.NoSuchElementException: head of empty list
  at scala.collection.immutable.Nil$.head(List.scala:426)
  at scala.collection.immutable.Nil$.head(List.scala:423)
  ... 28 elided

scala> List().headOption  //使用headOption则有特定返回值判断

res1: Option[Nothing] = None

//example

scala> def divide(amt: Double, divisor: Double): Option[Double] = {
     | if (divisor == 0) None
     | else Option(amt / divisor)
     | }
<console>: divide: (amt: Double, divisor: Double)Option[Double]

scala> val legit = divide(5, 2)
<console>: legit: Option[Double] = Some(2.5)

scala> val illegit = divide(3, 0)
<console>: illegit: Option[Double] = None

//syntax

class <identifier> [type-parameters]
                   [([val|var] <identifier>: <type> = <expression>[, ... ])]
                   [extends <identifier>[type-parameters](<input parameters>)]
                   [{ fields and methods }]                          

//syntax

class <identifier> [extends <identifier>] [{ fields, methods, and classes }]

//example 1：简单类与实例

scala> class Child extends Parent {val m_value; var m_variable; def foo = "fool"; class Nest {println("This is a nested class")}}
<console>: defined class Child

scala> val lm = new Child  //例化对象也使用new关键字

<console>: lm: Child = Child@memory_addr

//example 2: class nested in expression

scala> val te = {val tes = 18; class Test {var est = tes + 3}}
<console>: te: Unit = ()

//syntax

class <identifier> ([val|var] <identifier>: <type> = <expression>[, ... ])
                   [extends <identifier>(<input parameters>)]
                   [{ fields and methods }]
                   
//example 1：无默认参数

scala> class Car(val make: String, var reserved: Boolean) {
     | def reserve(r: Boolean): Unit = { reserved = r }
     | }
<console>: defined class Car

scala> val t = new Car("Toyota", reserved = false) //对于混合提供类参数，顺序遵守先位置参数，后命名参数，且命名参数顺序任意

<console>: t: Car = Car@4eb48298

scala> val tt = new Car  //实例化时必须提供参数

<console>:12: error: not enough arguments for constructor Car: (make: String, reserved: Boolean)Car.
Unspecified value parameters make, reserved.
       val tt = new Car
       
scala> t.reserved = true //访问类成员使用周期符号"."

<console>: t.reserved: Boolean = true

//example 2: 为父类提供类参数

scala> class Lotus(val color: String, reserved: Boolean) extends Car("Lotus", reserved)
<console>: defined class Lotus

//example 3: 设置类参数默认值

scala> class Car(val make: String, var reserved: Boolean = true, val year: Int = 2015) {
     | override def toString = s"$year $make, reserved = $reserved"
     | }
<console>: defined class Car

scala> val l = new Car("Lexus", year = 2010) //第二个默认为位置参数，第三个参数必须使用命名参数

<console>: l: Car = 2010 Lexus, reserved = true

//example

scala> class Singular[A](element: A) extends Traversable[A] {
     | def foreach[B](f: A => B) = f(element)
     | }
<console>: defined class Singular

scala> val p = new Singular[String]("Planes") //也可省略"[String]"，通过编译器的类型推断功能指定A

<console>: p: Singular[String] = (Planes)

//example

scala> abstract class Car {
     | val year: Int                 //声明，无定义
     
     | val automatic: Boolean = true //定义
     
     | def color: String             //声明，无定义
     
     | }
<console>: defined class Car

scala> new Car() //抽象类不可例化
<console>:9: error: class Car is abstract; cannot be instantiated new Car()

scala> class RedMini(val year: Int) extends Car { //子类重写

     | def color = "Red"
     | }
<console>: defined class RedMini

scala> val m: Car = new RedMini(2005)
<console>: m: Car = RedMini@5f5a33ed

//example 1: 抽象父类

scala> abstract class Listener { def trigger }
<console>: defined class Listener

scala> val myListener = new Listener {  //实现方式：在实例化语句后紧跟父类待实现或重写的方法定义. 实际上，这是个两步走过程，
                                        //第一步编译器生成包含重定义方法的自动化子类，第二步例化该自动化子类对象

     | def trigger { println(s"Trigger at ${new java.util.Date}") }
     | }
<console>: myListener: Listener = $anon$1@59831016

//example 2: 非抽象父类

scala> class A { def foo = "i\'m " + "father"} //不能使用类参数

<console>: defined class A

scala> val anon = new A {override def foo = "i\'m " + "child"}
<console>: anon: A = $anon$1@3e65c397

scala> anon.foo
<console>: res0: String = i'm child

//example 3: 观察者模式更方便

scala> abstract class Listener { def trigger }
<console>: defined class Listener

scala> class Listening {
     | var listener: Listener = null
     | def register(l: Listener) { listener = l } //将无名类定义放到函数调用中
     
     | def sendNotification() { listener.trigger }
     | }
<console>: defined class Listening

scala> val notification = new Listening()
<console>: notification: Listening = Listening@66596c4c

scala> notification.register(new Listener {  //无名类对象参数

     | def trigger { println(s"Trigger at ${new java.util.Date}") }
     | })

//example

scala> class Printer(msg: String) {
     | def print(s: String): Unit = println(s"$msg: $s")
     | def print(l: Seq[String]): Unit = print(l.mkString(", "))
     | }
<console>: defined class Printer

scala> new Printer("Today's Report").print("Foggy" :: "Rainy" :: "Hot" :: Nil)
<console>: Today's Report: Foggy, Rainy, Hot

//example
scala> class Multiplier(factor: Int) {
     | def apply(input: Int) = input * factor //定义apply函数
     
     | }
<console>: defined class Multiplier

scala> val tripleMe = new Multiplier(3)

<console>: tripleMe: Multiplier = Multiplier@339cde4b

scala> val tripled = tripleMe.apply(10) //显示调用

<console>: tripled: Int = 30

scala> val tripled2 = tripleMe(10)      //使用"对象名()"间接调用apply函数

<console>: tripled2: Int = 30

//example

scala> class RandomPoint {
     | val x = { println("creating x"); util.Random.nextInt }
     | lazy val y = { println("now y"); util.Random.nextInt }  //定义lazy value
     | }
<console>: defined class RandomPoint

scala> val p = new RandomPoint() //实例化时，会为对象内类成员分配内存空间并初始化，但lazy value未在其中

<console>: creating x
p: RandomPoint = RandomPoint@6c225adb

scala> println(s"Location is ${p.x}, ${p.y}") //当lazy value被访问时，才被初始化

now y
<console>: Location is 2019268581, -806862774

scala> println(s"Location is ${p.x}, ${p.y}") //第一次初始化后，值便稳定

<console>: Location is 2019268581, -806862774

//syntax: 第一种是在源文件开头加入package关键字的包定义，<identifier>的命名应该按照Java的定义，即机构属性+机构名+功能分类，如com.netflix.utilities.

package <identifier>
source code

//example

package bobsrockets.navigation //源文件开头的包定义

class Navigator ...  //源码

//syntax: 第二种使用package定义块区域，只有包含在区域内的源码才会打包在对应的路径下，这使得可以在同一文件中定义属于不同包的源码，但显然不是好的管理方式

package <identifier> {
    source code
}

//example

package com {
      package oreilly {           //逐层嵌套
      
                     class Config(val baseUrl: String = "http://localhost")
      }
}

//example 1: 完整路径引用

scala> val d = new java.util.Date
<console>: d: java.util.Date = Wed Jan 22 16:42:04 PDT 2014

//syntax: 导入指定包中类到当前命名空间，Scala中import的是一个语句，因为它没有返回值，可以放在任何可以使用语句的地方，如可以在使用处就近安置

import <package>.<class>

//example 2: 导入包中的一个类

scala> import java.util.Date
<console>: import java.util.Date

scala> val d = new Date //可省略路径

<console>: d: java.util.Date = Wed Jan 22 16:49:17 PDT 2014

//example 3: 使用下划线通配符导入整个包，在Java中使用的*，注意区分

scala> import collection.mutable._
<console>: import collection.mutable._

//syntax: 导入类集合，导入整个包可能带来命名冲突，所以可以选择只导入需要的类

import <package>.{<class 1>[, <class 2>...]}

//example 4

scala> import collection.mutable.{Queue,ArrayBuffer} //很明确导入了哪些类

<console>: import collection.mutable.{Queue, ArrayBuffer}

//syntax: 定义包别名，上一种方式还有一种潜在同名冲突问题，如前面介绍Scala中有immutable和mutable两个版本的collection，如同名Map类型，一旦导入mutable包，那么使用Map实例化便不会再例化immutable版本的对象，可以使用设置别名的方式加以规避，或使用完整路径名.

import <package>.{<original name>=><alias>}

//example 5

scala> import collection.mutable.{Map=>MutMap}
<console>: import collection.mutable.{Map=>MutMap}

scala> val m1 = Map(1 -> 2)
<console>: m1: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2)

scala> val m2 = MutMap(2 -> 3)
<console>: m2: scala.collection.mutable.Map[Int,Int] = Map(2 -> 3)

//example 1: protcted关键字

scala> class User { protected val passwd = util.Random.nextString(10) }
<console>: defined class User

//example 2: private关键字

scala> class User(private var password: String) {
     | def update(p: String) {
     |    println("Modifying the password!")
     |    password = p
     |  }
     | def validate(p: String) = p == password
     | }
<console>: defined class User

//example 3: 访问控制修饰符

package com.oreilly {
     private[oreilly] class Config {   //指明Config类在oreilly包内是public的，包外是private的
     
         val url = "http://localhost"
     }
     
     class Authentication {
         private[this] val password = "jason"   //同类对象不可访问，其他可访问
         
         def validate = password.size > 0       
     }

     class Test {
          println(s"url = ${new Config().url}")
     }
}

scala> val valid = new com.oreilly.Authentication().validate
<console>: valid: Boolean = true

scala> new com.oreilly.Test      //Test类位于com.reilly包内，所以可以例化Config的实例

<console>:
url = http://localhost
res0: com.oreilly.Test = com.oreilly.Test@4c309d4d

scala> new com.oreilly.Config   //因为指明在com.reilly包内的类才能访问，所以这里不能直接例化实例

<console>:8: error: class Config in package oreilly cannot be
accessed in package com.oreilly
new com.oreilly.Config

//syntax: 由于object由编译器自动初始化，所以object定义不能包含类初始化参数.

object <identifier> [extends <identifier>]
                    [{ fields, methods, and classes }]

//example

scala> object Hello { println("in Hello"); def hi = "hi" }   
<console>: defined object Hello

scala> println(Hello.hi)   
in Hello        //第一次被访问会自动初始化

<console>: hi

scala> println(Hello.hi) //之后访问不会再初始化

<console>: hi

//example 1

scala> class Multiplier(val x: Int) { def product(y: Int) = x * y }
<console>: defined class Multiplier

scala> object Multiplier { def apply(x: Int) = new Multiplier(x) } //对象工厂

<console>: defined object Multiplier

scala> val tripler = Multiplier(3) //通过调用伴生的object对象来创建常规类Multiplier的对象，而不是使用new，这个就是chisel wiki中推荐的省略new的方式

<console>: tripler: Multiplier = Multiplier@5af28b27

scala> val result = tripler.product(13)
<console>: result: Int = 39

//example 2: 访问控制

scala> :paste
// Entering paste mode (ctrl-D to finish)

object DBConnection {
      private val db_url = "jdbc://localhost"
      private val db_user = "franken"   
      private val db_pass = "berry"

      def apply() = new DBConnection
}                                                          

class DBConnection {
        private val props = Map(  
             "url" -> DBConnection.db_url, //通过类名直接访问伴生object的私有变量
             
             "user" -> DBConnection.db_user,
             "pass" -> DBConnection.db_pass
         )
         println(s"Created new connection for " + props("url"))
}

// Exiting paste mode, now interpreting.

defined object DBConnection
defined class DBConnection

scala> val conn = DBConnection()
Created new connection for jdbc://localhost
<console>: conn: DBConnection = DBConnection@4d27d9d

//example

$ cat > Date.scala object Date {
          def main(args: Array[String])  //定义main函数
          
          {
              println(new java.util.Date)
          }
        }

$ scalac Date.scala  //编译

$ scala Date  //运行，如果要为main提供参数，可以跟在Date类后添加

Mon Sep 01 22:03:09 PDT 2014

//syntax: 直接在类定义加implicit关键字

implicit class <identifier> ...

//example

scala> object IntUtils {
     |   implicit class Fishies(val x: Int) {   //将Int类型转换为Fishies类型
     
     |           def fishes = "Fish" * x
     |   }
     | }
<console>: defined object IntUtils

scala> import IntUtils._   //使用之前需要将其添加到当前的namespace中

<console>: import IntUtils._

scala> println(3.fishes) //Int类型参数转换为Fishies class以访问类内方法

<console>: FishFishFish

implicit class ArrowAssoc[A](x: A) {
      def ->[B](y: B) = Tuple2(x, y)
}

//syntax: 注意参数化列表中不包含val参数类型，因为默认情况下，case class会将参数转化为val，所以没有必要单独声明val变量，但依然可以使用var声明变量.

case class <identifier> ([var] <identifier>: <type>[, ... ])  
                                                     
                        [extends <identifier>(<input parameters>)]
                        [{ fields and methods }]

//example 1：自动化生成方法示例

scala> case class Character(name: String, isThief: Boolean)
<console>: defined class Character

scala> val h = Character("Hadrian", true)
<console>: h: Character = Character(Hadrian,true)

scala> val r = h.copy(name = "Royce")
<console>: r: Character = Character(Royce,true)

scala> h == r
<console>: res0: Boolean = false

scala> h match {
         | case Character(x, true) => s"$x is a thief" //应用unapply分解类属性，将第一个参数用于值绑定，第二个参数做匹配
         
         | case Character(x, false) => s"$x is not a thief"
         | }
<console>: res1: String = Hadrian is a thief

//example 2: data-based

scala> :paste

abstract class Expr
case class Var(name: String) extends Expr
case class Number(num: Double) extends Expr
case class UnOp(operator: String, arg: Expr) extends Expr
case class BinOp(operator: String, left: Expr, right: Expr) extends Expr

//syntax

trait <identifier> [type-parameters]  //泛型

                   [extends <identifier>[type-parameters]]
                   [{ fields, methods, and classes }]
                   
//example

scala> trait HtmlUtils {
     |   def removeMarkup(input: String) = {
     |      input
     |      .replaceAll("""</?\w[^>]*>""","")； .replaceAll("<.*>","")
     |   }
     | }
<console>: defined trait HtmlUtils

scala> class Page(val s: String) extends HtmlUtils {
     |  def asPlainText = removeMarkup(s)  //直接访问父类方法
     
     | }
<console>: defined class Page

scala> new Page("<html><body><h1>Introduction</h1></body></html>").asPlainText
<console>: res2: String = Introduction

//example 1

scala> trait Base { override def toString = "Base" }
<console>: defined trait Base

scala> class A extends Base { override def toString = "A->" + super.toString }
<console>: defined class A

scala> trait B extends Base { override def toString = "B->" + super.toString }
<console>: defined trait B

scala> trait C extends Base { override def toString = "C->" + super.toString }
<console>: defined trait C

scala> class D extends A with B with C { override def toString = "D->" + super.toString } //书面多继承顺序D->A->B->C

<console>: defined class D

scala> new D()
<console>: res0: D = D->C->B->A->Base //编译器中依次单继承的顺序

//example 2：重写顺序

scala> class RGBColor(val color: Int) { def hex = f"$color%06X" }
defined class RGBColor

scala> val green = new RGBColor(255 << 8).hex
green: String = 00FF00

scala> trait Opaque extends RGBColor { override def hex = s"${super.hex}FF" }
defined trait Opaque     

scala> class Paint(color: Int) extends RGBColor(color) with Opaque
defined class Paint

scala> val red = new Paint(128 << 16).hex
<console>: red: String = 800000FF

//因为编译顺序Paint->Opaque->RGBColor，继承顺序指明了对象的内存模型，如下，所以类参数从最里层的父类开始做初始化，而hex函数的调用从外层依次向里层查找，这就理解输出为什么为800000FF.


================Paint instance memory model==================
 __________________
|  ______________  |               
| |  __________  | |    
| | |          | | |
| | |          | | |
| | |_RGBColor_| | |
| |____Opaque____| |
|__________________|
  Paint instance
=============================================================

scala> val blue = new Overlay(192).hex
blue: String = 0000C033

//syntax: <identifier>的标准用法是self，当然也可以使用其他的非scala关键字合法名称，但应尽量使用标准标识符.

trait ..... { <identifier>: <type> => .... }

//example 1

scala> class A { def hi = "hi" }
<console>: defined class A

scala> trait B { self: A =>  //声明self type

     | override def toString = "B: " + hi
     | }
defined trait B

scala> class C extends B    //C不是B中标识的A class或其子类，所以不能继承

<console>:9: error: illegal inheritance;self-type C does not conform to B's selftype B with A class C extends B ^

scala> class C extends A with B //C是A的子类，可以继承B

<console>: defined class C

//example 2: 弥补缺陷

scala> class TestSuite(suiteName: String) { def start() {} }
<console>: defined class TestSuite

scala> trait RandomSeeded { self: TestSuite =>
     |    def randomStart() {
     |       util.Random.setSeed(System.currentTimeMillis)
     |       self.start()   //通过self直接调用指定类成员
     
     |    }
     | }
<console>: defined trait RandomSeeded

//example 1

scala> class A
defined class A

scala> trait B { self: A => }  //self type不是必须

defined trait B

scala> val a = new A with B  //例化对象时使用trait继承. 这里实际上是编译器自动生成了一个无名类，即anonymousClass extends A with B，之后实例化对象两步完成，但对用户是透明的.

a: A with B = $anon$1@26a7b76d

//example 2

scala> class User(val name: String) {
     |     def suffix = ""
     |     override def toString = s"$name$suffix"
     | }
<console>: defined class User

scala> trait Attorney { self: User => override def suffix = ", esq." }
<console>: defined trait Attorney

scala> trait Wizard { self: User => override def suffix = ", Wizard" }
<console>: defined trait Wizard

scala> val h = new User("Harry P") with Wizard
<console>: h: User with Wizard = Harry P, Wizard

scala> val g = new User("Ginny W") with Attorney
<console>: g: User with Attorney = Ginny W, esq.

//example

scala> val hello1 = (n: String) => s"Hello, $n"
<console>: hello1: String => String = <function1>

scala> val h1 = hello1("Function Literals")
<console>: h1: String = Hello, Function Literals

scala> val hello2 = new Function1[String,String] {  //对比验证

     |      def apply(n: String) = s"Hello, $n"
     | }
<console>: hello2: String => String = <function1>

scala> val h2 = hello2("Function1 Instances")     //调用apply方法

h2: String = Hello, Function1 Instances

scala> println(s"hello1 = $hello1, hello2 = $hello2")
hello1 = <function1>, hello2 = <function1>        //一个东西

//example

scala> object Doubly {
     |   def print(num: Double)(implicit fmt: String) = { //参数分组，将隐式与非隐式参数分隔
     
     |       println(fmt format num)
     |   }
     | }
<console>: defined object Doubly

scala> Doubly.print(3.724) //参数不全，无法调用

<console>:9: error: could not find implicit value for parameter fmt: String Doubly.print(3.724)

scala> Doubly.print(3.724)("%.1f")  //显式传递参数

<console>: 3.7

//隐式调用对比

scala> case class USD(amount: Double) {
     |    implicit val printFmt = "%.2f"   //主调函数定义局部value，用于填充隐式参数，注意implicit在主调被调函数都要指明
     
     |    def print = Doubly.print(amount)
     | }
<console>: defined class USD

scala> new USD(81.924).print
<console>: 81.92

//syntax: 使用type关键字定义

type <identifier>[type parameters] = <type name>[type parameters]

//example

scala> object TypeFun {
     | type Whole = Int
     | val x: Whole = 5
     |
     | type UserInfo = Tuple2[Int,String]
     | val u: UserInfo = new UserInfo(123, "George")
     |
     | type T3[A,B,C] = Tuple3[A,B,C]
     | val things = new T3(1, 'a', true)
     | }
<console>: defined object TypeFun

scala> val x = TypeFun.x
<console>: x: TypeFun.Whole = 5

scala> val u = TypeFun.u
<console>: u: TypeFun.UserInfo = (123,George)

scala> val things = TypeFun.things
<console>: things: (Int, Char, Boolean) = (1,a,true)

//example 1：版本一

scala> trait Factory { type A; def create: A }  //type A声明A为抽象类

<console>: defined trait Factory

scala> trait UserFactory extends Factory {
     | type A = User
     | def create = new User("")
     | }
<console>: defined trait UserFactory

//example 2: 版本二

scala> trait Factory[A] { def create: A }  //这里使用泛型代替了版本一的形式，所以，可以说abstract type是泛型设计的另一种描述形式

defined trait Factory

scala> trait UserFactory extends Factory[User] { def create = new User("") }
defined trait UserFactory

//syntax: 操作符<:

<identifier> <: <upper bound type>

//example

scala> class BaseUser(val name: String)
<console>: defined class BaseUser

scala> class Admin(name: String, val level: String) extends BaseUser(name)
<console>: defined class Admin

scala> class Customer(name: String) extends BaseUser(name)
<console>: defined class Customer

scala> class PreferredCustomer(name: String) extends Customer(name)
<console>: defined class PreferredCustomer

scala> def check[A <: BaseUser](u: A) { if (u.name.isEmpty) println("Fail!") }  //指定可接受参数类型是BaseUser或其子类对象

<console>: check: [A <: BaseUser](u: A)Unit

scala> check(new Customer("Fred"))

scala> check(new Admin("", "strict"))
<console>: Fail!

//syntax: 操作符>:

<identifier> >: <lower bound type>

//example

scala> def recruit[A >: Customer](u: Customer): A = u match {
     | case p: PreferredCustomer => new PreferredCustomer(u.name)
     | case c: Customer => new Customer(u.name)
     | }
<console>: recruit: [A >: Customer](u: Customer)A

scala> val customer = recruit(new Customer("Fred"))
<console>: customer: Customer = Customer@4746fb8c

scala> val preferred = recruit(new PreferredCustomer("George"))  //函数定义中指定最低阶类为Custom，但这里传入其子类，

<console>: preferred: Customer = PreferredCustomer@4cd8db31      //虽然会正确返回子类对象，但val只能使用限定的Customer定义

//example 1

scala> class Car { override def toString = "Car()" } 
defined class Car

scala> class Volvo extends Car { override def toString = "Volvo()" } 
defined class Volvo

scala> val c: Car = new Volvo() 
c: Car = Volvo()

scala> case class Item[A](a: A) { def get: A = a } 
defined class Item

scala> val c: Item[Car] = new Item[Volvo](new Volvo)   //即子类Volvo可以赋值给与父类Car的value以实现多态，但在类的泛型定义中，泛型声明与类定义是特定组合，即使type parameter是相互兼容，也不能匹配.

<console>:12: error: type mismatch; found : Item[Volvo] required: Item[Car]
Note: Volvo <: Car, but class Item is invariant in type A. You may wish to define A as +A instead. (SLS 4.5) val c: Item[Car] = new Item[Volvo](new Volvo)