Swift에서 Debounce: Combine을 버리고 이 간단한 루프

I’m ready to translate the article for you, but it looks like the body of the text wasn’t included in your message—only the source link was provided. Could you please paste the article’s content (or the specific sections you’d like translated) here? I’ll then translate it into Korean while preserving the formatting, markdown, and code blocks as requested.

Source:

Swift Async Algorithms 소개 – 비동기 작업을 for 루프처럼 자연스럽게 만드는 Apple의 솔루션

Swift Async Algorithms란?

Swift Async Algorithms는 Apple이 오픈‑소스화한 라이브러리로, 익숙한 컬렉션 알고리즘을 비동기 시퀀스에 적용할 수 있게 해줍니다. async/await을 위한 표준 라이브러리 지원이 부족했던 부분을 메워 주는 역할이며, debounce, throttle, merge, combineLatest 등 다양한 도구를 제공하지만 모두 Swift의 최신 동시성 모델에 맞춰 처음부터 설계되었습니다.

• 2022년에 출시된 이 라이브러리는 “이제 모든 것을 Combine으로 할 필요는 없다”는 Apple의 메시지를 담고 있습니다.
• 한 줄 요약: Combine 프레임워크와 비슷하지만, 퍼블리셔와 구독자가 아니라 async/await용으로 만든 버전입니다.

왜 관심을 가져야 할까요?

예를 들어 검색 바를 만든다고 가정해 보세요. 사용자가 입력할 때마다 API에 쿼리를 보내고 싶지만, 요청을 남발하고 싶지는 않습니다. 이때 디바운싱이 필요합니다.

이미 앱에서 async/await을 사용하고 있다면, 하나의 연산자를 위해 굳이 Combine을 추가할 필요가 있을까요?

실제 예시: 검색창 디바운스

아래는 두 가지 접근 방식으로 구현한 동일한 기능입니다. 대비를 통해 Async Algorithms의 장점이 명확히 드러납니다.

Combine 방식

import Combine
import UIKit

class CombineSearchViewController: UIViewController {
    @IBOutlet weak var searchBar: UISearchBar!
    @IBOutlet weak var tableView: UITableView!

    private var cancellables = Set()
    private let searchSubject = PassthroughSubject<String, Never>()
    private var results: [String] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        setupSearch()
    }

    private func setupSearch() {
        // Set up the debounce pipeline
        searchSubject
            .debounce(for: .milliseconds(500), scheduler: DispatchQueue.main)
            .removeDuplicates()
            .sink { [weak self] query in
                Task {
                    await self?.performSearch(query: query)
                }
            }
            .store(in: &cancellables)

        searchBar.delegate = self
    }

    private func performSearch(query: String) async {
        // Simulate API call
        try? await Task.sleep(nanoseconds: 500_000_000)

        let mockResults = [
            "Result for \(query) - 1",
            "Result for \(query) - 2",
            "Result for \(query) - 3"
        ]

        await MainActor.run {
            self.results = mockResults
            self.tableView.reloadData()
        }
    }
}

extension CombineSearchViewController: UISearchBarDelegate {
    func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
        searchSubject.send(searchText)
    }
}

무슨 일이 일어나고 있는가

• PassthroughSubject가 검색 텍스트 값을 방출합니다.
• 연산자들이 체인됩니다: debounce → removeDuplicates → sink.
• sink 안에서 Task를 사용해 async 로 브리지합니다.
• 정리를 위해 Set을 관리해야 합니다.
• 두 개의 동시성 모델(Combine + async/await)이 공존합니다.

Async Algorithms 방식

import AsyncAlgorithms
import UIKit

class AsyncSearchViewController: UIViewController {
    @IBOutlet weak var searchBar: UISearchBar!
    @IBOutlet weak var tableView: UITableView!

    private let searchStream = AsyncChannel<String>()
    private var results: [String] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        searchBar.delegate = self

        Task {
            await observeSearches()
        }
    }

    private func observeSearches() async {
        // This reads like plain English!
        for await query in searchStream
            .debounce(for: .milliseconds(500))
            .removeDuplicates() {
                await performSearch(query: query)
        }
    }

    private func performSearch(query: String) async {
        // Simulate API call
        try? await Task.sleep(nanoseconds: 500_000_000)

        let mockResults = [
            "Result for \(query) - 1",
            "Result for \(query) - 2",
            "Result for \(query) - 3"
        ]

        await MainActor.run {
            self.results = mockResults
            self.tableView.reloadData()
        }
    }
}

extension AsyncSearchViewController: UISearchBarDelegate {
    func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
        Task {
            await searchStream.send(searchText)
        }
    }
}

왜 이 방식은 완전히 다르게 느껴지는가

• AsyncChannel은 send할 수 있는 비동기 스트림 역할을 합니다.
• 하나의 for await 루프가 디바운스되고 중복이 제거된 값을 소비합니다.
• 모든 코드가 async/await 세계에 머물러 브리징이 필요 없습니다.
• cancellable도, 추가적인 라이프사이클 관리도 없습니다.

Source:

Async 알고리즘 접근법 분석

마법 같은 코드:

for await query in searchStream
    .debounce(for: .milliseconds(500))
    .removeDuplicates() {
        await performSearch(query: query)
}

무슨 일이 일어나고 있나요?

이 모든 것은 Swift 동시성 런타임 위에서 실행되며, 결정적인 취소, 구조화된 동시성, 그리고 마치 산문처럼 읽히는 구문을 제공합니다.

TL;DR

• Swift Async Algorithms 은 async 시퀀스를 위한 컬렉션‑스타일 연산자(debounce, throttle, merge, …)를 제공합니다.
• Combine‑스타일 파이프라인을 깔끔한 async/await 코드로 대체할 수 있습니다.
• 별도의 프레임워크, cancellable, 브리징이 필요 없습니다—오직 순수 Swift 동시성만 사용합니다.

다음에 디바운싱, 스로틀링 또는 기타 스트림‑처리 로직이 필요할 때 한 번 사용해 보세요. 미래의 자신(그리고 리뷰어)에게 큰 도움이 될 것입니다.

Debounce – 스트림에서 일정 시간 정지 후 최신 값을 방출합니다:

for await value in stream.debounce(for: .seconds(0.5), clock: .continuous) {
    print(value)          // 사용자가 0.5 초 동안 입력을 멈췄을 때만 실행
}

사용자가 그 시간 동안 계속 입력하면 타이머가 재설정됩니다.

.removeDuplicates()

연속된 동일한 값을 걸러냅니다.
사용자가 **“cat”**을 입력하고 삭제한 뒤 다시 **“cat”**을 입력하면 검색이 한 번만 실행됩니다.

for await

루프는 각 반복마다 다음 값을 기다리며 일시 중단됩니다.
깨끗하고 순차적이며 가독성이 좋습니다.

설치

Swift Async Algorithms 를 Swift Package Manager 를 통해 프로젝트에 추가하세요:

https://github.com/apple/swift-async-algorithms

Xcode에서: File → Add Package Dependencies → 위 URL을 붙여넣으세요.

언제 어떤 것을 사용해야 할까?

Async 알고리즘을 사용할 때:

• 이미 async/await를 사용하고 있을 때
• 새 기능을 처음부터 구축할 때
• 코드를 더 간단하고 가독성 있게 만들고 싶을 때
• 팀이 최신 Swift 동시성에 익숙할 때

Combine을 사용할 때:

• 이미 Combine을 사용하고 있는 레거시 코드와 작업할 때
• SwiftUI와의 긴밀한 통합이 필요할 때 (이 경우 Combine이 여전히 우위에 있음)
• 많은 연산자를 포함한 복잡한 리액티브 파이프라인을 구축할 때
• async/await 이전 iOS 버전을 타깃으로 할 때

메모리 트릭

• Combine = 퍼블리셔가 값을 푸시 → 당신은 구독하고 반응합니다
• Async Algorithms = 값을 풀 → 당신은 await하고 처리합니다

한 가지 더: 기타 멋진 연산자

Throttle – 시간 창당 최대 하나의 값만 방출

for await value in stream.throttle(for: .seconds(1), clock: .continuous) {
    print(value)
}

Merge – 여러 비동기 시퀀스 결합

for await value in merge(streamA, streamB) {
    print(value)
}

Zip – 여러 시퀀스의 값을 쌍으로 결합

for await (a, b) in zip(streamA, streamB) {
    print("Pair: \(a), \(b)")
}

CombineLatest – 여러 스트림에서 최신 값을 가져오기

for await (a, b) in combineLatest(streamA, streamB) {
    print("Latest: \(a), \(b)")
}

결론

Swift Async Algorithms는 Combine을 대체하는 것이 아니라 선택지를 제공합니다.
async/await에 전념했다면 (그렇게 해야 합니다), Async Algorithms가 자연스러운 다음 단계입니다.

검색창 예제가 이를 완벽히 보여줍니다: Combine에서 여러 객체, 구독, 복잡한 로직이 필요했지만, 이제는 읽기 쉬운 단일 for await 루프로 변합니다.

다음에 텍스트 필드 디바운스를 위해 Combine을 사용할 때는 대신 Async Algorithms를 시도해 보세요.

더 자세히 알아보고 싶나요?

• Swift Async Algorithms on GitHub