Swift Apps in a Swoosh! A modern framework for creating iOS apps, inspired by Redux.

Overview

Katana

Twitter URL Build Status Docs CocoaPods Licence

Katana is a modern Swift framework for writing iOS applications' business logic that are testable and easy to reason about. Katana is strongly inspired by Redux.

In few words, the app state is entirely described by a single serializable data structure, and the only way to change the state is to dispatch a StateUpdater. A StateUpdater is an intent to transform the state, and contains all the information to do so. Because all the changes are centralized and are happening in a strict order, there are no subtle race conditions to watch out for.

We feel that Katana helped us a lot since we started using it in production. Our applications have been downloaded several millions of times and Katana really helped us scaling them quickly and efficiently. Bending Spoons's engineers leverage Katana capabilities to design, implement and test complex applications very quickly without any compromise to the final result.

We use a lot of open source projects ourselves and we wanted to give something back to the community, hoping you will find this useful and possibly contribute. ❤️

Overview

Your entire app State is defined in a single struct, all the relevant application information should be placed here.

struct CounterState: State {
  var counter: Int = 0
}

The app State can only be modified by a StateUpdater. A StateUpdater represents an event that leads to a change in the State of the app. You define the behaviour of the State Updater by implementing the updateState(:) method that changes the State based on the current app State and the StateUpdater itself. The updateState should be a pure function, which means that it only depends on the inputs (that is, the state and the state updater itself) and it doesn't have side effects, such as network interactions.

struct IncrementCounter: StateUpdater {
  func updateState(_ state: inout CounterState) {
    state.counter += 1
  }
}

The Store contains and manages your entire app State. It is responsible of managing the dispatched items (e.g., the just mentioned State Updater).

// ignore AppDependencies for the time being, it will be explained later on
let store = Store<CounterState, AppDependencies>()
store.dispatch(IncrementCounter())

You can ask the Store to be notified about every change in the app State.

store.addListener() { oldState, newState in
  // the app state has changed
}

Side Effects

Updating the application's state using pure functions is nice and it has a lot of benefits. Applications have to deal with the external world though (e.g., API call, disk files management, …). For all this kind of operations, Katana provides the concept of side effects. Side effects can be used to interact with other parts of your applications and then dispatch new StateUpdaters to update your state. For more complex situations, you can also dispatch other side effects.

Side Effects are implemented on top of Hydra, and allow you to write your logic using promises. In order to leverage this functionality you have to adopt the SideEffect protocol

struct GenerateRandomNumberFromBackend: SideEffect {
  func sideEffect(_ context: SideEffectContext<CounterState, AppDependencies>) throws {
    // invokes the `getRandomNumber` method that returns a promise that is fullfilled
    // when the number is received. At that point we dispatch a State Updater
    // that updates the state
    context.dependencies.APIManager
        .getRandomNumber()
        .then { randomNumber in context.dispatch(SetCounter(newValue: randomNumber)) }
  }
}

struct SetCounter: StateUpdater {
  let newValue: Int
  
  func updateState(_ state: inout CounterState) {
    state.counter = self.newValue
  }
}

Moreover, you can leverage the Hydra.await operator to write logic that mimics the async/await pattern, which allows you to write async code in a sync manner.

struct GenerateRandomNumberFromBackend: SideEffect {
  func sideEffect(_ context: SideEffectContext<CounterState, AppDependencies>) throws {
    // invokes the `getRandomNumber` method that returns a promise that is fulfilled
    // when the number is received.
    let promise = context.dependencies.APIManager.getRandomNumber()
    
    // we use Hydra.await to wait for the promise to be fulfilled
    let randomNumber = try Hydra.await(promise)

    // then the state is updated using the proper state updater
    try Hydra.await(context.dispatch(SetCounter(newValue: randomNumber)))
  }
}

In order to further improve the usability of side effects, there is also a version which can return a value. Note that both the state and dependencies types are erased, to allow for more freedom when using it in libraries, for example.

struct PurchaseProduct: ReturningSideEffect {
  let productID: ProductID

  func sideEffect(_ context: AnySideEffectContext) throws -> Result<PurchaseResult, PurchaseError> {

    // 0. Get the typed version of the context
    guard let context = context as? SideEffectContext<CounterState, AppDependencies> else {
      fatalError("Invalid context type")
    }

    // 1. purchase the product via storekit
    let storekitResult = context.dependencies.monetization.purchase(self.productID)
    if case .failure(let error) = storekitResult {
      return .storekitRejected(error)
    }

    // 2. get the receipt
    let receipt = context.dependencies.monetization.getReceipt()

    // 3. validate the receipt
    let validationResult = try Hydra.await(context.dispatch(Monetization.Validate(receipt)))

    // 4. map error
    return validationResult
      .map { .init(validation: $0) }
      .mapError { .validationRejected($0) }
  }
}

Note that, if this is a prominent use case for the library/app, the step 0 can be encapsulated in a protocol like this:

protocol AppReturningSideEffect: ReturningSideEffect {
  func sideEffect(_ context: SideEffectContext<AppState, DependenciesContainer>) -> Void
}

extension AppReturningSideEffect {
  func sideEffect(_ context: AnySideEffectContext) throws -> Void {
    guard let context = context as? SideEffectContext<AppState, DependenciesContainer> else {
      fatalError("Invalid context type")
    }
    
    self.sideEffect(context)
  }
}

Dependencies

The side effect example leverages an APIManager method. The Side Effect can get the APIManager by using the dependencies parameter of the context. The dependencies container is the Katana way of doing dependency injection. We test our side effects, and because of this we need to get rid of singletons or other bad pratices that prevent us from writing tests. Creating a dependency container is very easy: just create a class that conforms to the SideEffectDependencyContainer protocol, make the store generic to it, and use it in the side effect.

final class AppDependencies: SideEffectDependencyContainer {
  required init(dispatch: @escaping PromisableStoreDispatch, getState: @escaping GetState) {
		// initialize your dependencies here
	}
}

Interceptors

When defining a Store you can provide a list of interceptors that are triggered in the given order whenever an item is dispatched. An interceptor is like a catch-all system that can be used to implement functionalities such as logging or to dynamically change the behaviour of the store. An interceptor is invoked every time a dispatchable item is about to be handled.

DispatchableLogger

Katana comes with a built-in DispatchableLogger interceptor that logs all the dispatchables, except the ones listed in the blacklist parameter.

let dispatchableLogger = DispatchableLogger.interceptor(blackList: [NotToLog.self])
let store = Store<CounterState>(interceptor: [dispatchableLogger])

ObserverInterceptor

Sometimes it is useful to listen for events that occur in the system and react to them. Katana provides the ObserverInterceptor that can be used to achieve this result.

In particular you instruct the interceptor to dispatch items when:

  • the store is initialized
  • the state changes in a particular way
  • a particular dispatchable item is managed by the store
  • a particular notification is sent to the default NotificationCenter
let observerInterceptor = ObserverInterceptor.observe([
  .onStart([
    // list of dispatchable items dispatched when the store is initialized
  ])
])

let store = Store<CounterState>(interceptor: [observerInterceptor])

Note that when intercepting a side effect using an ObserverInterceptor, the return value of the dispatchable is not available to the interceptor itself.

What about the UI?

Katana is meant to give structure to the logic part of your app. When it comes to UI we propose two alternatives:

  • Tempura: an MVVC framework we built on top of Katana and that we happily use to develop the UI of all our apps at Bending Spoons. Tempura is a lightweight, UIKit-friendly library that allows you to keep the UI automatically in sync with the state of your app. This is our suggested choice.

  • Katana-UI: With this library, we aimed to port React to UIKit, it allows you to create your app using a declarative approach. The library was initially bundled together with Katana, we decided to split it as internally we don't use it anymore. In retrospect, we found that the impedance mismatch between the React-like approach and the imperative reality of UIKit was a no go for us.

Tempura Katana UI

Signpost Logger

Katana is automatically integrated with the Signpost API. This integration layer allows you to see in Instruments all the items that have been dispatched, how long they last, and useful pieces of information such as the parallelism degree. Moreover, you can analyse the cpu impact of the items you dispatch to furtherly optimise your application performances.

Bending Spoons Guidelines

In Bending Spoons, we are extensively using Katana. In these years, we've defined some best pratices that have helped us write more readable and easier to debug code. We've decided to open source them so that everyone can have a starting point when using Katana. You can find them here.

Migration from 2.x

We strongly suggest to upgrade to the new Katana. The new Katana, in fact, not only adds new very powerful capabilities to the library, but it has also been designed to be extremely compatible with the old logic. All the actions and middleware you wrote for Katana 2.x, will continue to work in the new Katana as well. The breaking changes are most of the time related to simple typing changes that are easily addressable.

If you prefer to continue with Katana 2.x, however, you can still access Katana 2.x in the dedicated branch.

Middleware

In Katana, the concept of middleware has been replaced with the new concept of interceptor. You can still use your middleware by leveraging the middlewareToInterceptor method.

Swift Version

Certain versions of Katana only support certain versions of Swift. Depending on which version of Swift your project is using, you should use specific versions of Katana. Use this table in order to check which version of Katana you need.

Swift Version Katana Version
Swift 5.0 Katana >= 6.0
Swift 4.2 Katana >= 2.0
Swift 4.1 Katana < 2.0

Where to go from here

Give it a shot

pod try Katana

Tempura

Make awesome applications using Katana together with Tempura

Check out the documentation

Documentation

You can also add Katana to Dash using the proper docset.

Installation

Katana is available through CocoaPods and Swift Package Manager, you can also drop Katana.project into your Xcode project.

Requirements

  • iOS 11.0+ / macOS 10.10+

  • Xcode 9.0+

  • Swift 5.0+

Swift Package Manager

Swift Package Manager is a tool for managing the distribution of Swift code. It’s integrated with the Swift build system to automate the process of downloading, compiling, and linking dependencies.

There are two ways to integrate Katana in your project using Swift Package Manager:

  • Adding it to your Package.swift
  • Adding it directly from Xcode under File -> Swift Packages -> Add Package dependency..

In both cases you only need to provide this URL: [email protected]:BendingSpoons/katana-swift.git

CocoaPods

CocoaPods is a dependency manager for Cocoa projects. You can install it with the following command:

$ sudo gem install cocoapods

To integrate Katana into your Xcode project using CocoaPods you need to create a Podfile.

For iOS platforms, this is the content

use_frameworks!
source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '9.0'

target 'MyApp' do
  pod 'Katana'
end

Now, you just need to run:

$ pod install

Get in touch

Special thanks

Contribute

  • If you've found a bug, open an issue;
  • If you have a feature request, open an issue;
  • If you want to contribute, submit a pull request;
  • If you have an idea on how to improve the framework or how to spread the word, please get in touch;
  • If you want to try the framework for your project or to write a demo, please send us the link of the repo.

License

Katana is available under the MIT license.

About

Katana is maintained by Bending Spoons. We create our own tech products, used and loved by millions all around the world. Interested? Check us out!

Comments
  • SyncAction/AsyncAction should be improved

    SyncAction/AsyncAction should be improved

    In the last few days I've reviewed a lot of code and I think that we have an intrinsic problem with these two protocols.

    Forcing people to put everything in the payload leads to very weird things and in general to hard to understand actions. We should release this constraint.

    A little bit of background: forcing to use payload has been added to write an automated way to serialize/deserialize actions. I think we have not better ways to do it and therefore it shouldn't be a problem anymore.

    My only concern is about asyncActions. We should find a way to keep the functionalities without forcing people to use names such as payload or completedPayload. Note that using asyncActions is very verbose right now as we cannot automate very little using the protocol extensions. Maybe it is time to think to a better way to manage the problem of having an action that can be "completed" and that can "fail" without having 3 actions. In this context, if possible, we should also add a way to manage progression (e.g., download of a file)

    enhancement 
    opened by bolismauro 17
  • Reducers?

    Reducers?

    I just have a simple question as I've been using Redux directly for the last few months:

    Where are the Reducers?

    It seems like you are putting all your state mutation code inside your actions. Is this a pattern that you adopted on purpose and if so then why?

    opened by alexanderjarvis 14
  • Create README.md

    Create README.md

    @bolismauro @lucaquerella here the first draft of the readme. I've looked at pretty much every readme of every significant swift framework, this is (excluding the copy that is work in progress) my best summary of what a readme should contain. feel free to suggest or question everything.

    my suggestion on how to improve this:

    • improve copy
    • insert/update the items in the roadmap (under features)
    • introduce also the advanced stuff (i.e. asyncActions)
    • tune the example to something comprehensive that we will also release as a complete example
    • include more examples, even complex ones
    opened by smaramba 14
  • DSL for PlasticView Anchors and Values

    DSL for PlasticView Anchors and Values

    This PR adds a small DSL intended to improve readability and speed of development when laying out PlasticViews, i.e. setting Anchors with offsets.

    The current way to set an anchor to a PlasticView with an offset is something like:

    button.setTop(view.top, offset: .scalable(300))
    button.setRight(view.right, offset: .fixed(-50))
    

    With this DSL, the above example would turn into:

    button.top = view.top + 300
    button.right = view.right - 50.fixed
    

    The contents of this PR are (see each commit message for more details):

    • Add offset property to Anchor

    • Add ability to add an offset to an anchor through + and - operators

    • Make Value conform to ExpressibleByIntegerLiteral and ExpressibleByFloatLiteral

    • Add scaled and fixed properties to CGFloat, Double and Int as a convenient way to instantiate Value instances

    opened by m4tbat 11
  • The fill method of PlasticView is ambiguously named

    The fill method of PlasticView is ambiguously named

    It has happened to me a few times that I wanted to use the fill method and got surprised by the behaviour. I called it this way view.fill(top: anchor1, left: anchor2, bottom: anchor3, right: anchor4) and expected my view to stretch to the anchors, instead I got a square view.

    This is because fill stretches the view preserving the aspect ratio (1, by default). I think the method should be renamed to something like fillPreservingAspectRatio to avoid confusion, or at least the scale argument shouldn't be optional.

    Moreover, I think it would be useful to have a fill method that does not preserve the aspect ratio.

    opened by frankdilo 10
  • Reduce boilerplate in Actions

    Reduce boilerplate in Actions

    Current Action implementation leads to code like this

    struct MyAction: Action {
      func updatedState(currentState: State) -> State {
        guard var state = currentState as? AppState else { 
          return currentState // Boilerplate
        } 
        // ... currentState changes
        return state // Boilerplate
      }
    }
    

    Wouldn't it be better to make it

    struct MyAction: Action {
      func updateState(currentState: inout MyState) {
        // ... currentState changes
      }
    }
    

    This can be done in two simple steps:

    1. Rename current Action to e.g. BaseAction
    2. Implement Action as
    protocol Action: BaseAction {
      associatedtype StateType: State
      func updateState(currentState: inout StateType)
    }
    
    extension Action {
      func updatedState(currentState: State) -> State {
        guard var state = currentState as? StateType else { fatalError("Wrong state type") }
        updateState(currentState: &state)
        return state
      }
    }
    

    AsyncAction can be simplified in the same way.

    opened by okla 7
  • Feature/action linker

    Feature/action linker

    Why Add the ActionLinker to dispatch a set of Actions that depends on another one

    Changes The Store require a links: [ActionLinks] new parameter to be initialized. I keep the compatibility with the convenience empty init.

    Tasks

    • [x] Add relevant tests, if needed
    • [x] Add documentation, if needed
    • [ ] Update README, if needed
    • [x] Ensure that all the examples (as well as the demo) work properly
    opened by cipolleschi 6
  • Write a great README

    Write a great README

    As discussed we want to touch the following points (more or less in deep) in the README

    • Background (react/redux)
    • History, why we have created Katana
    • How to use it
    • Very simple getting started (ideally max 10 lines for an hello world)
    • “We use it in production”
    • Roadmap
    • Why do we release Katana as OSS?

    Let's take a look at other well done README for inspiration.

    This is also an interesting resource

    opened by bolismauro 6
  • Possible Fix For #67 - Change referenceSize static var to func

    Possible Fix For #67 - Change referenceSize static var to func

    Why This is a possible attempt to fix the issue #67. It gives developers maximum flexibility while retaining a simple interface, which is the same of the PlasticNodeDescription's layout func.

    This PR doesn't introduce any BC.

    Changes

    • Add PlasticExtendedReferenceSizeable protocol, which contains a referenceSize static func with props and state parameters, that can be implemented in place of the referenceSize static var. PlasticReferenceSizeable protocol is kept as is.

    Tasks

    • [ ] Add relevant tests, if needed
    • [ ] Add documentation, if needed
    • [ ] Update README, if needed
    • [ ] Ensure that all the examples (as well as the demo) work properly
    opened by sroddy 5
  • Find and add a license

    Find and add a license

    We need to find a good license for Katana. I'd stick with the famous ones. MIT, for instance, seems very common

    Additional note, should we put the license also in the header? What I mean is something like this https://github.com/Alamofire/Alamofire/blob/master/Example/Source/DetailViewController.swift#L4

    opened by bolismauro 5
  • StoreListener change

    StoreListener change

    Problem

    Right now StoreListeners do not have the capability to reason about diffs between old state and new state. An example of usage could be change the LocalState of a ViewController in Tempura based on those differences inside func update(with state: V.VM.S) that could become func update(oldState: V.VM.S).

    Proposal

    Modify StoreListener to accept the oldState as parameter, this should be fairly simple.

    ┆Issue is synchronized with this Asana task by Unito

    enhancement 
    opened by AlfioRusso 4
Releases(0.8.0)
  • 0.8.0(Apr 8, 2017)

    Changes

    Core

    • Add defaults to completedAction and failedAction in AsyncAction
    • Fix Plastic issue with frame rounding
    • Add ability to mock internal state of NodeDescription. See this issue for the the complete description of the feature, and this PR for the implementation
    • Refactor Store's action management. The old implementation had issues in the very early stages of the Store. See this PR for more information
    • Fix issue with Plastic layout and improve test coverage

    MacOS

    • Improve properties of the Button

    Breaking Changes

    Core

    • Dependency Container now takes getState as parameter in the init
    Source code(tar.gz)
    Source code(zip)
    Katana.framework.zip(6.26 MB)
    KatanaElements.framework.zip(3.23 MB)
  • 0.7.0(Feb 7, 2017)

  • 0.6.0(Jan 27, 2017)

    Changes

    Core

    • Ad shouldUpdate method to NodeDescription. This method can be used to control when a description should be updated. The default implementation of this method checks, using Equatable if current and next props / state are the same
    • Improve animations performances. Katana now skips useless update when possible

    Breaking Changes

    Core

    • Refactor Action, SyncAction and AsyncAction. See this issue for more information
    Source code(tar.gz)
    Source code(zip)
    Katana.framework.zip(5.62 MB)
    KatanaElements.framework.zip(3.15 MB)
  • 0.5.0(Jan 13, 2017)

    Changes

    Core

    • scaleValue is now a public function of PlasticView. Thanks @sroddy 
    • Implement Linkable Actions. Thanks @cipolleschi

    MacOS

    • Improve Button
      • cornerRadius can now be customized
      • isEnabled can now be customized

    Breaking Changes

    Core

    • It is not possible to invoke dispatch and update asynchronously in the lifecyle hooks. This required to change the signatures of the methods by adding the @escaping parameter
    Source code(tar.gz)
    Source code(zip)
    Katana.framework.zip(5.69 MB)
    KatanaElements.framework.zip(3.14 MB)
  • 0.4.0(Dec 24, 2016)

    Changes

    Core

    • Node now exposes container, which is the (platform dependent) native view in which the node is rendered
    • Fix documentation and add documentation where was missing
    • Add Lifecycle hooks
    • Fix random int generation on 32-bit platforms
    • Improve codebase style through Swiftlint

    MacOS

    • NSViewCustom and NativeButton are now open classes and can be subclassed
    • Improved MacOS support
    • Improve MacOS elements

    Breaking Changes

    • renderer in AnyNode is now optional
    • Rename middlewares to middleware
    • Middleware is now non-generic, in order to allow reusable middleware (e.g., middleware shipped with libraries)
    Source code(tar.gz)
    Source code(zip)
    Katana.framework.zip(5.31 MB)
    KatanaElements.framework.zip(3.13 MB)
  • 0.3.0(Nov 29, 2016)

    Changes

    Katana

    • Fix documentation
    • Fix cocoapods instructions
    • Fix bug that caused crashes in some animations
    • Store is now an open class. It is now possible to subclass it for testing purposes
    • Added Support for MacOS :rocket:

    Breaking Changes

    Katana Elements

    • Changed default value of isUserInteractionEnabled in View from false to true

    Plastic

    Layout DSL

    We introduced a new DSL for Plastic. It is now possible to express constraints in a more fluent way

    // before
    view.setTop(anotherView.bottom, offset: .scalable(10))
    
    // now
    view.top = anotherView.bottom + 10 // Plastic assumes 10 is scalable
    
    // the following are also valid
    view.top = anotherView.bottom + .scalable(10)
    view.top = anotherView.bottom + .fixed(10)
    

    Changes:

    • Remove setTop, setBottom, setLeft, setRight, setCenterX and setCenterY methods. Use + and - as shown in the example above
    • Remove confusing init from Value, Size and EdgeInsets

    Confusing Methods

    The previous fill method was confusing. We decided to split the fill/fit management in two separated methods:

    • removed fill(top:left:bottom:right:aspectRatio:insets:)
    • added fill(top:left:bottom:right:insets:)
    • added fit(top:left:bottom:aspectRatio:insets:)
    Source code(tar.gz)
    Source code(zip)
    Katana.framework.zip(5.25 MB)
    KatanaElements.framework.zip(3.08 MB)
  • 0.2.0(Nov 17, 2016)

A simple and predictable state management library inspired by Flux + Elm + Redux.

A simple and predictable state management library inspired by Flux + Elm + Redux. Flywheel is built on top of Corotuines using the concepts of structured concurrency. At the core, lies the State Machine which is based on actor model.

Abhi Muktheeswarar 35 Dec 29, 2022
ReSwift is a Redux-like implementation of the unidirectional data flow architecture in Swift.

ReSwift is a Redux-like implementation of the unidirectional data flow architecture in Swift. ReSwift helps you to separate three important concerns of your app's components.

null 7.3k Jan 9, 2023
A New, Modern Reactive State Management Library for Swift and SwiftUI (The iOS implementation of Recoil)

RecoilSwift RecoilSwift is a lightweight & reactive swift state management library. RecoilSwift is a SwiftUI implementation of recoil.js which powered

Holly Li 160 Dec 25, 2022
Modern thread-safe and type-safe key-value observing for Swift and Objective-C

Now Archived and Forked PMKVObserver will not be maintained in this repository going forward. Please use, create issues on, and make PRs to the fork o

Postmates Inc. 708 Jun 29, 2022
SwiftUI-compatible framework for building browser apps with WebAssembly and native apps for other platforms

SwiftUI-compatible framework for building browser apps with WebAssembly At the moment Tokamak implements a very basic subset of SwiftUI. Its DOM rende

TokamakUI 2k Dec 30, 2022
SwiftUI-compatible framework for building browser apps with WebAssembly and native apps for other platforms

SwiftUI-compatible framework for building browser apps with WebAssembly At the moment Tokamak implements a very basic subset of SwiftUI. Its DOM rende

TokamakUI 2k Dec 29, 2022
A micro-library for creating and observing events.

Signals Signals is a library for creating and observing events. It replaces delegates, actions and NSNotificationCenter with something much more power

Tuomas Artman 454 Dec 21, 2022
VueFlux is the architecture to manage state with unidirectional data flow for Swift, inspired by Vuex and Flux.

Unidirectional State Management Architecture for Swift - Inspired by Vuex and Flux Introduction VueFlux is the architecture to manage state with unidi

Ryo Aoyama 324 Dec 17, 2022
Very simple Observable and Publisher implementation for iOS apps.

Very simple Observable and Publisher implementation for iOS apps.

Igor Kulman 7 Jun 11, 2022
A simple example of the VIPER architecture for iOS apps

Counter Counter is a simple app showing the basics of the VIPER architecture, a version of Uncle Bob’s Clean Architecture for iOS apps. Counter shows

Mutual Mobile 353 Nov 6, 2022
EventBroadcaster is a lightweight event handler framework, written in swift for iOS, macOS, tvOS & watchOS applications.

EventBroadcaster is a lightweight event handler framework, written in swift for iOS, macOS, tvOS & watchOS applications.

Ali Samaiee 4 Oct 5, 2022
Bond is a Swift binding framework that takes binding concepts to a whole new level.

Bond, Swift Bond Update: Bond 7 has been released! Check out the migration guide to learn more about the update. Bond is a Swift binding framework tha

Declarative Hub 4.2k Jan 5, 2023
🐌 snail - An observables framework for Swift

?? snail A lightweight observables framework, also available in Kotlin Installation Carthage You can install Carthage with Homebrew using the followin

Compass 179 Nov 21, 2022
UI event handling using Apple's combine framework.

Description Combinative is a library for UI event handling using Apple's combine framework. It doesn't need many dependencies because it is written ma

noppefoxwolf 106 Jan 29, 2022
Open source implementation of Apple's Combine framework for processing values over time.

OpenCombine Open-source implementation of Apple's Combine framework for processing values over time. The main goal of this project is to provide a com

OpenCombine 2.4k Dec 26, 2022
RxReduce is a lightweight framework that ease the implementation of a state container pattern in a Reactive Programming compliant way.

About Architecture concerns RxReduce Installation The key principles How to use RxReduce Tools and dependencies Travis CI Frameworks Platform Licence

RxSwift Community 125 Jan 29, 2022
A Swift based Future/Promises Library for IOS and OS X.

FutureKit for Swift A Swift based Future/Promises Library for IOS and OS X. Note - The latest FutureKit is works 3.0 For Swift 2.x compatibility use v

null 759 Dec 2, 2022
SwiftEventBus - A publish/subscribe EventBus optimized for iOS

Allows publish-subscribe-style communication between components without requiring the components to explicitly be aware of each other

César Ferreira 1k Jan 6, 2023
Interactive notification pop-over (aka "Toast) modeled after the iOS AirPods and Apple Pencil indicator.

Interactive notification pop-over (aka "Toast) modeled after the iOS AirPods and Apple Pencil indicator. Installation The recommended way is to use Co

Philip Kluz 108 Nov 11, 2022