How to prevent strong reference cycles when using Apple's new Combine framework (.assign is causing problems)

How about:

class Test { @Published var name: String = "" deinit { print("deinit") } init(publisher: CurrentValueSubject<String, Never>) { publisher.assign(to: &$name) } 

}

This version of the assign operation manages memory internally (does not return AnyCancellable), as it dies together with the object. Note you need to convert your property to @Published.

I don't know what you have against closures but the solution is to not use self in the assign:

import Combine import SwiftUI class NameStore { var name: String init() { name = "" } deinit { print("deinit NameStore") } } class Test { private var nameStore = NameStore() public var name: String { get { return nameStore.name } } var subscriber: AnyCancellable? = nil deinit { print("deinit Test") } init(publisher: CurrentValueSubject<String, Never>) { subscriber = publisher.print().assign(to: \NameStore.name, on: nameStore) } } let publisher = CurrentValueSubject<String, Never>("Test") var test: Test? = Test(publisher: publisher) struct ContentView : View { var body: some View { Button( action: { test = nil }, label: {Text("test = nil")} ) } } 

As far as I can see weak references are only allowed in closures so that wasn't the answer. Putting the reference into another object meant that both could be released.

I added a ContentView because it makes it easier to play with and I added a print to the pipeline to see what was happening. The computed name is probably not necessary, it just made it look the same as you had. I also removed the Set, it's probably useful but I haven't worked out when.

You should remove stored AnyCancellable from disposeBag to release Test instance.

import UIKit import Combine private var disposeBag: Set<AnyCancellable> = Set() class Test { public var name: String = "" deinit { print("deinit") } init(publisher: CurrentValueSubject<String, Never>) { publisher.assign(to: \.name, on: self).store(in: &disposeBag) } } let publisher = CurrentValueSubject<String, Never>("Test") var test: Test? = Test(publisher: publisher) disposeBag.removeAll() test = nil 

or use optional disposeBag

import UIKit import Combine class Test { public var name: String = "" private var disposeBag: Set<AnyCancellable>? = Set() deinit { print("deinit") } init(publisher: CurrentValueSubject<String, Never>) { guard var disposeBag = disposeBag else { return } publisher.assign(to: \.name, on: self).store(in: &disposeBag) } } let publisher = CurrentValueSubject<String, Never>("Test") var test: Test? = Test(publisher: publisher) test = nil 

In addition to previously recommended way of using @Published property or .sink() there is another way to break strong reference cycle.

From documentation:

The Subscribers/Assign instance created by this operator maintains a strong reference to object, and sets it to nil when the upstream publisher completes (either normally or with an error).

So sending completion event when you don't need updates from publisher will break reference cycle.

In this case:

publisher.send(completion: .finished) 

import protocol Combine.Publisher import class Combine.AnyCancellable fileprivate struct RootUnownedWrapper<R: AnyObject> { unowned var root: R init(_ root: R) { self.root = root } } fileprivate struct RootWeakWrapper<R: AnyObject> { weak var root: R! init(_ root: R) { self.root = root } } extension Publisher where Self.Failure == Never { typealias TRootKeyPath<T> = ReferenceWritableKeyPath<T, Self.Output> fileprivate typealias TWeakKeyPath<T: AnyObject> = WritableKeyPath<RootWeakWrapper<T>, T> func assignWeakly<Root: AnyObject>(to keyPath: TRootKeyPath<Root>, on object: Root) -> AnyCancellable { let wrapped = RootWeakWrapper(object) let wkp: TWeakKeyPath<Root> = \.root return assign(to: wkp.appending(path: keyPath), on: wrapped) } fileprivate typealias TUnownedKeyPath<T: AnyObject> = WritableKeyPath<RootUnownedWrapper<T>, T> func assignUnowned<Root: AnyObject>(to keyPath: TRootKeyPath<Root>,on object: Root) -> AnyCancellable { let wrapped = RootUnownedWrapper(object) let wkp: TUnownedKeyPath<Root> = \.root return assign(to: wkp.appending(path: keyPath), on: wrapped) } }