swift-composable-architecture VS SwiftUIBestPracticeExperimentation

One point that's not being discussed enough -- using SwiftUI (since it's heavily value-typed / struct-based) prevents a whole host of problems around retain cycles, typically the bugbear of iOS dev. I recently built an iOS app from scratch with recent grads with zero Swift experience (but had done React).

It was ~2mo before they even had to learn what a retain cycle was, and that was from using UIKit.

Of course you still eventually see this if / when you use `@ObservedObjects` and their implementation, but in our case we were also using https://github.com/pointfreeco/swift-composable-architecture which hides this away as well.

There’s a nice open source swift library by the pointfree guys, called The Composable Architecture (TCA). Check it out 🙂

It looks like you reinvented the Reducer pattern, have you had a look at Composable Architecture?

[Books by Objc.io](https://www.objc.io/books/) are great. Also whilst not a book, [Composable Architecture](https://github.com/pointfreeco/swift-composable-architecture) seems like a nice way to develop cross platform (iOS/macOS) apps.

Regarding MVVM, since your list is very SwiftUI-forward (which is great) I’m surprised that the Composable Architecture pattern was not mentioned. (https://github.com/pointfreeco/swift-composable-architecture)

I use a variation on The Binder Architecture. Another one I like a lot and that works well with SwiftUI is The Composable Architecture.

Check out pointfree’s composable architecture series GitHub repository

The Composable Architecture is a must-have. It provides the most complete and battle-hardened architecture - check out the examples in the repo, or check out their videos on it called A tour of The Composable Architecture, which should give you a good overview of what it looks like and its benefits.

Do take a look at https://github.com/pointfreeco/swift-composable-architecture and their videos though

Give a try? Why not? Maybe you will like this as well: https://github.com/pointfreeco/swift-composable-architecture

If neither of these approaches are appropriate, chances are you're in a spot where object lifetimes are somewhat complicated and you'll need to come up with some dependency resolution method (like a DI-container). This is where SwiftUI's current provisions prove to be inadequate (e.g. @StateObject) and you may need to try something more like what I've done here or, as I said, find some DI container package that works for this purpose.

I settled on something similar recently (visible on my github).

The main driver in my approach (ViewContainer) is similar to your ModelledViewFactory, with the main purpose being to solve the dependency injection problem (i.e. supplying Environment concerns to view models).