Day 13 · 2부 · 동시성과 측정 — MainActor·Sendable·signpost

struct Fact: Equatable, Sendable {
  var number: Int
  var text: String
}

@Reducer
struct FactFeature {
  @ObservableState
  struct State: Equatable {
    var number = 0
    var fact: Fact?
    var isLoading = false
  }
  enum Action { case factButtonTapped, factResponse(Fact) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .factButtonTapped:
        state.isLoading = true                       // main actor: 상태 변경
        return .run { [number = state.number] send in
          try await Task.sleep(for: .milliseconds(300))   // 풀: 기다림
          let fact = Fact(number: number, text: "\(number)은 좋은 숫자다")
          await send(.factResponse(fact), animation: .default)   // main actor로 복귀
        }
      case let .factResponse(fact):
        state.isLoading = false
        state.fact = fact
        return .none
      }
    }
  }
}

case .buttonTapped:
  return .run { send in
    try await Task.sleep(for: .seconds(1))
    await send(.delayed(state.count))
  }

@Reducer
struct DelayFeature {
  @ObservableState
  struct State: Equatable { var count = 0 }
  enum Action { case buttonTapped, delayed(Int) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .buttonTapped:
        return .run { [count = state.count] send in      // 이 시점 값의 복사본
          try await Task.sleep(for: .seconds(1))
          await send(.delayed(count))
        }
      case .delayed:
        return .none
      }
    }
  }
}

struct FactClient {
  var fetch: (Int) async throws -> String
}

actor ImageCache {
  private var storage: [URL: Data] = [:]
  func data(for url: URL) -> Data? { storage[url] }
  func insert(_ data: Data, for url: URL) { storage[url] = data }
}

@DependencyClient
struct ImageClient: Sendable {
  var load: @Sendable (_ url: URL) async throws -> Data
}

extension ImageClient: DependencyKey {
  static let liveValue: ImageClient = {
    let cache = ImageCache()                   // actor는 Sendable — 클로저가 캡처해도 된다
    return ImageClient(load: { url in
      if let hit = await cache.data(for: url) { return hit }
      let (data, _) = try await URLSession.shared.data(from: url)
      await cache.insert(data, for: url)
      return data
    })
  }()
}

extension DependencyValues {
  var imageClient: ImageClient {
    get { self[ImageClient.self] }
    set { self[ImageClient.self] = newValue }
  }
}

@Reducer
struct ClockFeature {
  @ObservableState
  struct State: Equatable { var ticks = 0 }
  enum Action { case onAppear, tick(Date) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .onAppear:
        return .publisher {
          Timer.publish(every: 1, on: .main, in: .common)
            .autoconnect()
            .map { .tick($0) }            // .map(Action.tick) 대신
        }
      case .tick:
        state.ticks += 1
        return .none
      }
    }
  }
}

@Reducer
struct AppFeature {
  @ObservableState
  struct State: Equatable {
    var fact = FactFeature.State()
  }
  enum Action { case fact(FactFeature.Action) }
  var body: some ReducerOf<Self> {
    Scope(\.fact, action: \.fact) { FactFeature() }
  }
}

@MainActor
let appStore = Store(initialState: AppFeature.State()) {
  AppFeature()
    ._printChanges()        // DEBUG 빌드에서만 출력 — 릴리스에선 그냥 통과
    .signpost("App")        // Instruments로 기록 중일 때만 signpost를 남긴다
}

received action:
  AppFeature.Action.fact(.factButtonTapped)
  AppFeature.State(
    _fact: FactFeature.State(
      _number: 0,
      _fact: nil,
-     _isLoading: false
+     _isLoading: true
    )
  )

@Reducer
struct WordCounter {
  @ObservableState
  struct State: Equatable {
    var text = ""
    var wordCount: Int?
  }
  enum Action { case countButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.wordCount = state.text.split(separator: " ").count
      return .none
    }
  }
}