SwiftUI: How to implement NavigationLinks in List with mutable data?

The answer proposed is absolutely fine, but let me propose a more complete one using the MVVM design pattern.

First of all you will need a model to describe your data, some call this data-class from other languages, but in Swift this is most commonly described as a struct.

//
//  ItemModel.swift
//  Design Pattern
//
//  Created by Allan Garcia on 04/03/23.
//

import Foundation

struct Item: Hashable, Identifiable {
    let id = UUID()
    var text: String
}

Then, in MVVM pattern you have a "middle-man" that is responsible to Store this data, manage it, save it, detect changes and let the View redraw itself via radio-tuning into this "station" called ObservableObject.

This is an example of one for this case:

//
//  ItemStorageViewModel.swift
//  Design Pattern
//
//  Created by Allan Garcia on 04/03/23.
//

import SwiftUI

class ItemStorageViewModel: ObservableObject {
    
    @Published var items: [Item]
    
    init() {
        items = ItemStorageViewModel.addSomeExampleItems()
    }
    
    static func addSomeExampleItems() -> [Item] {
        let item1 = Item(text: "foo")
        let item2 = Item(text: "bar")
        return [item1, item2]
    }
    
    func save(_ item: Item) -> Void {
        if let index = items.firstIndex(where: { $0.id == item.id }) {
            items[index] = item
        } else {
            print("Couldn't find the index.")
        }
    }
}

This class have two responsibilities: first, publish the changes of the Item array to the world, whoever are instances of this view-model, this is accomplished using the decorator @Published, and an intent to save in his storage "var items" when someone want to change it's values.

Look that a more appropriate way to describe this var is using private(set) visibility, but I let this pass.

The static func is just a helper function to play well with previews in Xcode.

Then you want to show the list of this Storage into some view...

Now you don't need a NavigationLink(Item.self, item: item), because this is a Struct suitable when you have several models that you want to show into the same List. You can use the more simpler Struct NavigationLink(destination:label) that is presented here.

For destination you will provide the View that you what to show with all parameters necessary.

In the label only what will be seen in the List.

Like so:

//
//  ItemListView.swift
//  Design Pattern
//
//  Created by Allan Garcia on 04/03/23.
//

import SwiftUI

struct ItemListView: View {
    
    @ObservedObject private var viewModel = ItemStorageViewModel()
    
    var body: some View {
        NavigationStack {
            List(viewModel.items) { item in
                NavigationLink {
                    ItemEditItemView(viewModel: viewModel, editingItem: item)
                } label: {
                    Text(item.text)
                }
            }
            .navigationTitle("Items")
        }
    }
}


struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ItemListView()
    }
}

Last but not least, here is the mock view of the Editing an Item of your model and calling the apropriate Intent into the view-model, this could be customized to look better than this.

//
//  ItemEditItemView.swift
//  Design Pattern
//
//  Created by Allan Garcia on 04/03/23.
//

import SwiftUI

struct ItemEditItemView: View {
        
    @ObservedObject var viewModel: ItemStorageViewModel
    
    @State var editingItem: Item
    
    @Environment(\.presentationMode) var presentationMode: Binding<PresentationMode>
    
    var body: some View {
        VStack {
            TextField("Edit text:", text: $editingItem.text)
                .padding()
            HStack {
                Button {
                    self.viewModel.save(editingItem)
                    
                    self.presentationMode.wrappedValue.dismiss()
                } label: {
                    Text("Save")
                        .padding()
                        .bold()
                }
                Button {
                    self.presentationMode.wrappedValue.dismiss()
                } label: {
                    Text("Cancel")
                        .padding()
                        .foregroundColor(.red)
                }
            }
            Spacer()
//            Text("Debug EditingText")
//                .foregroundColor(.red)
//                .bold()
//            Text("Editing text is: \(editingItem.text)")
        }
        .navigationTitle("Editing Item")
        .navigationViewStyle(.stack)
    }
}

struct ItemEditItemView_Previews: PreviewProvider {
    static var previews: some View {
        let vc = ItemStorageViewModel()
        
        ItemEditItemView(viewModel: vc, editingItem: vc.items.first!)
    }
}

Hope this add some value to the answer already mentioned here.