타입으로 견고하게 다형성으로 유연하게 3주차 - 하업서

2025/RobustWithTypeFlexibleWithPolymorphism/hemil0102/3장.md

@@ -0,0 +1,149 @@
+# 3장 매개변수에 의한 다형성
+
+이쯤해서 다시 한번 짚어보는 다형성이란? 
+프로그램 언어 각 요소들(상수, 변수, 식, 객체, 메소드 등)이 
+다양한 자료형(type)에 속하는 것이 허가되는 성질을 가리킨다. 
+
+어떤 타입을 사용할지 미리 알려줘야한다. 즉 타입을 매개변수처럼 입력을 받는다. 
+
+### 3.1 제네릭 함수 
+매개변수에 의한 다형성은 타입 매개변수를 통해 다형성을 만드는 기능으로, 제네릭스라고도 부른다. 
+
+Any와 제네릭의 차이? 
+Any는 아무 타입이나 될 수 있기에 타입이 결정되지 않는 불확실함으로 컴파일 이전에 타입 유추를 할 수 없다. 
+타입 유추를 할 수 없기에 어떤 타입에서 활용할 기능을 미리 정의할 수 없다. 
+
+반면 제네릭은 어떤 타입이든 될 수 있는 것은 같지만, 미리 타입을 지정하므로써 해당 타입의 기능을 가져다 쓸 수 있다. 
+
+T가 타입 매개변수일 때 함수 안에서 T타입의 부품은 아무 특별한 능력도 요구되지 않는 곳에만 사용될 수 있다. 
+아무 특별한 능력을 요구하지 않는다는 말은 타입에 따라서 연산을 할 수 없는 행위들을 말한다. 
+
+### 힌들리-밀너 타입 추론
+제네릭 함수를 정의할 때 추론을 한다. 
+
+### 3.2 제네릭 타입 
+타입 매개변수를 추가할 수 있는 곳은 함수뿐이 아니다. 타입에 타입 매개변수를 추가하면 제네릭 타입이 된다. 
+
+```swift
+struct IntBox {
+   var value: Int
+}
+
+struct StringBox { 
+   var value: String
+}
+
+위와 같은 비슷한 구조 타입들에 제네릭을 적용한다. 
+
+struct Box<T> { 
+   var value: T
+}
+
+let intBox = Box(value: 42)
+let stringBox = Box(value: "Hi")
+```
+
+제네릭 타입은 Json 디코더에서 사용해본 기억이 있음 
+
+### 3.3 무엇이든 타입
+제네릭 함수의 타입, 제네릭 함수를 값(매개변수)로 사용하면 그 타입이 무엇이든 타입이 되고, 무엇이든 타입의 값을 사용할 때는 제네릭 함수를 사용하듯이 하면 된다. 
+
+```swift
+func identity<T>(_ value: T) -> T {
+    return value
+}
+
+let intFunction: (Int) -> Int = identity
+let stringFunction: (String) -> String = identity
+
+print(intFunction(10)) // 10
+print(stringFunction("Hello")) // Hello
+
+func apply<T>(_ function: (T) -> T, to value: T) -> T {
+    return function(value)
+}
+
+print(apply(identity, to: 100)) // 100
+print(apply(identity, to: "hello")) // hello
+```
+
+```swift
+protocol ApplyFunction {
+    func apply<T>(_ function: (T) -> T, to value: T) -> T
+}
+
+class ApplyOne: ApplyFunction {
+    func apply<T>(_ function: (T) -> T, to value: T) -> T {
+        let transformedValue = function(value)
+
+        if let number = transformedValue as? Int {
+            return (number + 1) as! T
+        } else if let text = transformedValue as? String {
+            return (text + "!") as! T
+        } else {
+            print("Unsupported type: \(T.self)")
+            return transformedValue
+        }
+    }
+}
+
+class ApplyTwo: ApplyFunction {
+    func apply<T>(_ function: (T) -> T, to value: T) -> T {
+        let transformedValue = function(value)
+
+        if let number = transformedValue as? Int {
+            return (number + 2) as! T
+        } else if let text = transformedValue as? String {
+            return (text + "!!") as! T
+        } else {
+            print("Unsupported type: \(T.self)")
+            return transformedValue
+        }
+    }
+}
+
+func simulate(r: ApplyFunction) {
+    print(r.apply(identity, to: 100))
+    print(r.apply(identity, to: "hello"))
+}
+
+let applyOne = ApplyOne()
+let applyTwo = ApplyTwo()
+
+simulate(r: applyOne) // 101, hello!
+simulate(r: applyTwo) // 102, hello!!
+```
+
+### 3.4 무엇인가 타입 
+
+```swift
+protocol Timestamp {
+    associatedtype T
+    func initValue() -> T
+    func next(_ t: T) -> T
+    func cmp(_ t1: T, _ t2: T) -> Bool
+}
+
+class Timestamper: Timestamp {
+    typealias T = Int
+
+    func initValue() -> Int { return 0 }
+    func next(_ t: Int) -> Int { return t + 1 }
+    func cmp(_ t1: Int, _ t2: Int) -> Bool { return t1 < t2 }
+}
+
+func create() -> some Timestamp {
+    return Timestamper()
+}
+
+let ts = create() // some Timestamp 타입이 반환되며 Timestamper()는 숨겨진다.
+let t0 = ts.initValue() // let t1: (some Timestamp).T
+let t1 = ts.next(t0) // let t1: (some Timestamp).T
+
+print(t1) // 1
+print(ts.cmp(t0, t1)) // true
+```
+
+### 논제 ### 
+1. 힌들리-밀너 타입 추론은 하스캘과 오캐멀 언어 예제만 책에 소개되었는데. 하당 타입 추론 방식을 다른 언어에서는 잘 활용하지 않는 것으로 보인다. 그렇다면 그 이유는 무엇일까? 
+