I’m working on a custom list that tracks an array of values, and publishes the array after filtering:

public final class List<T: Equatable> {

  @Published public private(set) var publishedValues = [T]()

  public var values: [T] { 
    didSet {
      guard values != oldValue else { return }
      updatePublishedValues()
    }
  } 

  public init(values: [T] = []) {
    self.values = values
    updatePublishedValues()
  }

  private func updatePublishedValues() {
    publishedValues = values.filter { /* filtering logic */ }
  }
}

For ease of use, I make the class conform to ExpressibleByArrayLiteral:

extension List {
  public convenience init(arrayLiteral: T...) { self.init(values: arrayLiteral) }
}

I have another class that holds a list and publishes the last value in the filtered list:

public class ListContainer<T: Equatable> {

  @Published public private(set) var publishedValue: T?

  public lazy var list: List<T> = {
    let list = List<T>()
    subscription = list.$publishedValues
      .map { $0.last }
      .assign(to: \.publishedValue, on: self)
    return list
  }()
  private var subscription: AnyCancellable?
}

Okay, so with this setup, let’s say we have a list container of Ints and that the value of 1 passes the filter operation. Making changes directly to List.values produces the correct result:

let listContainer = ListContainer<Int>()
listContainer.list.append(1)
print(listContainer.publishedValue == 1) => prints true

However, resetting the values using the assignment operator and ExpressibleByArrayLiteral does not work correctly:

let listContainer = ListContainer<Int>()
listContainer.list = [1]
print(listContainer.publishedValue == 1) => prints false

Inspecting the object hierarchy reveals that after this assignment, ObjectIdentifier(listContainer.list) remains unchanged, and listContainer.list.publishedValues == [1]. My only guess is that the subscription set up in the lazy instantiation closure has been cancelled at some point without my knowledge.

Now, I was surprised that assigning an array literal to listContainer.list even works at all, since lazy vars are treated as let constants after initialization. However, since this compiles, I don’t want to have the subscriptions silently fail and produce unexpected behavior (especially since it’s hard to detect because AnyCancellable doesn’t have an isCancelled property that we can check). Is there a way to prevent the subscription from being cancelled, given that we cannot override the assignment operator in Swift? One option would be to just remove the ExpressibleByArrayLiteral implementation and require all updates to go through listContainer.list.values, but I’d like to keep the syntactic sugar of array literal conversion if possible.