Swiftpack.co - Package - UrbanCompass/Snail

🐌 snail Carthage compatible Cocoapods codecov.io SwiftPM Compatible


A lightweight observables framework, also available in Kotlin



You can install Carthage with Homebrew using the following command:

brew update
brew install carthage

To integrate Snail into your Xcode project using Carthage, specify it in your Cartfile where "x.x.x" is the current release:

github "UrbanCompass/Snail" "x.x.x"

Swift Package Manager

To install using Swift Package Manager have your Swift package set up, and add Snail as a dependency to your Package.swift.

dependencies: [
    .Package(url: "https://github.com/UrbanCompass/Snail.git", majorVersion: 0)


Add all the files from Snail/Snail to your project

Creating Observables

let observable = Observable<thing>()


A disposer is in charge of removing all the subscriptions. This prevents creating retention cycles when using closures (see weak self section). For the sake of all the examples, let's have a disposer created:

let disposer = Disposer()

Subscribing to Observables

    onNext: { thing in ... }, // do something with thing
    onError: { error in ... }, // do something with error
    onDone: { ... } //do something when it's done
).add(to: disposer)

Closures are optional too...

    onNext: { thing in ... } // do something with thing
).add(to: disposer)
    onError: { error in ... } // do something with error
).add(to: disposer)

Creating Observables Variables

let variable = Variable<whatever>(some initial value)
let optionalString = Variable<String?>(nil)
    onNext: { string in ... } // do something with value changes
).add(to: disposer)

optionalString.value = "something"
let int = Variable<Int>(12)
    onNext: { int in ... } // do something with value changes
).add(to: disposer)

int.value = 42

Combining Observable Variables

let isLoaderAnimating = Variable<Bool>(false)
isLoaderAnimating.bind(to: viewModel.isLoading) // forward changes from one Variable to another

viewModel.isLoading = true
print(isLoaderAnimating.value) // true
Observable.merge([userCreated, userUpdated]).subscribe(
  onNext: { user in ... } // do something with the latest value that got updated
}).add(to: disposer)

userCreated.value = User(name: "Russell") // triggers 
userUpdated.value = User(name: "Lee") // triggers 
Observable.combineLatest((isMapLoading, isListLoading)).subscribe(
  onNext: { isMapLoading, isListLoading in ... } // do something when both values are set, every time one gets updated
}).add(to: disposer)

isMapLoading.value = true
isListLoading.value = true // triggers

Transforming Observable Variable Types

let variable = Variable<String>("Something")
variable.map { $0.count }.asObservable().subscribe(
    onNext: { (charactersCount: Int -> Void) in ... } // do something with Integer 'charactersCount' on value changes
).add(to: disposer)

Miscellaneous Observables

let just = Just(1) // always returns the initial value (1 in this case)

enum TestError: Error {
  case test
let failure = Fail(TestError.test) // always fail with error

let n = 5
let replay = Replay(n) // replays the last N events when a new observer subscribes

Subscribing to Control Events

let control = UIControl()
  onNext: { ... }  // do something with thing
).add(to: disposer)

let button = UIButton()
  onNext: { ... }  // do something with thing
).add(to: disposer)


You can specify which queue an observables will be notified on by using .subscribe(queue: <desired queue>). If you don't specify, then the observable will be notified on the same queue that the observable published on.

There are 3 scenarios:

  1. You don't specify the queue. Your observer will be notified on the same thread as the observable published on.

  2. You specified main queue AND the observable published on the main queue. Your observer will be notified synchronously on the main queue.

  3. You specified a queue. Your observer will be notified async on the specified queue.


Subscribing on DispatchQueue.main

observable.subscribe(queue: .main,
    onNext: { thing in ... }
).add(to: disposer)

Weak self is optional

You can use [weak self] if you want, but with the introduction of Disposer, retention cycles are destroyed when calling disposer.disposeAll().

One idea would be to call disposer.disposeAll() when you pop a view controller from the navigation stack.

protocol HasDisposer {
    var disposer: Disposer

class NavigationController: UINavigationController {
    public override func popViewController(animated: Bool) -> UIViewController? {
        let viewController = super.popViewController(animated: animated)
        (viewController as? HasDisposer).disposer.disposeAll()
        return viewController

In Practice

Subscribing to Notifications

  .subscribe(queue: .main, onNext: { notification in
  }).add(to: disposer)

Subscribing to Gestures

let panGestureRecognizer = UIPanGestureRecognizer()
  .subscribe(queue: .main, onNext: {
  }).add(to: disposer)

Subscribing to UIBarButton Taps

  .subscribe(onNext: {
    self.dismiss(animated: true, completion: nil)
  }).add(to: disposer)


Stars: 156
Help us keep the lights on


Used By

Total: 1


0.4 - Aug 7, 2019

  • This would help identify subscriptions that were not tied to a Disposer()

0.3.3 - Aug 2, 2019

  • Adding new Disposer class to take care of disposables

0.3.2 - Aug 1, 2019

0.3.1 - Jul 24, 2019

0.3.0 - May 6, 2019

Update project to work with Swift 5