How to update a SwiftUI navigationlink view from an observableObject?

Consider this MRE

struct ContentView: View {
    @StateObject var vm = VM()
    var body: some View {
        NavigationStack {
            VStack {
                ForEach(vm.list, id: \.self) { int in
                    NavigationLink {
                        DetailView(vm: vm, x: int)
                    } label: {
                        Text("\(int)")
                    }
                }
                Button {
                    vm.changeFirstElement()
                } label: {
                    Text("change")
                }
            }
        }
    }
}

struct DetailView: View {
    @ObservedObject var vm: VM
    let x: Int
    var body: some View {
        VStack {
            Text("\(x)")
            Button {
                vm.changeFor(index:x) //how to make this work?
            } label: {
                Text("change")
            }
        }
    }
}

class VM: ObservableObject {
    @Published var list = [1, 2, 3, 4]
    func changeFirstElement() {
        list[0] = 5
    }
}

You can see that in the main view, change() works, the view redraws

But inside the detail view, even though it has observed object it doesn't. How can I make it so that changes in the data model is reflected even inside the Detail View?

In SwiftUI, there are many cases (like ForEach and List) where it's useful to have Identifiable data. In fact, if you're using id: self, it's usually a sign of something going wrong.

By using an Identifiable model, everything "just works":

struct Item: Identifiable {
    var id = UUID()
    var value: Int
}

struct ContentView: View {
    @StateObject var vm = VM()
    var body: some View {
        NavigationStack {
            VStack {
                ForEach(vm.list) { item in
                    NavigationLink {
                        DetailView(vm: vm, item: item)
                    } label: {
                        Text("\(item.value)")
                    }
                }
                Button {
                    vm.change()
                } label: {
                    Text("change")
                }
            }
        }
    }
}

struct DetailView: View {
    @ObservedObject var vm: VM
    let item: Item
    var body: some View {
        VStack {
            Text("\(item.value)")
            Button {
                vm.change()
            } label: {
                Text("change")
            }
        }
    }
}

class VM: ObservableObject {
    @Published var list: [Item] = [.init(value: 1), .init(value: 2), .init(value: 3)]
    func change() {
        list[0].value = 5
    }
}

Note that it's also debatable whether you would need the VM at all here -- you could just use a Binding from the ForEach. Here's a version using a Binding on the ForEach:

struct Item: Identifiable {
    var id = UUID()
    var value: Int
}

struct ContentView: View {
    @StateObject var vm = VM()
    var body: some View {
        NavigationStack {
            VStack {
                ForEach($vm.list) { $item in
                    NavigationLink {
                        DetailView(item: $item)
                    } label: {
                        Text("\(item.value)")
                    }
                }
                Button {
                    vm.list[0].value = 5
                } label: {
                    Text("change")
                }
            }
        }
    }
}

struct DetailView: View {
    @Binding var item: Item
    var body: some View {
        VStack {
            Text("\(item.value)")
            Button {
                item.value = 5
            } label: {
                Text("change")
            }
        }
    }
}

class VM: ObservableObject {
    @Published var list: [Item] = [.init(value: 1), .init(value: 2), .init(value: 3)]
}

And, if for some reason you truly need to use indices, you can do this:

struct Item: Identifiable {
    var id = UUID()
    var value: Int
}

struct ContentView: View {
    @StateObject var vm = VM()
    var body: some View {
        NavigationStack {
            VStack {
                ForEach(Array(vm.list.enumerated()), id: \.element.id) { (index, item) in
                    NavigationLink {
                        DetailView(vm: vm, item: item, index: index)
                    } label: {
                        Text("\(item.value)")
                    }
                }
                Button {
                    vm.changeFirstElement()
                } label: {
                    Text("change")
                }
            }
        }
    }
}

struct DetailView: View {
    @ObservedObject var vm: VM
    let item: Item
    let index: Int
    
    var body: some View {
        VStack {
            Text("\(item.value)")
            Button {
                vm.changeAtIndex(index)
            } label: {
                Text("change")
            }
        }
    }
}

class VM: ObservableObject {
    @Published var list: [Item] = [.init(value: 1), .init(value: 2), .init(value: 3)]
    func changeFirstElement() {
        list[0].value = 5
    }
    
    func changeAtIndex(_ index: Int) {
        list[index].value = 5
    }
}