Find an unique identifier for an enum case to conform to Identifiable

Question

I am testing RxDataSources which requires the models to conform to the Equatable and IdentifiableType(similar to Identifiable protocols.

I am using a unidirectional data flow to drive the UI and my model is the following enum:

enum ViewModelType: Equatable, IdentifiableType {
        case loading
        case post(Post)
        
        var identity: String {
            switch self {
            case .loading: return "???" // <-- What to choose here?
            case let .post(post): return String(post.id)
            }
        }
        
        static func == (lhs: ViewModel.ViewModelType, rhs: ViewModel.ViewModelType) -> Bool {
            switch (lhs, rhs) {
            case (.loading, .loading): return true
            case let (.post(l), .post(r)): return l == r
            default: return false
            }
        }
    }
}

Concerning the .loading ViewModelType, I have to find a possible stable unique identifier if I want to use multiple ViewModelType of this type at once like [.loading, .loading, .loading] or the diffing breaks from identical identifier.

I prepared a sample project to reproduce the issue: https://github.com/florianldt/RxDataSourcesIdentifiableType

Any ideas of possible stable unique identifiers I can find for this use case.

I think you need to change your design. Your 3 loading cells are, by definition, *not* identifiable. You physically cannot distinguish one loading cell from another. They are all the same. — Sweeper, Nov 08 '22 at 12:40
How do you know the number of Posts before calling the fetchPosts function? — Daniel T., Nov 08 '22 at 13:01
@DanielT. I don't. 3 loading cell is an arbitrary number, could be 2 or 4 it doesn't matter much — Florian Ldt, Nov 08 '22 at 13:05
Then how do you decide the number of cells to display? What will you do if the post count is different than the cell count? — Daniel T., Nov 08 '22 at 13:31
I set the number of loading cell to 3 arbitrary simply because it look good on the screen, you know on some app like Facebook or instagram, when you load the content you have multiple post skeletons. So it is like when loading -> 3 loading cells, then loaded -> x post cells — Florian Ldt, Nov 08 '22 at 13:34

Daniel T. · Accepted Answer · 2022-11-08T13:53:14.090

There are several changes you will need to make, all stemming from the fact that you are completely replacing your view model without regard to its previous state. When building a state machine, remember that the update is based on the input and the previous state. Here are the minimal changes you should make:

There is no need to build your own AnimatableSectionModelType. Simply use the one that the library provides. Replace your SingleSectionModel struct with the below:

typealias SingleSectionModel<T> = AnimatableSectionModel<String, T> where T: IdentifiableType & Equatable

Turn your ViewModelType into a struct instead of an enum:

struct ViewModelType: Equatable, IdentifiableType {
    let identity: UUID
    let post: Post?
}

By doing this, you assure that every value has an identity. You can tell that it is "loading" by the fact that post is nil.

Instead of completely replacing your view model every time it changes state, use its previous state to help determine the new state. This means removing your init(state:) function and adding these two functions:

func loading() -> ViewModel {
    ViewModel(
        state: .loading,
        viewModels: [
            ViewModelType(identity: UUID(), post: nil),
            ViewModelType(identity: UUID(), post: nil),
            ViewModelType(identity: UUID(), post: nil)
        ]
    )
}

func loaded(posts: [Post]) -> ViewModel {
    ViewModel(
        state: .loaded,
        viewModels: zip(viewModels, posts).map { ViewModelType(identity: $0.0.identity, post: $0.1) }
        + (posts.count > viewModels.count ? posts[viewModels.count...].map { ViewModelType(identity: UUID(), post: $0) } : [])
    )
}

Notice how now, all three view model types have different identities and when the posts come in, they are not changed. That is the key.

When you fetch your posts, you will need to use the previous state of the view model to make the updates:

private func fetchPosts() {
    viewModel.accept(viewModel.value.loading())
    Post.list()
        .subscribe(onSuccess: { [viewModel] posts in
            viewModel.accept(viewModel.value.loaded(posts: posts))
        })
        .disposed(by: disposeBag)
}

The rest of the changes should be pretty obvious.

score 0 · Answer 2 · answered Nov 08 '22 at 09:56

0

While I believe you shouldn't base your Data Sources on the state of whatever it is you're loading (if these are unique posts, try that post's ID instead), you can always use UUID (or, specifically, UUID().uuidString for a unique identifier string.

answered Nov 08 '22 at 09:56

Vym

463
3
9

Yes I know that this is possible. I did try it and can remove the crash, however, it is an unstable identifier as at every state change the id change as the how ViewModel is rebuilt – Florian Ldt Nov 08 '22 at 12:17

Find an unique identifier for an enum case to conform to Identifiable

2 Answers2