// 에러: type mismatch; found: String, required: Int
def add(a: Int, b: Int): Int = a + b
add(1, "2")  // String을 Int 자리에 전달

// 에러: type mismatch
//   found   : Map[String, List[Option[Int]]]
//   required: Map[String, List[Option[String]]]
def process(data: Map[String, List[Option[String]]]): Unit = {}

val input: Map[String, List[Option[Int]]] = Map("key" -> List(Some(1)))
process(input)  // 깊이 중첩된 타입 파라미터 불일치

// 에러: covariant type A occurs in contravariant position
class Container[+A] {
  def add(item: A): Unit = {}  // A가 메서드 파라미터(반공변 위치)에 사용됨
}

class Container[+A] {
  def add[B >: A](item: B): Container[B] = {
    // B는 A의 슈퍼타입
    new Container[B]
  }
}

val dogs: Container[Dog] = new Container[Dog]
val animals: Container[Animal] = dogs  // 공변이므로 가능

// build.sbt (Scala 2.13)
addCompilerPlugin("io.tryp" % "splain" % "1.1.0" cross CrossVersion.full)

// build.sbt
scalacOptions += "-Xprint:typer"

# 특정 파일만 컴파일하며 타입 확인
sbt "compile:doc"
# 또는 REPL에서
scala -Xprint:typer -e "val x = List(1, 2, 3).map(_ + 1)"

// F는 타입 생성자 (예: List, Option)
trait Functor[F[_]] {
  def map[A, B](fa: F[A])(f: A => B): F[B]
}

// 에러: Map takes two type parameters, expected: one
// Map[String, *]은 F[_]에 맞지 않음
// implicit val mapFunctor: Functor[Map] = ???  // 컴파일 안 됨

// 에러: missing parameter type
val result = List(1, 2, 3).foldLeft(Map.empty)((acc, x) => acc + (x.toString -> x))

// 해결: 초기값의 타입을 명시
val result = List(1, 2, 3).foldLeft(Map.empty[String, Int])((acc, x) =>
  acc + (x.toString -> x)
)

// 컴파일러가 추론에 실패하는 경우
def transform[A, B](list: List[A])(f: A => B): List[B] = list.map(f)

// 에러: missing parameter type for expanded function
// transform(List(1, 2, 3))(x => x.toString)

// 해결 방법 1: 람다 파라미터에 타입 명시
transform(List(1, 2, 3))((x: Int) => x.toString)

// 해결 방법 2: 타입 인자 명시
transform[Int, String](List(1, 2, 3))(x => x.toString)

// 잘못된 예: 빈 컬렉션에서 Nothing 추론
val map = Map.empty  // Map[Nothing, Nothing]으로 추론됨
map + ("key" -> 1)   // 에러: type mismatch

// 올바른 예: 타입 명시
val map = Map.empty[String, Int]
map + ("key" -> 1)   // 정상 동작

class Outer {
  class Inner
  def process(inner: Inner): Unit = {}
}

val a = new Outer
val b = new Outer
val innerA = new a.Inner

// 에러: type mismatch; found: a.Inner, required: b.Inner
// b.process(innerA)

// 해결: 같은 인스턴스의 Inner를 사용하거나, 타입 프로젝션 사용
def processAny(inner: Outer#Inner): Unit = {}
processAny(innerA)  // 정상 동작

// 경고: non-variable type argument String in type pattern
// List[String] is unchecked since it is eliminated by erasure
def process(list: Any): Unit = list match {
  case l: List[String] => println("String list")  // 런타임에 확인 불가
  case _ => println("Other")
}

// 해결: TypeTag 또는 ClassTag 사용
import scala.reflect.ClassTag

def process[A: ClassTag](list: List[A]): Unit = {
  val clazz = implicitly[ClassTag[A]].runtimeClass
  println(s"List of ${clazz.getSimpleName}")
}