How can you refer to a generic type as one it inherits from?

I have a MutableStorage protocol which is designed to store the generic Item type. I have another protocol ImmutableStorage which it inherits from, which is meant to be a read-only version of the MutableStorage. This part works fine.

What I would like to do is specify this storage as a generic and have access to both the mutable type and immutable types within that class.

For example, this StorageExample class takes the MutableStorage as a generic which it can use for its mutable property, which is exactly what I want. The problem I run into is in the colectItems(:) method where I would prefer to specify the equivalent ImmutableStorage type.

Is there a way to do this with the protocols I have defined? Or is the answer that I must not have the protocol inheritance between MutableStorage/ImmutableStorage and need to have one be an associated type of the other?

class StorageExample<S: MutableStorage> {
  private var mutableStorage: S
  init(mutableStorage: S) {
    self.mutableStorage = mutableStorage
  }

  func collectItems(_ collector: (S) -> [S.StorageItem]) {
    let itemUpdates = collector(mutableStorage) // <-- How can I pass an `ImmutableStorage` type
    for item in itemUpdates {
      mutableStorage.contents[item.key] = item
    }
  }
}

/// Read/write storage of the items.
protocol MutableStorage: ImmutableStorage {
  var contents: [StorageItem.Key: StorageItem] { get set }
}

/// Item storage that can be inspected but not changed.
protocol ImmutableStorage {
  associatedtype StorageItem: Item
  var contents: [StorageItem.Key: StorageItem] { get }
}

/// An item that can be stored.
protocol Item {
  associatedtype Key: Hashable
  associatedtype Data
  var key: Key { get }
  var data: Data { get }
}

If you intend for collector to accept an ImmutableStorage, you can pass that. I recommend adjusting your ImmutableStorage to a have a primary type:

protocol ImmutableStorage<StorageItem> {
    associatedtype StorageItem: Item
    var contents: [StorageItem.Key: StorageItem] { get }
}

In which case you can then pass a more appropriate collector:

func collectItems(_ collector: (any ImmutableStorage<S.StorageItem>) -> [S.StorageItem]) {

That said, this would probably be better implemented by passing the contents, which are a value type (and so the mutability doesn't matter):

func collectItems(_ collector: ([S.StorageItem.Key: S.StorageItem]) -> [S.StorageItem]) {
    let itemUpdates = collector(mutableStorage.contents)
    ...

Another solution to this is to just have separate protocols rather than unnecessary inheritance. This lets you refer to the immutable type directly via the associated type.

/// Item storage that can be inspected but not changed.
protocol ImmutableStorage {
  associatedtype StorageItem: Item
  var contents: [StorageItem.Key: StorageItem] { get }
}

protocol MutableStorage {
  associatedtype Immutable: ImmutableStorage  // <-- Can refer to the Immutable storage type
  var contents: [Immutable.StorageItem.Key: Immutable.StorageItem] { get set }
  var readOnly: Immutable { get }
}

class StorageExample<S: MutableStorage> {

  func collectItems(_ collector: (S.Immutable) -> [S.Immutable.StorageItem]) { 
    (...)
  }
}