类型系统 #

        Any
       /    \
    AnyVal  AnyRef
    /  |  \      \
  Int Double Boolean String ...
    \   |   /      /
       Null
         |
       Nothing

val any: Any = 42
val anyVal: AnyVal = 42
val anyRef: AnyRef = "hello"

val nothing: Nothing = throw new Exception("error")
val nullVal: Null = null

class Box[+T](val value: T)

class Animal
class Dog extends Animal

val dogBox: Box[Dog] = Box(Dog())
val animalBox: Box[Animal] = dogBox

trait Printer[-T]:
  def print(value: T): String

class Animal
class Dog extends Animal

val animalPrinter: Printer[Animal] = new Printer[Animal]:
  def print(value: Animal): String = "Animal"

val dogPrinter: Printer[Dog] = animalPrinter

class Container[T](var value: T)

val intContainer: Container[Int] = Container(42)
val anyContainer: Container[Any] = intContainer

val list: List[?] = List(1, 2, 3)
val map: Map[?, ?] = Map("a" -> 1)

def process(list: List[?]): Int = list.length

val numbers: List[? <: Number] = List(1, 2, 3)
val strings: List[? >: String] = List("a", "b", "c")

def printAll(list: List[?]): Unit =
  list.foreach(println)

printAll(List(1, 2, 3))
printAll(List("a", "b", "c"))

class Outer:
  class Inner(val value: Int)
  
  def createInner(v: Int): Inner = Inner(v)

val outer1 = Outer()
val outer2 = Outer()

val inner1: outer1.Inner = outer1.createInner(1)
val inner2: outer2.Inner = outer2.createInner(2)

val outer1 = Outer()
val outer2 = Outer()

val inner1: outer1.Inner = outer1.createInner(1)
val inner2: outer2.Inner = inner1

class Outer:
  class Inner(val value: Int)

def process(inner: Outer#Inner): Int = inner.value

val outer1 = Outer()
val outer2 = Outer()

process(outer1.Inner(1))
process(outer2.Inner(2))

trait Container:
  type T
  def value: T
  def describe: String = s"Value: $value"

class IntContainer extends Container:
  type T = Int
  def value: Int = 42

class StringContainer extends Container:
  type T = String
  def value: String = "hello"

val intContainer: IntContainer = IntContainer()
val stringContainer: StringContainer = StringContainer()

trait OrderedContainer:
  type T <: Ordered[T]
  def value: T
  def compare(other: T): Int = value.compare(other)

type Name = String
type Age = Int
type Person = (Name, Age)

val person: Person = ("Alice", 25)

type StringList = List[String]
type IntMap[V] = Map[Int, V]
type Result[T] = Either[String, T]

val names: StringList = List("a", "b", "c")
val scores: IntMap[String] = Map(1 -> "A", 2 -> "B")
val result: Result[Int] = Right(42)

transparent inline type UserId = Long

val userId: UserId = 42L

def describe(x: Any): String = x match
  case i: Int => s"Int: $i"
  case s: String => s"String: $s"
  case list: List[?] => s"List with ${list.length} elements"
  case _ => "Unknown"

def check(list: Any): String = list match
  case _: List[Int] => "List of Int"
  case _: List[String] => "List of String"
  case _ => "Other"

import scala.reflect.TypeTest

def describe[T: TypeTest](x: Any): String = x match
  case t: T => s"Matched: $t"
  case _ => "No match"

describe[Int](42)
describe[String]("hello")

val list = List(1, 2, 3)
val map = Map("a" -> 1, "b" -> 2)
val result = list.map(_ * 2)

val empty = List()
val empty2 = List.empty[Int]

val nothing = None
val nothing2 = None: Option[Int]

val result = List(1, 2, 3).foldLeft(List.empty[Int])((acc, x) => x :: acc)

val x = 42
val y: x.type = x

def getValue[T](t: T): t.type = t

def process(value: Int | String): String = value match
  case i: Int => s"Int: $i"
  case s: String => s"String: $s"

process(42)
process("hello")

trait A:
  def a: String

trait B:
  def b: Int

class C extends A with B:
  def a: String = "A"
  def b: Int = 42

def process(value: A & B): String = s"${value.a} - ${value.b}"