Idea for basic ViewModel - View - ViewController structure with property wrappers

ModelView.swift

import UIKit

/// Any model struct used as a ViewModel. Must at least conform to `Equatable` to do some diffing
public protocol ViewModellable: Equatable { }

/// Protocol declaring `ModelView` behavior
public protocol ModelViewable<Model>: UIView {
	
	associatedtype Model: ViewModellable
	var model: Model { get }
	
	/// Creates a new model view with an initial frame and a view model proxy
	init(frame: CGRect, model: ViewModelProxy<Model>)
	/// Create, place and position subviews with this method, so subclassed don‘t need to override ``init(frame:model:)`` (and the coder one)
	func setupView()
	/// Notifies model view that `ViewModel` has been updated
	func modelDidUpdate()
}

/// Base class all your model views should inherit from
open class ModelView<Model: ViewModellable>: UIView, ModelViewable {

	/// Proxy to the model stored in parent ``ModelViewController`` subclass
	@ViewModelProxy public var model: Model

	public required init(frame: CGRect = .zero, model: ViewModelProxy<Model>) {
		_model = model
		super.init(frame: frame)
		setupView()
		modelDidUpdate()
	}

	public required init?(coder: NSCoder) {
		fatalError("init(coder:) has not been implemented")
	}

	open func setupView() { }

	open func modelDidUpdate() { }
}

public protocol ModelViewControllable<ModelView>: UIViewController {
	associatedtype ModelView: ModelViewable
	
	var model: ModelView.Model { get set }
	var modelView: ModelView { get }
}

Usage.swift

class TestView: ModelView<TestView.Model> {
    
    struct Model: ViewModellable {
        var text: String = "Pressed: "
        var timesPressed = 0
    }
    
    private(set) lazy var button = UIButton(
        configuration: UIButton.Configuration.borderedProminent(),
        primaryAction: UIAction { [unowned self] action in
            self.model.timesPressed += 1
        }
    )
    
    override func setupView() {
        backgroundColor = .white
        addSubview(button)
		// Auto Layout convenience method from https://github.com/PimCoumans/ConstraintBuilder
        button.centerInSuperview()
    }
    
    override func modelDidUpdate() {
        button.configuration?.title = model.text + "\(model.timesPressed)" + " times"
    }
}

class TestViewController: UIViewController, ModelViewControllable {
    
	@ViewModel
	var viewModel = TestView.Model()
	
	private(set) lazy var modelView = TestView(model: $viewModel)
	
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        
        // Simulate network request or whatever
        DispatchQueue.main.asyncAfter(wallDeadline: .now() + 1) { [weak self] in
            self?.viewModel.text = "You‘ve pressed: "
        }
    }
}

ViewModelWrapper.swift

/// Creates a wrapper for any `ViewModellable`, providing an update handler and a proxy for other modellable views
/// Updates `modelView` in containing `ModelViewControllable` using tricks discussed in
/// https://www.swiftbysundell.com/articles/accessing-a-swift-property-wrappers-enclosing-instance/
@propertyWrapper
public class ViewModel<Model: ViewModellable> {
	
	public static subscript<ViewController: ModelViewControllable>(
		_enclosingInstance instance: ViewController,
		wrapped wrappedKeyPath: ReferenceWritableKeyPath<ViewController, Model>,
		storage storageKeyPath: ReferenceWritableKeyPath<ViewController, ViewModel>
	) -> Model {
		get {
			instance[keyPath: storageKeyPath].storage
		}
		set {
			instance[keyPath: storageKeyPath].storage = newValue
			instance.modelView.modelDidUpdate()
		}
	}
	
	@available(*, unavailable, message: "@ViewModelWrapper can only be applied to classes")
	public var wrappedValue: Model {
		get { fatalError() }
		set { fatalError() }
	}
	
	public var projectedValue: ViewModelProxy<Model> {
		ViewModelProxy(get: {
			self.storage
		}, set: {
			self.storage = $0
		})
	}
	
	private var storage: Model
	public init(wrappedValue: Model) {
		self.storage = wrappedValue
	}
}

/// Proxy model wrapper that forwards getters and setters to originating `ViewModelWrapper`
@propertyWrapper
public struct ViewModelProxy<Model: ViewModellable> {
	
	public var wrappedValue: Model {
		get {
			get()
		}
		nonmutating set {
			set(newValue)
		}
	}
	
	private let get: () -> Model
	private let set: (Model) -> Void
	
	internal init(get: @escaping () -> Model, set: @escaping (Model) -> Void) {
		self.get = get
		self.set = set
	}
}

See Usage.swift for typical usage. Here a counter is increased when a button in the view is pressed but from the view controller the model is updated after 1 second as well. The Model could’ve been defined outside TestView too, but having the struct in TestView makes both the model and the view more tightly connected.