Scala 让你又爱又恨的语法，到底在表达什么

val pf1: PartialFunction[Any, String] = { case s: String => "yes" }
val pf2: PartialFunction[Any, String] = { case d: Double => "yes" }
val pf = pf1 orElse pf2
List("str", 3.14, 10) foreach { item => print(pf(item).toString + "") }

val array: Array[String] = new Array[String](5)   // val 声明，引用不可变
array(0) = "hello"                                // 但 array[0] 是可变的！

var stockPrice: Double = 100.0                    // var 才是真正"可重新赋值"
stockPrice = 200.0

class Crocodile extends Animal with Carnivore with Philosopher {
  // 方法名是 ?!，能这样写是因为 Scala 里"操作符"就是方法
  override def ?!(thought: String): Unit = println(s"I was thinking: $thought")
}

val aCroc = new Crocodile
aCroc ?! "What if we could fly?"   // 调用的是 aCroc.?!("What if we could fly?")

case class Point(x: Double = 0.0, y: Double = 0.0) {
  // shift 方法返回一个新 Point，原 Point 不变
  def shift(deltax: Double = 0.0, deltay: Double = 0.0) =
    copy(x + deltax, y + deltay)
}

sealed abstract class Option[+A] {}   // +A 后面会讲，sealed 现在先记住

abstract class Animal                  // 任何文件、任何包都能继承
sealed abstract class Animal           // 只能在本文件继承

def factorial(intValue: Int): Long = {
  @tailrec   // 强制要求下面的 fact 必须是尾递归，否则编译报错
  def fact(value: Int, accumulator: Int): Long = {
    if (value <= 1) accumulator
    else fact(value - 1, value * accumulator)   // 递归调用之后没有任何其他操作 = 尾递归
  }
  fact(intValue, 1)
}

def singleArgMethod(arg: Int): String = s"$arg little ducks..."

val description = singleArgMethod {
  // 花括号里的表达式会被求值后传给 singleArgMethod
  42
}   // 等价于 singleArgMethod(42)

List(1, 2, 3).map { x => x + 1 }   // 比 List(1, 2, 3).map(x => x + 1) 看着舒服

trait Action {
  def act(x: Int): Int
}

val aFunkyInstance: Action = (x: Int) => x + 1   // 编译器知道 Action 只有一个抽象方法

val aSweetThread = new Thread(() => println("sweet, scala!"))
// 替代了 new Thread(new Runnable { override def run(): Unit = ... })

val prependedList = 2 :: List(3, 4)
// 不是 2.::(List(3, 4))，而是 List(3, 4).::(2)
// 因为以 : 结尾的方法是右结合的

val chain = 1 :: 2 :: 3 :: List(4, 5)
// 实际执行顺序：List(4, 5).::(3).::(2).::(1)

class TeenGirl(name: String) {
  // 反引号包起来的任意字符串都能当方法名
  def `and then said`(gossip: String) = println(s"$name said $gossip")
}

val lilly = new TeenGirl("Lilly")
lilly `and then said` "Scala is so sweet"   // 调用是 lilly.`and then said`("...")

class Composite[A, B]
val composite: Int Composite String = ???

class -->[A, B]
val towards: Int --> String = ???

val anArray = Array(1, 2, 3)
anArray(2)        // 编译为 anArray.apply(2)，读取元素
anArray(2) = 7    // 编译为 anArray.update(2, 7)，写入元素

class Mutable {
  private var internalMember: Int = 0   // 真正的存储

  def member = internalMember           // getter

  def member_=(value: Int): Unit =      // setter，方法名以 _= 结尾
    internalMember = value
}

val a = new Mutable
a.member = 42   // 编译为 a.member_=(42)

val aList = List(1, 2, 3)
val listDescription = aList match {
  case List(_, 2, _) => "List containing 2 on its second position"
  case _             => "unknown list"
}

val numberList = List(1, 2, 3, 42)

// 模式 1 :: tail 既解构（head=1, tail=List(2,3,42)），又判断（列表非空）
val startsWithOne = numberList match {
  case 1 :: tail => s"list starts with one, tail is $tail"
}

def process(aList: List[Int]): String = aList match {
  case Nil              => "List is empty"
  case head :: tail     => s"list starts with $head, tail is $tail"
}

val dontCareAboutTheRest = numberList match {
  case List(_, 2, _*) => "I only care about second number being 2"
  //      ^^^^^^^^
  //      _* 表示"任意多个元素，名字我不关心"
}

val mustEndWithTheMeaningOfLife = numberList match {
  // List(1, 2, _) :+ 42 是个中缀表达式
  // 含义：一个 List(1, 2, 任意) 后面追加 42
  case List(1, 2, _) :+ 42 => "that's right, I have a meaning"
}

def gimmeAValue(): Any = 45

val gimmeTheType: String = gimmeAValue() match {
  case _: String => "I have a string"
  case _: Int    => "I have an int"
  case _         => "Something else"
}

val bobInfo: String = bob match {
  // p@Person(name, age) 把整个对象绑定到 p，同时把字段解构到 name、age
  case p @ Person(name, age) => s"$name's info: ${requestInfo(p)}"
}

val ordinal2: String = aNumber match {
  case 1 => "first"
  case 2 => "second"
  case 3 => "third"
  case n if n % 10 == 1 => n + "st"   // 守卫：只有这个条件成立才算匹配
  case n if n % 10 == 2 => n + "nd"
  case n if n % 10 == 3 => n + "rd"
  case _ => aNumber + "th"
}

val myOptionalList = numberList match {
  case List(1, _*) | List(_, _, 3, _*) => "I like this list"
  //                ^
  //                | 表示"或者"，只要左或右任一匹配就算匹配
  case _ => "I hate this list"
}

class Person(val name: String, val age: Int)

object Person {
  // 让 Person 也能参与模式匹配，并且加入"未成年不能匹配"的业务规则
  def unapply(person: Person): Option[(String, Int)] =
    if (person.age < 21) None        // 返回 None 表示"模式不匹配"
    else Some((person.name, person.age))

  // 重载：让 Person 这个 object 也能匹配 Int 类型的输入
  def unapply(age: Int): Option[String] =
    Some(if (age < 21) "minor" else "major")
}

val bob = new Person("Bob", 25)
val greeting = bob match {
  case Person(n, a) => s"Hi, my name is $n and I am $a year."
}
// greeting == "Hi, my name is Bob and I am 25 year."

val legalStatus = bob.age match {
  case Person(status) => s"my legal status is $status"
  //               ^^^^^^
  //      bob.age 是 Int，匹配的是 unapply(age: Int) 那个重载
}
// legalStatus == "my legal status is major"

// even 和 singleDigit 不是值，是返回 Boolean 的 unapply object
object even       { def unapply(arg: Int): Boolean = arg % 2 == 0 }
object singleDigit { def unapply(arg: Int) = arg > -10 && arg < 10 }

val n = 8
val mathProperty = n match {
  case singleDigit() => "single digit"   // 匹配 predicate
  case even()        => "an even number"
  case _             => "no property"
}

// unapply 的"标准签名"是 Option[T]
// 但编译器只要求返回类型有 isEmpty: Boolean 和 get: T 两个方法
abstract class Wrapper[T] {
  def isEmpty: Boolean
  def get: T
}

object PersonWrapper {
  def unapply(person: Person): Wrapper[String] = new Wrapper[String] {
    def isEmpty = false
    def get = person.name
  }
}

println(bob match {
  case PersonWrapper(n) => s"This person's name is $n"
  case _               => "An alien"
})