// 隐式参数: 自动传递
case class Config(timeout: Int, retries: Int)

def connect(url: String)(implicit config: Config): Unit = {
    println(s"Connecting to $url with timeout ${config.timeout}")
}

implicit val defaultConfig = Config(5000, 3)
connect("http://example.com")  // 自动传入 defaultConfig

// 类型类模式
trait Show[A] {
    def show(value: A): String
}

implicit val intShow: Show[Int] = (value: Int) => s"Int($value)"
implicit val stringShow: Show[String] = (value: String) => s"String($value)"

def display[A](value: A)(implicit s: Show[A]): String = s.show(value)

println(display(42))       // Int(42)
println(display("hello"))  // String(hello)

// 隐式转换: 自动类型转换
class Fraction(val n: Int, val d: Int) {
    override def toString = s"$n/$d"
    def *(other: Fraction) = new Fraction(n * other.n, d * other.d)
}

object Fraction {
    implicit def intToFraction(n: Int): Fraction = new Fraction(n, 1)
}

import Fraction._

val result = 3 * new Fraction(1, 2)  // 3 自动转为 Fraction(3, 1)
println(result)  // 3/2

// 隐式类: 扩展方法
implicit class StringOps(val s: String) extends AnyVal {
    def shout: String = s.toUpperCase + "!"
    def whisper: String = s.toLowerCase + "..."
}

println("hello".shout)   // HELLO!
println("HELLO".whisper) // hello...

import scala.annotation._

// 内置注解
@deprecated("Use newMethod instead", "1.0")
def oldMethod(): Unit = {}

@tailrec
def factorial(n: Int, acc: Int = 1): Int = {
    if (n <= 1) acc
    else factorial(n - 1, n * acc)
}

@volatile var running = true

// 自定义注解
import scala.annotation.StaticAnnotation

class description(text: String) extends StaticAnnotation

@description("This is a person class")
case class Person(name: String, age: Int)

// 编译时注解处理需要宏 (macro)

// JSON 类型类
trait JsonWriter[A] {
    def write(value: A): String
}

object JsonWriter {
    def apply[A](implicit writer: JsonWriter[A]): JsonWriter[A] = writer
    
    // 内置实例
    implicit val stringWriter: JsonWriter[String] = 
        (value: String) => s""""$value""""
    
    implicit val intWriter: JsonWriter[Int] = 
        (value: Int) => value.toString
    
    implicit val boolWriter: JsonWriter[Boolean] = 
        (value: Boolean) => value.toString
    
    implicit def listWriter[A](implicit w: JsonWriter[A]): JsonWriter[List[A]] =
        (value: List[A]) => value.map(w.write).mkString("[", ",", "]")
    
    implicit def mapWriter[A](implicit w: JsonWriter[A]): JsonWriter[Map[String, A]] =
        (value: Map[String, A]) => 
            value.map { case (k, v) => s""""$k":${w.write(v)}""" }
                 .mkString("{", ",", "}")
}

// 语法糖
implicit class JsonOps[A](val value: A) extends AnyVal {
    def toJson(implicit writer: JsonWriter[A]): String = writer.write(value)
}

// 使用
println(42.toJson)                          // 42
println("hello".toJson)                     // "hello"
println(List(1, 2, 3).toJson)               // [1,2,3]
println(Map("a" -> 1, "b" -> 2).toJson)     // {"a":1,"b":2}