Why do we need yet another architecture?

Programming is all about ABSTRACTION

State?

var a = 0  //storing value

a = 5 // changing value assign to sth

a += 7 // mutating value to another

a // a = 12

You touch state all the time!

Variable is a sort of state

Abstraction

struct Car {
    let make: String
    let model: String
    var numberOfWheels: Int = 4
    
    init(make: String, model: String) {
    } 
}

Car(make: "Honda", model: "HRV")

State is easy

But maintaining it is really HARD!

State is everywhere, mutating all the time

State is complex

class UIView {

   var userInteractionEnabled: Bool // 2^1

   var opaque: Bool // 2^2

   var hidden: Bool // 2^3

   var autoresizesSubviews: Bool // 2^4

}

Possibilities go exponentially

But could we avoid state?

Then, we need the best possible way to maintain state

NO, we couldn't ...

Store

Object that glues everything together, responsibilities of Store are;

Hold app state

Allow access state

Allow action to be dispatched

Register listeners and also unregister

Store

protocol DisposableType {
  var dispose: () -> () { get }
}

protocol StoreType {
  associatedtype State
  
  var getState: () -> State { get }
  var dispatch: ActionType -> ActionType { get }
  var subscribe: (State -> ()) -> 
                  DisposableType { get }
}

The Flow - Unidirectional

The Flow - Unidirectional

Tell store to dispatch action

store.dispatch(action)

Store calls reducer function, returns state

func reducer(state, action) -> newState

Store notify subscribers for state changes

store.subscribe { newState in
  print(newState)
}

Q&A

Resources

redux.js.org/index.html

reswift.github.io/ReSwift

github.com/kittinunf/ReduxPlaygroud