Why does sorted(by:) work but sort(by:) does not in ForEach loop - swift

Question

I am trying to show a list of custom objects in an ordered manner.
While this works...
import SwiftUI
struct MyModel: Identifiable {
let id = UUID()
let timestamp: Date
}
struct ViewModel {
var models = [
MyModel(timestamp: Date().addingTimeInterval(300)),
MyModel(timestamp: Date().addingTimeInterval(100)),
MyModel(timestamp: Date().addingTimeInterval(500))
]
}
struct MyView: View {
#State var viewModel = ViewModel()
var body: some View {
List {
ForEach(viewModel.models.sorted(by: { (lhs, rhs) -> Bool in // will not work with `sort(by:)`
lhs.timestamp > rhs.timestamp
})) { model in
Text("\(model.timestamp)")
}
.onDelete(perform: { indexSet in
//delete from viewModel.models
})
}
}
}
...it falls short when deleting, because the array I am working on is not sorted (only it's visualisation, so to say).
sort(by:) should be what I need, as it "Sorts the collection in place, using the given predicate as the comparison between elements." according to Apple's documentation.
However, the same ForEach statement will not work for sort(by:), throwing the error Cannot convert value of type '()' to expected argument type 'Range<Int>'.
Is there a way to sort in place and loop with ForEach in this case or will I have to handle sorting in my ViewModel?

Answer 1

The reason why you can't use sort(by:) inside the ForEach is because sort(by:) is a mutating function that returns Void. sorted(by:) on the other hand returns a new array that you can iterate through with the ForEach.
You can solve your problem by creating a separate computed property on ViewModel, which return models sorted and calling ForEach with this sorted properties. You just need to make sure you also perform deletion on the sorted array.
struct ViewModel {
var models = [
MyModel(timestamp: Date().addingTimeInterval(300)),
MyModel(timestamp: Date().addingTimeInterval(100)),
MyModel(timestamp: Date().addingTimeInterval(500))
]
var sortedModels: [MyModel] {
get {
models.sorted(by: { $0.timestamp > $1.timestamp })
}
set {
models = newValue
}
}
}
struct MyView: View {
#State var viewModel = ViewModel()
var body: some View {
List {
ForEach(viewModel.sortedModels) { model in
Text("\(model.timestamp)")
}
.onDelete(perform: { indexSet in
for index in indexSet {
viewModel.sortedModels.remove(at: index)
}
})
}
}
}

Answer 2

No need to create a computed property. You can simply sort the models when your list appears. No need to sort it every time you delete a model if they are already sorted. You should also conform your model to comparable protocol:
import SwiftUI
struct ContentView: View {
#State var viewModel = ViewModel()
var body: some View {
List {
ForEach(viewModel.models) {
Text("\($0.timestamp)")
}
.onDelete {
$0.reversed().forEach { viewModel.models.remove(at: $0) }
}
}.onAppear {
viewModel.models.sort(by: >)
}
}
}
struct MyModel: Identifiable {
let id = UUID()
let timestamp: Date
}
extension MyModel: Comparable {
static func < (lhs: Self, rhs: Self) -> Bool {
lhs.timestamp < rhs.timestamp
}
}
struct ViewModel {
var models = [
MyModel(timestamp: Date().addingTimeInterval(300)),
MyModel(timestamp: Date().addingTimeInterval(100)),
MyModel(timestamp: Date().addingTimeInterval(500))
]
}
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView()
}
}

Answer 3

In addition to the other two answers, I'd like to add some more information regards how you're meant to use ViewModels.
Essentially you want to have a ViewModel that is a ObservableObject with a #Published property for the values you expect to change. That way you can encapsulate any important logic inside the ViewModel.
Having a struct ViewModel doesn't make any sense, as structs aren't mutable.
Furthermore you can implement Comparable on your model type, allowing you to have sorting tied to the type, rather than at random places in your code. Now how it's also not necessary to re-sort the content when you delete individual models if your model is already sorted.
And if you had inserts, you would want to sort them when inserting.
And finally, you should only use #State variables for UI state, not (View)Model state.
import SwiftUI
struct MyModel: Identifiable, Equatable, Comparable {
let id = UUID()
let timestamp: Date
static func < (lhs: MyModel, rhs: MyModel) -> Bool {
return lhs.timestamp > rhs.timestamp
}
}
class ViewModel: ObservableObject {
#Published
private(set) var models: [MyModel]
init() {
let now = Date()
models = [
MyModel(timestamp: now.addingTimeInterval(300)),
MyModel(timestamp: now.addingTimeInterval(100)),
MyModel(timestamp: now.addingTimeInterval(500))
].sorted()
}
func remove(at indicies: IndexSet) {
indicies.forEach { index in
models.remove(at: index)
}
}
}
struct ContentView: View {
#ObservedObject
var viewModel = ViewModel()
var body: some View {
List {
ForEach(viewModel.models) { model in
Text("\(model.timestamp)")
}
.onDelete(perform: { indexSet in
viewModel.remove(at: indexSet)
})
}
}
}