// 순수함수 - 같은 입력에 항상 같은 출력
func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

// 순수함수 - 외부 상태에 의존하지 않음
func multiply(_ numbers: [Int], by factor: Int) -> [Int] {
    return numbers.map { $0 * factor }
}

// 순수함수 - 불변 데이터 구조 사용
func updateUser(name: String, in user: User) -> User {
    return User(name: name, age: user.age, email: user.email)
}

// 사용 예시
let result1 = add(3, 5)  // 항상 8
let result2 = add(3, 5)  // 항상 8
print(result1 == result2)  // true

let numbers = [1, 2, 3, 4, 5]
let doubled = multiply(numbers, by: 2)
print(numbers)   // [1, 2, 3, 4, 5] - 원본 유지
print(doubled)   // [2, 4, 6, 8, 10] - 새로운 배열

// 비순수함수 - 전역 상태에 의존
var globalCounter = 0

func incrementCounter() -> Int {
    globalCounter += 1  // 외부 상태 변경!
    return globalCounter
}

// 비순수함수 - 외부 상태 변경
var users: [User] = []

func addUser(_ user: User) {
    users.append(user)  // 외부 배열 변경!
}

// 비순수함수 - 랜덤 값 반환
func getRandomNumber() -> Int {
    return Int.random(in: 1...100)  // 매번 다른 값!
}

// 비순수함수 - 현재 시간 의존
func getCurrentTimestamp() -> Date {
    return Date()  // 호출 시점마다 다른 값!
}

// 문제점 확인
let count1 = incrementCounter()  // 1
let count2 = incrementCounter()  // 2 - 같은 입력(없음)인데 다른 출력!
print(count1 == count2)  // false - 예측 불가능!

// 순수함수로 변환
func increment(_ counter: Int) -> Int {
    return counter + 1
}

func addUser(_ user: User, to users: [User]) -> [User] {
    var newUsers = users
    newUsers.append(user)
    return newUsers
}

// 더 나은 방법 - 배열 복사 없이
func addUser(_ user: User, to users: [User]) -> [User] {
    return users + [user]
}

// 사용 예시
var counter = 0
counter = increment(counter)  // 1
counter = increment(counter)  // 2

var userList: [User] = []
userList = addUser(newUser, to: userList)
// 원본 userList는 변경되지 않고, 새로운 배열이 반환됨

// 불변 변수 선언
let immutableNumber = 42
// immutableNumber = 43  // 컴파일 에러!

let immutableArray = [1, 2, 3, 4, 5]
// immutableArray.append(6)  // 컴파일 에러!

// 가변 변수
var mutableNumber = 42
mutableNumber = 43  // OK

var mutableArray = [1, 2, 3, 4, 5]
mutableArray.append(6)  // OK

// 구조체를 활용한 불변 데이터 모델
struct User {
    let id: Int
    let name: String
    let email: String
    let age: Int
}

// 불변 인스턴스
let user = User(id: 1, name: "김철수", email: "kim@example.com", age: 25)
// user.name = "이영희"  // 컴파일 에러!

// 값을 변경하려면 새 인스턴스 생성
let updatedUser = User(
    id: user.id,
    name: "이영희",
    email: user.email,
    age: user.age
)

print(user.name)         // "김철수" - 원본 유지
print(updatedUser.name)  // "이영희" - 새로운 인스턴스

// 1. 단순 복사 패턴
struct Point {
    let x: Double
    let y: Double
    
    func moved(dx: Double, dy: Double) -> Point {
        return Point(x: x + dx, y: y + dy)
    }
}

let point1 = Point(x: 10, y: 20)
let point2 = point1.moved(dx: 5, dy: 3)

print(point1)  // Point(x: 10, y: 20) - 원본 유지
print(point2)  // Point(x: 15, y: 23) - 새로운 인스턴스

// 2. 빌더 패턴 활용
struct UserProfile {
    let name: String
    let age: Int
    let email: String
    let phoneNumber: String?
    let address: String?
    
    func with(name: String? = nil,
              age: Int? = nil,
              email: String? = nil,
              phoneNumber: String? = nil,
              address: String? = nil) -> UserProfile {
        return UserProfile(
            name: name ?? self.name,
            age: age ?? self.age,
            email: email ?? self.email,
            phoneNumber: phoneNumber ?? self.phoneNumber,
            address: address ?? self.address
        )
    }
}

let profile = UserProfile(
    name: "김철수",
    age: 30,
    email: "kim@example.com",
    phoneNumber: nil,
    address: nil
)

// 일부 필드만 업데이트
let updatedProfile = profile.with(age: 31, phoneNumber: "010-1234-5678")

print(profile.age)          // 30 - 원본 유지
print(updatedProfile.age)   // 31 - 새로운 인스턴스

// 3. 컬렉션 업데이트 패턴
let numbers = [1, 2, 3, 4, 5]

// 요소 추가 (새 배열 반환)
let withSix = numbers + [6]

// 요소 제거 (새 배열 반환)
let withoutFirst = Array(numbers.dropFirst())

// 요소 변경 (새 배열 반환)
let doubled = numbers.map { $0 * 2 }

print(numbers)       // [1, 2, 3, 4, 5] - 원본 유지
print(withSix)       // [1, 2, 3, 4, 5, 6]
print(withoutFirst)  // [2, 3, 4, 5]
print(doubled)       // [2, 4, 6, 8, 10]

// 클래스 - 참조 타입
class MutableUser {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

let user1 = MutableUser(name: "김철수", age: 25)
user1.name = "이영희"  // let인데도 변경 가능! (참조는 불변, 내용은 가변)

// 구조체 - 값 타입
struct ImmutableUser {
    let name: String
    let age: Int
}

let user2 = ImmutableUser(name: "김철수", age: 25)
// user2.name = "이영희"  // 컴파일 에러! 진정한 불변성

// 기본 map 사용
let numbers = [1, 2, 3, 4, 5]
let squared = numbers.map { $0 * $0 }
print(squared)  // [1, 4, 9, 16, 25]

// 타입 변환
let strings = numbers.map { String($0) }
print(strings)  // ["1", "2", "3", "4", "5"]

// 복잡한 객체 변환
struct Product {
    let name: String
    let price: Double
}

let products = [
    Product(name: "사과", price: 1000),
    Product(name: "바나나", price: 1500),
    Product(name: "오렌지", price: 2000)
]

// 가격만 추출
let prices = products.map { $0.price }
print(prices)  // [1000.0, 1500.0, 2000.0]

// 할인가 계산
let discountedPrices = products.map { $0.price * 0.9 }
print(discountedPrices)  // [900.0, 1350.0, 1800.0]

// 새로운 구조체 생성
struct DiscountedProduct {
    let name: String
    let originalPrice: Double
    let discountedPrice: Double
}

let discountedProducts = products.map { product in
    DiscountedProduct(
        name: product.name,
        originalPrice: product.price,
        discountedPrice: product.price * 0.9
    )
}

// 명령형 스타일과 비교
var squaredImperative: [Int] = []
for number in numbers {
    squaredImperative.append(number * number)
}
// vs
let squaredFunctional = numbers.map { $0 * $0 }
// 함수형이 훨씬 간결하고 의도가 명확해!

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// 짝수만 필터링
let evenNumbers = numbers.filter { $0 % 2 == 0 }
print(evenNumbers)  // [2, 4, 6, 8, 10]

// 5보다 큰 수
let greaterThanFive = numbers.filter { $0 > 5 }
print(greaterThanFive)  // [6, 7, 8, 9, 10]

// 복잡한 조건
struct User {
    let name: String
    let age: Int
    let isActive: Bool
}

let users = [
    User(name: "김철수", age: 25, isActive: true),
    User(name: "이영희", age: 17, isActive: true),
    User(name: "박민수", age: 30, isActive: false),
    User(name: "정수진", age: 22, isActive: true)
]

// 성인이면서 활성 사용자만
let activeAdults = users.filter { $0.age >= 18 && $0.isActive }
print(activeAdults.map { $0.name })  // ["김철수", "정수진"]

// 명령형 스타일과 비교
var evenNumbersImperative: [Int] = []
for number in numbers {
    if number % 2 == 0 {
        evenNumbersImperative.append(number)
    }
}
// vs
let evenNumbersFunctional = numbers.filter { $0 % 2 == 0 }
// 역시 함수형이 더 간결!

let numbers = [1, 2, 3, 4, 5]

// 합계 계산
let sum = numbers.reduce(0) { $0 + $1 }
print(sum)  // 15

// 더 간단하게
let sum2 = numbers.reduce(0, +)
print(sum2)  // 15

// 곱셈
let product = numbers.reduce(1, *)
print(product)  // 120

// 문자열 결합
let words = ["Hello", "Swift", "World"]
let sentence = words.reduce("") { $0 + " " + $1 }
print(sentence)  // " Hello Swift World"

// 더 나은 방법
let sentence2 = words.reduce("") { result, word in
    result.isEmpty ? word : result + " " + word
}
print(sentence2)  // "Hello Swift World"

// 복잡한 집계
struct Transaction {
    let amount: Double
    let type: String  // "income" or "expense"
}

let transactions = [
    Transaction(amount: 1000, type: "income"),
    Transaction(amount: 500, type: "expense"),
    Transaction(amount: 2000, type: "income"),
    Transaction(amount: 300, type: "expense")
]

// 순수익 계산
let netIncome = transactions.reduce(0.0) { result, transaction in
    transaction.type == "income" ? result + transaction.amount : result - transaction.amount
}
print(netIncome)  // 2200.0

// 딕셔너리로 그룹화
let grouped = transactions.reduce(into: [String: Double]()) { result, transaction in
    result[transaction.type, default: 0] += transaction.amount
}
print(grouped)  // ["income": 3000.0, "expense": 800.0]

let strings = ["1", "2", "three", "4", "five", "6"]

// 문자열을 Int로 변환 (실패하면 nil)
let numbers = strings.compactMap { Int($0) }
print(numbers)  // [1, 2, 4, 6] - nil이 자동으로 제거됨!

// map을 사용하면?
let numbersWithNil = strings.map { Int($0) }
print(numbersWithNil)  // [Optional(1), Optional(2), nil, Optional(4), nil, Optional(6)]

// 옵셔널 체이닝과 함께
struct Person {
    let name: String
    let email: String?
}

let people = [
    Person(name: "김철수", email: "kim@example.com"),
    Person(name: "이영희", email: nil),
    Person(name: "박민수", email: "park@example.com"),
    Person(name: "정수진", email: nil)
]

// 이메일이 있는 사람만
let emails = people.compactMap { $0.email }
print(emails)  // ["kim@example.com", "park@example.com"]

// 복잡한 변환
let validEmails = people.compactMap { person -> String? in
    guard let email = person.email,
          email.contains("@") else {
        return nil
    }
    return email.lowercased()
}
print(validEmails)  // ["kim@example.com", "park@example.com"]

// 2차원 배열 평탄화
let nestedNumbers = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
let flattened = nestedNumbers.flatMap { $0 }
print(flattened)  // [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 문자열 배열을 문자 배열로
let words = ["Hello", "Swift"]
let characters = words.flatMap { $0 }
print(characters)  // ["H", "e", "l", "l", "o", "S", "w", "i", "f", "t"]

// 복잡한 예제
struct Department {
    let name: String
    let employees: [String]
}

let departments = [
    Department(name: "개발팀", employees: ["김철수", "이영희"]),
    Department(name: "디자인팀", employees: ["박민수"]),
    Department(name: "마케팅팀", employees: ["정수진", "최영수", "한지민"])
]

// 모든 직원 이름 추출
let allEmployees = departments.flatMap { $0.employees }
print(allEmployees)  // ["김철수", "이영희", "박민수", "정수진", "최영수", "한지민"]

// 옵셔널과 함께 사용 (Swift 4.1 이후 compactMap 권장)
let optionalNumbers: [Int?] = [1, 2, nil, 4, nil, 6]
let validNumbers = optionalNumbers.compactMap { $0 }
print(validNumbers)  // [1, 2, 4, 6]

struct Product {
    let name: String
    let price: Double
    let category: String
    let inStock: Bool
}

let products = [
    Product(name: "맥북", price: 2000000, category: "전자제품", inStock: true),
    Product(name: "아이패드", price: 800000, category: "전자제품", inStock: false),
    Product(name: "책상", price: 150000, category: "가구", inStock: true),
    Product(name: "의자", price: 200000, category: "가구", inStock: true),
    Product(name: "아이폰", price: 1200000, category: "전자제품", inStock: true)
]

// 재고가 있는 전자제품의 총 가격
let totalElectronicsPrice = products
    .filter { $0.category == "전자제품" && $0.inStock }  // 전자제품 + 재고 있음
    .map { $0.price }                                      // 가격만 추출
    .reduce(0, +)                                          // 합계

print(totalElectronicsPrice)  // 3200000

// 카테고리별 평균 가격
let averagePriceByCategory = Dictionary(grouping: products, by: { $0.category })
    .mapValues { products in
        products.map { $0.price }.reduce(0, +) / Double(products.count)
    }

print(averagePriceByCategory)
// ["전자제품": 1333333.33, "가구": 175000.0]

// 재고 있는 상품 이름들을 쉼표로 연결
let availableProducts = products
    .filter { $0.inStock }
    .map { $0.name }
    .joined(separator: ", ")

print(availableProducts)  // "맥북, 책상, 의자, 아이폰"

// 기본 예제
func applyOperation(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
    return operation(a, b)
}

// 사용
let sum = applyOperation(5, 3, operation: { $0 + $1 })
print(sum)  // 8

let product = applyOperation(5, 3, operation: { $0 * $1 })
print(product)  // 15

// 더 간단하게
let sum2 = applyOperation(5, 3, operation: +)
let product2 = applyOperation(5, 3, operation: *)

// 실용적인 예제
func processArray(_ array: [Int], with processor: (Int) -> Int) -> [Int] {
    return array.map(processor)
}

let numbers = [1, 2, 3, 4, 5]
let doubled = processArray(numbers) { $0 * 2 }
let squared = processArray(numbers) { $0 * $0 }

print(doubled)  // [2, 4, 6, 8, 10]
print(squared)  // [1, 4, 9, 16, 25]

// 조건부 처리
func filterAndTransform<t, u="">(_ array: [T], 
                               filter: (T) -> Bool,
                               transform: (T) -> U) -> [U] {
    return array.filter(filter).map(transform)
}

let evenSquares = filterAndTransform(numbers,
                                      filter: { $0 % 2 == 0 },
                                      transform: { $0 * $0 })
print(evenSquares)  // [4, 16]</t,>

// 기본 예제
func makeMultiplier(factor: Int) -> (Int) -> Int {
    return { number in
        return number * factor
    }
}

let double = makeMultiplier(factor: 2)
let triple = makeMultiplier(factor: 3)

print(double(5))  // 10
print(triple(5))  // 15

// 더 복잡한 예제
func makeValidator(minLength: Int, maxLength: Int) -> (String) -> Bool {
    return { text in
        return text.count >= minLength && text.count <= maxLength
    }
}

let isValidUsername = makeValidator(minLength: 3, maxLength: 20)
let isValidPassword = makeValidator(minLength: 8, maxLength: 50)

print(isValidUsername("kim"))      // true
print(isValidUsername("ab"))       // false
print(isValidPassword("12345"))    // false
print(isValidPassword("12345678")) // true

// 클로저 캡처를 활용한 카운터
func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}

let counter1 = makeCounter()
let counter2 = makeCounter()

print(counter1())  // 1
print(counter1())  // 2
print(counter1())  // 3
print(counter2())  // 1 - 독립적인 카운터
print(counter2())  // 2

// 함수 조합
func compose<a, b,="" c="">(_ f: @escaping (B) -> C, _ g: @escaping (A) -> B) -> (A) -> C {
    return { x in
        f(g(x))
    }
}

let addOne: (Int) -> Int = { $0 + 1 }
let multiplyByTwo: (Int) -> Int = { $0 * 2 }

let addOneThenMultiply = compose(multiplyByTwo, addOne)
print(addOneThenMultiply(5))  // (5 + 1) * 2 = 12</a,>

// 일반 함수
func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

// 커링된 함수
func curriedAdd(_ a: Int) -> (Int) -> Int {
    return { b in
        return a + b
    }
}

// 사용
let add5 = curriedAdd(5)
print(add5(3))   // 8
print(add5(10))  // 15

// 실용적인 예제
func makeGreeting(_ greeting: String) -> (String) -> String {
    return { name in
        return "\(greeting), \(name)!"
    }
}

let sayHello = makeGreeting("안녕하세요")
let sayGoodbye = makeGreeting("안녕히 가세요")

print(sayHello("김철수"))      // "안녕하세요, 김철수!"
print(sayGoodbye("이영희"))    // "안녕히 가세요, 이영희!"

// 더 복잡한 커링
func multiply(_ a: Int) -> (Int) -> (Int) -> Int {
    return { b in
        return { c in
            return a * b * c
        }
    }
}

let result = multiply(2)(3)(4)
print(result)  // 24

// 부분 적용
let multiplyBy2 = multiply(2)
let multiplyBy2And3 = multiplyBy2(3)
print(multiplyBy2And3(4))  // 24

// 나쁜 예: 가변 상태
class MutableShoppingCart {
    var items: [Product] = []
    var totalPrice: Double = 0
    
    func addItem(_ product: Product) {
        items.append(product)
        totalPrice += product.price
    }
    
    func removeItem(at index: Int) {
        let product = items.remove(at: index)
        totalPrice -= product.price
    }
}

// 좋은 예: 불변 상태
struct Product {
    let id: String
    let name: String
    let price: Double
}

struct ShoppingCart {
    let items: [Product]
    
    var totalPrice: Double {
        items.reduce(0) { $0 + $1.price }
    }
    
    var itemCount: Int {
        items.count
    }
    
    func adding(_ product: Product) -> ShoppingCart {
        return ShoppingCart(items: items + [product])
    }
    
    func removing(at index: Int) -> ShoppingCart {
        var newItems = items
        newItems.remove(at: index)
        return ShoppingCart(items: newItems)
    }
    
    func removingProduct(withId id: String) -> ShoppingCart {
        let newItems = items.filter { $0.id != id }
        return ShoppingCart(items: newItems)
    }
    
    func applyingDiscount(_ percentage: Double) -> ShoppingCart {
        let discountedItems = items.map { product in
            Product(id: product.id,
                   name: product.name,
                   price: product.price * (1 - percentage / 100))
        }
        return ShoppingCart(items: discountedItems)
    }
}

// 사용
let emptyCart = ShoppingCart(items: [])
let product1 = Product(id: "1", name: "맥북", price: 2000000)
let product2 = Product(id: "2", name: "아이패드", price: 800000)

let cart1 = emptyCart.adding(product1)
let cart2 = cart1.adding(product2)
let discountedCart = cart2.applyingDiscount(10)

print(cart1.totalPrice)        // 2000000
print(cart2.totalPrice)        // 2800000
print(discountedCart.totalPrice) // 2520000

// 원본은 변하지 않음!
print(emptyCart.itemCount)  // 0
print(cart1.itemCount)      // 1
print(cart2.itemCount)      // 2

// 사용자 데이터 처리 파이프라인
struct User {
    let id: Int
    let name: String
    let email: String
    let age: Int
    let isActive: Bool
}

struct UserViewModel {
    let displayName: String
    let email: String
    let statusText: String
}

// 순수 함수들로 구성된 변환 파이프라인
func filterActiveAdults(_ users: [User]) -> [User] {
    return users.filter { $0.isActive && $0.age >= 18 }
}

func sortByName(_ users: [User]) -> [User] {
    return users.sorted { $0.name < $1.name }
}

func toViewModels(_ users: [User]) -> [UserViewModel] {
    return users.map { user in
        UserViewModel(
            displayName: user.name,
            email: user.email,
            statusText: user.isActive ? "활성" : "비활성"
        )
    }
}

// 파이프라인 조합
func processUsers(_ users: [User]) -> [UserViewModel] {
    return toViewModels(sortByName(filterActiveAdults(users)))
}

// 더 나은 방법: 커스텀 연산자
infix operator |> : AdditionPrecedence

func |> <t, u="">(value: T, function: (T) -> U) -> U {
    return function(value)
}

// 사용
let users = [
    User(id: 1, name: "김철수", email: "kim@example.com", age: 25, isActive: true),
    User(id: 2, name: "이영희", email: "lee@example.com", age: 17, isActive: true),
    User(id: 3, name: "박민수", email: "park@example.com", age: 30, isActive: false),
    User(id: 4, name: "정수진", email: "jung@example.com", age: 22, isActive: true)
]

let viewModels = users
    |> filterActiveAdults
    |> sortByName
    |> toViewModels

print(viewModels.map { $0.displayName })  // ["김철수", "정수진"]</t,>

// 순수 함수형 에러 처리
enum ValidationError: Error {
    case emptyName
    case invalidEmail
    case ageTooYoung
    case ageTooOld
}

struct UserInput {
    let name: String
    let email: String
    let age: Int
}

// 각 검증을 순수 함수로
func validateName(_ name: String) -> Result<string, validationerror=""> {
    guard !name.isEmpty else {
        return .failure(.emptyName)
    }
    return .success(name)
}

func validateEmail(_ email: String) -> Result<string, validationerror=""> {
    guard email.contains("@") && email.contains(".") else {
        return .failure(.invalidEmail)
    }
    return .success(email)
}

func validateAge(_ age: Int) -> Result<int, validationerror=""> {
    guard age >= 18 else {
        return .failure(.ageTooYoung)
    }
    guard age <= 120 else {
        return .failure(.ageTooOld)
    }
    return .success(age)
}

// 검증 조합
func validateUser(_ input: UserInput) -> Result<user, validationerror=""> {
    let nameResult = validateName(input.name)
    let emailResult = validateEmail(input.email)
    let ageResult = validateAge(input.age)
    
    // 모든 검증이 성공해야 User 생성
    switch (nameResult, emailResult, ageResult) {
    case (.success(let name), .success(let email), .success(let age)):
        return .success(User(id: 0, name: name, email: email, age: age, isActive: true))
    case (.failure(let error), _, _),
         (_, .failure(let error), _),
         (_, _, .failure(let error)):
        return .failure(error)
    }
}

// 사용
let input1 = UserInput(name: "김철수", email: "kim@example.com", age: 25)
let result1 = validateUser(input1)

switch result1 {
case .success(let user):
    print("사용자 생성 성공: \(user.name)")
case .failure(let error):
    print("검증 실패: \(error)")
}

let input2 = UserInput(name: "", email: "invalid", age: 15)
let result2 = validateUser(input2)

switch result2 {
case .success(let user):
    print("사용자 생성 성공: \(user.name)")
case .failure(let error):
    print("검증 실패: \(error)")  // "검증 실패: emptyName"
}</user,></int,></string,></string,>

import XCTest

// 테스트할 순수 함수들
func calculateDiscount(price: Double, percentage: Double) -> Double {
    return price * (1 - percentage / 100)
}

func isValidEmail(_ email: String) -> Bool {
    return email.contains("@") && email.contains(".")
}

func filterAdults(_ users: [User]) -> [User] {
    return users.filter { $0.age >= 18 }
}

// 테스트 코드
class FunctionalProgrammingTests: XCTestCase {
    
    // 순수 함수는 테스트가 정말 쉬워!
    func testCalculateDiscount() {
        // Given
        let price = 10000.0
        let percentage = 10.0
        
        // When
        let result = calculateDiscount(price: price, percentage: percentage)
        
        // Then
        XCTAssertEqual(result, 9000.0)
    }
    
    func testIsValidEmail() {
        // 여러 케이스를 간단하게 테스트
        XCTAssertTrue(isValidEmail("test@example.com"))
        XCTAssertFalse(isValidEmail("invalid"))
        XCTAssertFalse(isValidEmail("@example.com"))
        XCTAssertFalse(isValidEmail("test@"))
    }
    
    func testFilterAdults() {
        // Given
        let users = [
            User(id: 1, name: "김철수", email: "kim@example.com", age: 25, isActive: true),
            User(id: 2, name: "이영희", email: "lee@example.com", age: 17, isActive: true),
            User(id: 3, name: "박민수", email: "park@example.com", age: 30, isActive: true)
        ]
        
        // When
        let adults = filterAdults(users)
        
        // Then
        XCTAssertEqual(adults.count, 2)
        XCTAssertTrue(adults.allSatisfy { $0.age >= 18 })
    }
    
    // 불변 데이터 구조 테스트
    func testShoppingCartImmutability() {
        // Given
        let product = Product(id: "1", name: "맥북", price: 2000000)
        let emptyCart = ShoppingCart(items: [])
        
        // When
        let cart1 = emptyCart.adding(product)
        let cart2 = cart1.adding(product)
        
        // Then
        XCTAssertEqual(emptyCart.itemCount, 0)  // 원본 유지
        XCTAssertEqual(cart1.itemCount, 1)
        XCTAssertEqual(cart2.itemCount, 2)
        XCTAssertEqual(cart2.totalPrice, 4000000)
    }
}

// 프로퍼티 기반 테스트 (Property-Based Testing)
func testMapPreservesLength() {
    let numbers = [1, 2, 3, 4, 5]
    let doubled = numbers.map { $0 * 2 }
    
    // map은 길이를 보존해야 함
    XCTAssertEqual(numbers.count, doubled.count)
}

func testFilterReducesOrMaintainsLength() {
    let numbers = [1, 2, 3, 4, 5]
    let evens = numbers.filter { $0 % 2 == 0 }
    
    // filter는 길이를 줄이거나 유지해야 함
    XCTAssertLessThanOrEqual(evens.count, numbers.count)
}

// 일반 배열 연산 - 즉시 평가
let numbers = Array(1...1000000)

let result1 = numbers
    .map { $0 * 2 }        // 백만 개 처리
    .filter { $0 > 100 }   // 백만 개 처리
    .prefix(10)            // 10개만 필요한데...

// Lazy 평가 - 필요한 만큼만 처리
let result2 = numbers.lazy
    .map { $0 * 2 }        // 필요한 만큼만 처리
    .filter { $0 > 100 }   // 필요한 만큼만 처리
    .prefix(10)            // 10개만 처리하고 중단!

// 성능 비교
import Foundation

func measureTime(_ closure: () -> Void) {
    let start = Date()
    closure()
    let end = Date()
    print("실행 시간: \(end.timeIntervalSince(start))초")
}

measureTime {
    let _ = numbers
        .map { $0 * 2 }
        .filter { $0 > 100 }
        .prefix(10)
}
// 실행 시간: 약 0.5초

measureTime {
    let _ = Array(numbers.lazy
        .map { $0 * 2 }
        .filter { $0 > 100 }
        .prefix(10))
}
// 실행 시간: 약 0.001초 - 500배 빠름!

// Lazy의 주의사항
let lazyResult = numbers.lazy.map { $0 * 2 }
// 아직 계산되지 않음!

let array = Array(lazyResult)
// 이제 계산됨!

// 비효율적 - 매번 새 배열 생성
func inefficientAppend(_ array: [Int], _ element: Int) -> [Int] {
    var newArray = array  // 복사!
    newArray.append(element)
    return newArray
}

// 더 나은 방법 - 배열 연결 연산자
func efficientAppend(_ array: [Int], _ element: Int) -> [Int] {
    return array + [element]  // 최적화됨
}

// 여러 요소 추가할 때
let numbers = [1, 2, 3]

// 비효율적
var result1 = numbers
result1 = efficientAppend(result1, 4)
result1 = efficientAppend(result1, 5)
result1 = efficientAppend(result1, 6)

// 효율적
let result2 = numbers + [4, 5, 6]

// reduce(into:) 사용 - 가변 누산기
let sum = numbers.reduce(into: 0) { result, number in
    result += number  // 복사 없이 누산기 변경
}

// 딕셔너리 그룹화 최적화
struct Product {
    let category: String
    let name: String
}

let products = [
    Product(category: "전자제품", name: "맥북"),
    Product(category: "전자제품", name: "아이패드"),
    Product(category: "가구", name: "책상")
]

// 비효율적
let grouped1 = products.reduce([String: [Product]]()) { result, product in
    var newResult = result  // 매번 복사!
    newResult[product.category, default: []].append(product)
    return newResult
}

// 효율적 - reduce(into:)
let grouped2 = products.reduce(into: [String: [Product]]()) { result, product in
    result[product.category, default: []].append(product)  // 복사 없음!
}

// 비효율적인 재귀 함수
func fibonacci(_ n: Int) -> Int {
    if n <= 1 { return n }
    return fibonacci(n - 1) + fibonacci(n - 2)
}

// fibonacci(40) 호출 시 약 2초 소요...

// 메모이제이션 적용
class Memoizer<input: hashable,="" output=""> {
    private var cache: [Input: Output] = [:]
    private let function: (Input) -> Output
    
    init(_ function: @escaping (Input) -> Output) {
        self.function = function
    }
    
    func callAsFunction(_ input: Input) -> Output {
        if let cached = cache[input] {
            return cached
        }
        let result = function(input)
        cache[input] = result
        return result
    }
}

// 사용
let memoizedFib = Memoizer<int, int=""> { n in
    if n <= 1 { return n }
    return memoizedFib(n - 1) + memoizedFib(n - 2)
}

// fibonacci(40) 호출 시 약 0.001초 - 2000배 빠름!

// 실용적인 예제
struct ExpensiveCalculation {
    static let memoized = Memoizer<string, string=""> { input in
        // 복잡한 계산...
        Thread.sleep(forTimeInterval: 1)  // 1초 걸리는 작업
        return input.uppercased()
    }
}

// 첫 호출: 1초
let result1 = ExpensiveCalculation.memoized("hello")

// 두 번째 호출: 즉시 반환!
let result2 = ExpensiveCalculation.memoized("hello")</string,></int,></input:>

// 1. 불변 데이터 모델
struct Todo {
    let id: UUID
    let title: String
    let description: String
    let isCompleted: Bool
    let createdAt: Date
    let priority: Priority
    
    enum Priority: Int, Comparable {
        case low = 0
        case medium = 1
        case high = 2
        
        static func < (lhs: Priority, rhs: Priority) -> Bool {
            return lhs.rawValue < rhs.rawValue
        }
    }
}

// 2. 상태 관리
struct TodoState {
    let todos: [Todo]
    let filter: TodoFilter
    
    enum TodoFilter {
        case all
        case active
        case completed
    }
    
    // 필터링된 할 일 목록
    var filteredTodos: [Todo] {
        switch filter {
        case .all:
            return todos
        case .active:
            return todos.filter { !$0.isCompleted }
        case .completed:
            return todos.filter { $0.isCompleted }
        }
    }
    
    // 통계
    var statistics: Statistics {
        Statistics(
            total: todos.count,
            completed: todos.filter { $0.isCompleted }.count,
            active: todos.filter { !$0.isCompleted }.count
        )
    }
    
    struct Statistics {
        let total: Int
        let completed: Int
        let active: Int
        
        var completionRate: Double {
            guard total > 0 else { return 0 }
            return Double(completed) / Double(total) * 100
        }
    }
}

// 3. 순수 함수로 상태 변경
extension TodoState {
    func adding(_ todo: Todo) -> TodoState {
        return TodoState(todos: todos + [todo], filter: filter)
    }
    
    func removing(id: UUID) -> TodoState {
        let newTodos = todos.filter { $0.id != id }
        return TodoState(todos: newTodos, filter: filter)
    }
    
    func toggling(id: UUID) -> TodoState {
        let newTodos = todos.map { todo in
            guard todo.id == id else { return todo }
            return Todo(
                id: todo.id,
                title: todo.title,
                description: todo.description,
                isCompleted: !todo.isCompleted,
                createdAt: todo.createdAt,
                priority: todo.priority
            )
        }
        return TodoState(todos: newTodos, filter: filter)
    }
    
    func updating(id: UUID, title: String, description: String, priority: Todo.Priority) -> TodoState {
        let newTodos = todos.map { todo in
            guard todo.id == id else { return todo }
            return Todo(
                id: todo.id,
                title: title,
                description: description,
                isCompleted: todo.isCompleted,
                createdAt: todo.createdAt,
                priority: priority
            )
        }
        return TodoState(todos: newTodos, filter: filter)
    }
    
    func changingFilter(to newFilter: TodoFilter) -> TodoState {
        return TodoState(todos: todos, filter: newFilter)
    }
    
    func sortedByPriority() -> TodoState {
        let sortedTodos = todos.sorted { $0.priority > $1.priority }
        return TodoState(todos: sortedTodos, filter: filter)
    }
    
    func sortedByDate() -> TodoState {
        let sortedTodos = todos.sorted { $0.createdAt > $1.createdAt }
        return TodoState(todos: sortedTodos, filter: filter)
    }
}

// 4. 사용 예제
var state = TodoState(todos: [], filter: .all)

// 할 일 추가
let todo1 = Todo(
    id: UUID(),
    title: "스위프트 공부하기",
    description: "함수형 프로그래밍 마스터",
    isCompleted: false,
    createdAt: Date(),
    priority: .high
)

state = state.adding(todo1)

let todo2 = Todo(
    id: UUID(),
    title: "장보기",
    description: "우유, 빵, 계란",
    isCompleted: false,
    createdAt: Date(),
    priority: .medium
)

state = state.adding(todo2)

// 할 일 완료
state = state.toggling(id: todo1.id)

// 필터 변경
state = state.changingFilter(to: .active)

// 통계 확인
let stats = state.statistics
print("전체: \(stats.total), 완료: \(stats.completed), 진행중: \(stats.active)")
print("완료율: \(stats.completionRate)%")

// 우선순위로 정렬
state = state.sortedByPriority()

// 5. 고급 기능 - 검색
extension TodoState {
    func searching(query: String) -> TodoState {
        guard !query.isEmpty else { return self }
        
        let searchResults = todos.filter { todo in
            todo.title.localizedCaseInsensitiveContains(query) ||
            todo.description.localizedCaseInsensitiveContains(query)
        }
        
        return TodoState(todos: searchResults, filter: filter)
    }
}

// 6. 고급 기능 - 일괄 작업
extension TodoState {
    func completingAll() -> TodoState {
        let completedTodos = todos.map { todo in
            Todo(
                id: todo.id,
                title: todo.title,
                description: todo.description,
                isCompleted: true,
                createdAt: todo.createdAt,
                priority: todo.priority
            )
        }
        return TodoState(todos: completedTodos, filter: filter)
    }
    
    func removingCompleted() -> TodoState {
        let activeTodos = todos.filter { !$0.isCompleted }
        return TodoState(todos: activeTodos, filter: filter)
    }
}

// 하이브리드 접근법 - 둘 다 활용!

// 1. 불변 데이터 모델 (함수형)
struct User {
    let id: Int
    let name: String
    let email: String
}

// 2. 순수 함수로 비즈니스 로직 (함수형)
func validateUser(_ user: User) -> Result<user, validationerror=""> {
    // 검증 로직...
    return .success(user)
}

func transformToViewModel(_ user: User) -> UserViewModel {
    return UserViewModel(displayName: user.name, email: user.email)
}

// 3. 클래스로 상태 관리 (객체지향)
class UserManager {
    private var users: [User] = []
    
    // 함수형 스타일의 메서드
    func addUser(_ user: User) -> Result<void, error=""> {
        return validateUser(user).map { validUser in
            self.users.append(validUser)
        }
    }
    
    func getUsers(matching predicate: (User) -> Bool) -> [User] {
        return users.filter(predicate)
    }
    
    func transformUsers<t>(_ transform: (User) -> T) -> [T] {
        return users.map(transform)
    }
}

// 4. SwiftUI 뷰 (선언적 + 함수형)
struct UserListView: View {
    let users: [User]
    
    var body: some View {
        List(users, id: \.id) { user in
            UserRow(user: user)
        }
    }
}

// 최고의 조합: 각 패러다임의 장점을 활용!</t></void,></user,>

// 과도하게 함수형 - 읽기 어려움
let result = users
    .filter { $0.age >= 18 }
    .map { ($0.name, $0.email) }
    .reduce(into: [String: String]()) { $0[$1.0] = $1.1 }

// 더 나은 방법 - 의도가 명확
let adultUsers = users.filter { $0.age >= 18 }
let emailMap = Dictionary(
    uniqueKeysWithValues: adultUsers.map { ($0.name, $0.email) }
)

/// 사용자 목록을 필터링하고 변환합니다.
/// - Parameters:
///   - users: 필터링할 사용자 배열
///   - predicate: 필터링 조건
///   - transform: 변환 함수
/// - Returns: 변환된 결과 배열
func processUsers<t>(
    _ users: [User],
    filter predicate: (User) -> Bool,
    transform: (User) -> T
) -> [T] {
    return users
        .filter(predicate)
        .map(transform)
}</t>