How to debounce user input in Swift with AsyncNinja?

Use the `debounce` operator on a reactive property, like `searchBar.rp.text.debounce(interval: 0.3)`, then chain `distinct` and `flatMap` for processing, as demonstrated in the README's search example. This reduces network calls and improves performance.

AsyncNinja vs RxSwift: which is better for iOS?

AsyncNinja simplifies memory management with automatic context handling, reducing boilerplate, while RxSwift has a larger operator set and community. Choose AsyncNinja for cleaner code with less manual work, or RxSwift for maximum flexibility and extensive resources.

How to avoid memory leaks when using AsyncNinja in view controllers?

Pass the view controller as a context parameter in methods like `onSuccess` or `map`, which automatically cancels operations when the context is deallocated. This removes the need for [weak self] and manual cleanup, ensuring safe resource management.

Does AsyncNinja work with SwiftUI?

Yes, but integration may require custom adapters since AsyncNinja's bindings and reactive properties are designed for UIKit/AppKit. You can use it for state management, but it's not as seamless as native SwiftUI tools like Combine publishers.

What's the performance cost of using Channels over GCD?

Channels add abstraction overhead compared to raw Grand Central Dispatch, but for most apps, the convenience and safety benefits outweigh this. Profile performance-critical sections if needed, as the library optimizes common operations like threading automatically.

How to convert callback-based APIs to futures in AsyncNinja?

Create a Promise, pass its `complete` method as the callback, and return the Promise as a Future. Example: `func fetch() -> Future { let promise = Promise (); legacyFetch(callback: promise.complete); return promise }`, as shown in the README.

Open-Awesome

AsyncNinja

MITSwift1.4.0

A comprehensive Swift library providing primitives for concurrency and reactive programming, simplifying asynchronous code.

Visit Website GitHub

156 stars17 forks0 contributors

What is AsyncNinja?

AsyncNinja is a Swift library that provides a comprehensive set of primitives for concurrency and reactive programming. It solves the problem of writing clean, safe, and maintainable asynchronous code by offering constructs like Futures, Promises, and Channels, along with automatic lifecycle and threading management.

Target Audience

Swift developers building iOS, macOS, tvOS, watchOS, or Linux applications who need robust asynchronous and reactive programming tools.

Value Proposition

Developers choose AsyncNinja for its ability to drastically reduce boilerplate, eliminate common concurrency pitfalls like retain cycles and manual queue dispatching, and provide a unified API for both reactive and asynchronous patterns.

Overview

A complete set of primitives for concurrency and reactive programming on Swift

Use Cases

Best For

Simplifying asynchronous network calls and data processing in Swift apps
Implementing reactive UI bindings without manual memory management
Combining multiple asynchronous operations with zip, merge, or flatMap
Debouncing and throttling user input streams like search bars
Managing concurrency in cross-platform Swift projects
Transitioning callback-based legacy code to a futures/channels model

Not Ideal For

Projects already deeply invested in RxSwift or Apple's Combine framework
Applications built exclusively with Swift 5.5+ that rely on native async/await and structured concurrency
Teams requiring a large ecosystem of third-party plugins and community-driven extensions
Lightweight scripts or microservices where adding a comprehensive concurrency library is overkill

Pros & Cons

Pros

Automatic Context Management

Eliminates the need for [weak self] and manual DispatchQueue calls by using context parameters that automatically handle lifecycle and threading, as shown in the view controller examples.

Comprehensive Primitive Set

Provides Futures, Promises, Channels, Producers, Sinks, and Caches, covering a wide range of asynchronous and reactive patterns in a unified API.

Cross-Platform Compatibility

Supports all Apple platforms (macOS, iOS, tvOS, watchOS) and Linux, making it a versatile choice for Swift projects across different environments.

Boilerplate Reduction

Offers high-level operations like debounce, distinct, and recover for reactive streams, significantly cutting down repetitive code in scenarios like search input handling.

Cons

Swift Version Fragmentation

Requires different library versions for different Swift releases (e.g., 1.4.0 for Swift 4.2/5.0, 1.3.0 for Swift 4.0+), complicating dependency management in projects with mixed or legacy codebases.

Overlap with Native Features

With Swift 5.5 introducing built-in async/await and structured concurrency, AsyncNinja may become redundant for new projects adopting these modern language constructs, leading to potential code bloat.

Limited Ecosystem Scale

Has a smaller community and fewer third-party integrations compared to established alternatives like RxSwift, which can hinder finding pre-built solutions or community support for edge cases.

Frequently Asked Questions

Related Projects

Hydra

⚡️ Lightweight full-featured Promises, Async & Await Library in Swift

Stars1,991

Forks115

Last commit4 years ago

Venice

Coroutines, structured concurrency and CSP for Swift on macOS and Linux.

Stars1,495

Forks57

Last commit7 years ago

Queuer

Queuer is a queue manager, built on top of OperationQueue and Dispatch (aka GCD).

Stars1,155

Forks46

Last commit1 month ago

SwiftCoroutine

Swift coroutines for iOS, macOS and Linux.

Stars833

Forks50