ReSwift is one of the most popular frameworks that provides the components to build an iOS Redux-like application in a very easy way. Unfortunately, it brings also some issues, for example it's impossible to create a real modularised application because every component relies on a global action. This talk wants to propose a solution to this problem, implementing in a very easy way some extensions to ReSwift, taking inspiration from the Pointfree Composable Architecture, in particular we will see how the pullback function can be used in an old ReSwift Application in order to bring our projects to the next level.

1. Giovanni Catania
Refactoring ReSwift
Applications
In order to make them modular

2. About me
• Senior iOS Developer @ PhotoSì
• First talk in Swift Heroes!
• Functional Programming Lover
@gioevi
Gioevi90

3. PhotoSì
• Leader in Italy in printing photos, photobooks and
photo gift
• Growing reality
• Download the app using the QR code!

4. Agenda

5. Agenda
• ReSwift

6. Agenda
• ReSwift
• Modularization

7. Agenda
• ReSwift
• Modularization
• Sample Application

8. Agenda
• ReSwift
• Modularization
• Sample Application
• Modularize the Sample Application: Problems and Solutions

9. Agenda
• ReSwift
• Modularization
• Sample Application
• Modularize the Sample Application: Problems and Solutions
• Summary & Questions

10. ReSwift

11. ReSwift
ReSwift is a small framework that helps you to create Redux-like
architectures in Swift

12. ReSwift
ReSwift is a small framework that helps you to create Redux-like
architectures in Swift
• View

13. ReSwift
ReSwift is a small framework that helps you to create Redux-like
architectures in Swift
• View
• Action

14. ReSwift
ReSwift is a small framework that helps you to create Redux-like
architectures in Swift
• View
• Action
• Reducer

15. ReSwift
ReSwift is a small framework that helps you to create Redux-like
architectures in Swift
• View
• Action
• Reducer
• Store

17. Unidirectional Data Flow

18. Redux: why?
• Unidirectional Data Flow: it’s easier to debug

19. Redux: why?
• Unidirectional Data Flow: it’s easier to debug
• Code organization: it’s easier to get started

20. Redux: why?
• Unidirectional Data Flow: it’s easier to debug
• Code organization: it’s easier to get started
• Logic in reducers: it’s easier to test

21. ReSwift: why?
• The most starred framework to implement a redux architecture

22. ReSwift: why?
• The most starred framework to implement a redux architecture
• Platform independent

23. ReSwift: drawbacks
• All the App relies on a global AppState

24. Modularization

25. Modularization
Modularization is the activity of dividing a product or a system
into modules that are interchangeable

26. Modularization
Application

27. Modularization
Application
Module 1
Module 2
Module 3

28. Modularization: why?
• Interchangeability

29. Modularization: why?
• Interchangeability
• Isolation

30. Modularization: why?
• Interchangeability
• Isolation
• Easy to debug

31. Modularization: why?
• Interchangeability
• Isolation
• Easy to debug
• Easy to test

32. Sample app: Kittens 🐈

33. Sample app: Kittens 🐈

34. View
struct CatListView: View {
@ObservedObject var viewModel: CatListViewModel
View
Store
Reducer
Action

35. View
struct CatListView: View {
@ObservedObject var viewModel: CatListViewModel
init(store: Store<AppState>) {
viewModel = CatListViewModel(store: store)
}
View
Store
Reducer
Action

36. View
struct CatListView: View {
@ObservedObject var viewModel: CatListViewModel
init(store: Store<AppState>) {
viewModel = CatListViewModel(store: store)
}
var body: some View {
// view implementation
View
Store
Reducer
Action

37. View Model
class CatListViewModel: ObservableObject {
let store: Store<AppState>
@Published var isLoading: Bool
@Published var list: [CatPresentationModel]
init(store: Store<AppState>) {
self.store = store
isLoading = store.state.catListState.loading
list = store.state.catListState.list
}
}
View
Store
Reducer
Action

38. View Model
extension CatListViewModel {
func fetchList() {
store.dispatch(fetchCats)
}
}
View
Store
Reducer
Action

39. Actions: Middleware
let catListMiddleware: Middleware<AppState>
= createThunkMiddleware()
View
Store
Reducer
Action

40. Actions: Middleware
let catListMiddleware: Middleware<AppState>
= createThunkMiddleware()
View
Store
Reducer
Action
let fetchCats = Thunk<CatListState> { dispatch, getState in
dispatch(CatListAction.Fetch())
Task { @MainActor in
let list = await fetchCatList()
.map { $0.compactMap(CatPresentationModel.init) }
switch list {
case let .success(list):
dispatch(CatListAction.SetList(list: list))
...

41. Reducer
public func catListReducer(action: Action, state: CatListState?) -> CatListState {
var state = state ?? .init(list: [], error: nil, loading: false)
switch action {
case _ as CatListAction.Fetch:
state = .init(list: [], error: nil, loading: true)
case let event as CatListAction.SetList:
state = .init(list: event.list, error: nil, loading: false)
default:
break
}
return state
}
View
Store
Reducer
Action

42. View Model
extension CatListViewModel: StoreSubscriber {
typealias StoreSubscriberStateType = CatListState
func newState(state: CatListState) {
isLoading = state.loading
list = state.list
}
}
View
Store
Reducer
Action

43. App
var store = Store<AppState>(reducer: appReducer,
state: nil,
middleware: [catListMiddleware])
@main
struct CatsApp: App {
var body: some Scene {
WindowGroup {
CatListView(store: store)
}
}
}

44. Let’s start modularizing!

45. Let’s start modularizing!
1. Create a new Swift Package

46. Let’s start modularizing!
1. Create a new Swift Package
2. Move all the CatList files inside the new package

47. Let’s start modularizing!
1. Create a new Swift Package
2. Move all the CatList files inside the new package
3. Build the new package

48. Let’s start modularizing!
1. Create a new Swift Package
2. Move all the CatList files inside the new package
3. Build the new package
4. Build the main Application

49. Create a new Swift Package
• Create a new Swift Package called CatList
let package = Package(
name: "CatList"
)

50. Create a new Swift Package
• Create a new Swift Package called CatList
• Set the Swift package supported platforms
let package = Package(
name: "CatList",
platforms: [.iOS(.v15)],
)

51. Create a new Swift Package
• Create a new Swift Package called CatList
• Set the Swift package supported platforms
• Add the ReSwift and ReSwiftThunk dependencies
let package = Package(
name: "CatList",
platforms: [.iOS(.v15)],
dependencies: [
.package(name: "ReSwift")
.package(name: "ReSwiftThunk")
],
)

52. Create a new Swift Package
• Create a new Swift Package called CatList
• Set the Swift package supported platforms
• Add the ReSwift and ReSwiftThunk dependencies
• Add the Network dependency
let package = Package(
name: "CatList",
platforms: [.iOS(.v15)],
dependencies: [
.package(name: "ReSwift")
.package(name: "ReSwiftThunk"),
.package(name: "Network")
],
)

53. Move the CatList files in the new Package
• Drag the
fi
les in the new package

54. Move the CatList files in the new Package
• Drag the
fi
les in the new package
• Add the missing imports where needed

55. class CatListViewModel: ObservableObject {
let store: Store<AppState>
...
}
Build the new package

56. class CatListViewModel: ObservableObject {
let store: Store<AppState>
...
}
Cannot
fi
nd type 'AppState' in scope
Build the new package

57. class CatListViewModel: ObservableObject {
let store: Store<AppState>
...
}
Cannot
fi
nd type 'AppState' in scope
init(store: Store<AppState>) {
viewModel = CatListViewModel(store: store)
}
let catListMiddleware: Middleware<AppState>
= createThunkMiddleware()
let fetchCats = Thunk<AppState> { dispatch, getState in
Build the new package

59. Use the CatListState
instead of the AppState!

60. Build the new package
Middleware<AppState> Middleware<CatListState>
Store<AppState> Store<CatListState>

61. Build the new package
Middleware<AppState> Middleware<CatListState>
Store<AppState> Store<CatListState>
For sure this will be a problem when we
will try to build the main application

62. Build the new package

63. Build Succeeded!
Build the new package

64. var store = Store<AppState>(reducer: appReducer,
state: nil,
middleware: [catListMiddleware])
Type of expression is ambiguous
without more context
Build the application: Middleware

65. f(x) = y
f: Middleware<CatListState> -> Middleware<AppState>
Build the application: Middleware

66. public typealias DispatchFunction = (Action) -> Void
Build the application: Middleware

67. public typealias DispatchFunction = (Action) -> Void
public typealias Middleware<State> =
(@escaping DispatchFunction, @escaping () -> State?)
-> (@escaping DispatchFunction) -> DispatchFunction
Build the application: Middleware

68. public typealias DispatchFunction = (Action) -> Void
public typealias Middleware<State> =
(@escaping DispatchFunction, @escaping () -> State?)
-> (@escaping DispatchFunction) -> DispatchFunction
func function
}
}
) -> Middleware<GlobalState> {
return { globalDispatchFunction, globalStateGetter in
Build the application: Middleware
(input: Middleware<LocalState>

69. public typealias DispatchFunction = (Action) -> Void
public typealias Middleware<State> =
(@escaping DispatchFunction, @escaping () -> State?)
-> (@escaping DispatchFunction) -> DispatchFunction
func function
}
}
) -> Middleware<GlobalState> {
return { globalDispatchFunction, globalStateGetter in
Build the application: Middleware
(input: Middleware<LocalState>,
state: KeyPath<GlobalState, LocalState>

70. public typealias DispatchFunction = (Action) -> Void
public typealias Middleware<State> =
(@escaping DispatchFunction, @escaping () -> State?)
-> (@escaping DispatchFunction) -> DispatchFunction
func function
}
}
) -> Middleware<GlobalState> {
return { globalDispatchFunction, globalStateGetter in
Build the application: Middleware
(input: Middleware<LocalState>,
state: KeyPath<GlobalState, LocalState>
return input(globalDispatchFunction, { globalStateGetter()?[keyPath: state] })

71. public typealias DispatchFunction = (Action) -> Void
public typealias Middleware<State> =
(@escaping DispatchFunction, @escaping () -> State?)
-> (@escaping DispatchFunction) -> DispatchFunction
func pullback
}
}
) -> Middleware<GlobalState> {
return { globalDispatchFunction, globalStateGetter in
Build the application: Middleware
(input: Middleware<LocalState>,
state: KeyPath<GlobalState, LocalState>
return input(globalDispatchFunction, { globalStateGetter()?[keyPath: state] })

72. var store = Store<AppState>(reducer: appReducer,
state: nil,
middleware: [catListMiddleware])
Build the application: Middleware

73. var store = Store<AppState>(reducer: appReducer,
state: nil,
middleware: [pullback(input: catListMiddleware,
state: .catListState)])
Build the application: Middleware

74. @main
struct CatsApp: App {
var body: some Scene {
WindowGroup {
CatListView(store: store)
}
}
}
Cannot convert value of type 'Store<AppState>'
to expected argument type 'Store<CatListState>'
Build the application: Store

75. f(x) = y
f: Store<AppState> -> Store<CatListState>
Build the application: Store

76. func function(
typealias Reducer<State> =
(_ action: Action, _ state: State?) -> State
}
}
) -> Store<LocalState> {
Build the application: Store
extension Store {

77. func function(
typealias Reducer<State> =
(_ action: Action, _ state: State?) -> State
}
}
) -> Store<LocalState> {
Build the application: Store
extension Store {
state: KeyPath<State, LocalState>,
defaultState: LocalState
Store(reducer: { action, localState in
dispatch(action)
return self.state?[keyPath: state] ?? defaultState
}, state: self.state?[keyPath: state])

78. func function(
typealias Reducer<State> =
(_ action: Action, _ state: State?) -> State
}
}
) -> Store<LocalState> {
Build the application: Store
extension Store {
state: KeyPath<State, LocalState>,
defaultState: LocalState
Store(reducer: { action, localState in
dispatch(action)
return self.state?[keyPath: state] ?? defaultState
}, state: self.state?[keyPath: state])

79. Build the application: Store

80. Build the application: Store
This is not the correct way to do it!
The app doesn’t work anymore!

81. Build the application: Store
LocalStore

82. Build the application: Store
LocalStore LocalView
Updates

83. Build the application: Store
LocalStore
LocalReducer
LocalView
Action
Updates

84. Build the application: Store
LocalStore
LocalReducer
LocalView
Reducer
Action
Action
Updates

85. Build the application: Store
LocalStore
LocalReducer
LocalView
Store
Reducer
Action
Action Updates
Updates

86. Build the application: Store
LocalStore
LocalReducer
LocalView
Store
Reducer
Action
Action Updates No-one
listening
here
Updates
Updates

87. Build the application: Store
LocalStore
LocalReducer
LocalView
Store
Reducer
Action
Action Updates No-one
listening
here
Updates
Updates
Let’s change approach!
Create a wrapper instead!

88. Build the application: Store
class LocalStore {
let dispatchFunction: DispatchFunction
let subscribeFunction: (StoreSubscriber) -> Void
let unsubscribeFunction: (AnyStoreSubscriber) -> Void
let getState: () -> State
}

89. Build the application: Store
public var state: State {
getState() }
public func dispatch(_ action: Action) {
self.dispatchFunction(action) }
public func subscribe(_ subscriber: StoreSubscriber) {
subscribeFunction(subscriber) }
public func unsubscribe(_ subscriber: AnyStoreSubscriber) {
unsubscribeFunction(subscriber) }

90. func function(
typealias Reducer<State> =
(_ action: Action, _ state: State?) -> State
}
}
) -> LocalStore<LocalState> {
Build the application: Store
extension Store {

91. LocalStore(getState: { self.state[keyPath: state] },
dispatchFunction: { self.dispatch($0) },
subscribeFunction: { self.subscribe($0) { $0.select { $0[keyPath: state] }} },
unsubscribeFunction: { self.unsubscribe($0) })
func function(
typealias Reducer<State> =
(_ action: Action, _ state: State?) -> State
}
}
) -> LocalStore<LocalState> {
Build the application: Store
extension Store {
state: KeyPath<State, LocalState>

92. LocalStore(getState: { self.state[keyPath: state] },
dispatchFunction: { self.dispatch($0) },
subscribeFunction: { self.subscribe($0) { $0.select { $0[keyPath: state] }} },
unsubscribeFunction: { self.unsubscribe($0) })
func view(
typealias Reducer<State> =
(_ action: Action, _ state: State?) -> State
}
}
) -> LocalStore<LocalState> {
Build the application: Store
extension Store {
state: KeyPath<State, LocalState>

93. @main
struct CatsApp: App {
var body: some Scene {
WindowGroup {
CatListView(store: store.view(state: .catListState))
}
}
}
Build the application: Store

95. Build Succeeded!

97. Summary

98. Summary
• ReSwift: implement Redux in Swift

99. Summary
• ReSwift: implement Redux in Swift
• Modularization: a lot of bene
fi
ts

100. Summary
• ReSwift: implement Redux in Swift
• Modularization: a lot of bene
fi
ts
• Pullback to handle middlewares

101. Summary
• ReSwift: implement Redux in Swift
• Modularization: a lot of bene
fi
ts
• LocalStore wrapper implementation
• Pullback to handle middlewares

102. Summary
• ReSwift: implement Redux in Swift
• Modularization: a lot of bene
fi
ts
• LocalStore wrapper implementation
• Pullback to handle middlewares
• Store view function to assign local store to modules

103. Links
• Project: https://github.com/Gioevi90/Kittens
• Point-free: https://www.pointfree.co/collections/composable-architecture

104. Questions