NavigationSplitView - SwiftUI.AnyNavigationPath.Error.comparisonTypeMismatch

Receiving error:

SwiftUI/NavigationColumnState.swift:520: Fatal error: 'try!' expression unexpectedly raised an error: SwiftUI.AnyNavigationPath.Error.comparisonTypeMismatch`

When a NavigationSplitView's detail view changes, and the detail view moving from has a NavigationStack(path: ...).

This seems like a bug, though usually when I think that I've done something silly. Would love to know a workaround or fix if anyone can figure it out.

Xcode: Version 14.3 (14E222b)
Simulators: iPad Air (5th Generation) / My Mac (designed for iPad)

Models

import SwiftUI 

final class AppModel: ObservableObject {
    @Published var appNavigation: AppNavigation? = .lists
    @Published var listsNavigation: [ListsNavigation] = []
    @Published var settingsNavigation: [SettingsNavigation] = []
}

enum AppNavigation {
    case lists, settings
}

enum SettingsNavigation {
    case settings1, settings2
}

enum ListsNavigation {
    case favourites, notes
}

App.swift

import SwiftUI

@main
struct splittyApp: App {
    @StateObject private var model = AppModel()

    var body: some Scene {
        WindowGroup {
            NavigationSplitView {
                List(selection: $model.appNavigation) {
                    NavigationLink(value: AppNavigation.lists) {
                        Label("Lists", systemImage: "list.clipboard")
                    }
                    
                    NavigationLink(value: AppNavigation.settings) {
                        Label("Settings", systemImage: "gearshape")
                    }
                }
            } detail: {
                switch model.appNavigation {
                case .lists: ListsView()
                case .settings: SettingsView()
                case .none: Text("Error")
                }
            }
            .environmentObject(model)
        }
    }
}

*ListsView

import SwiftUI

struct ListsView: View {
    @EnvironmentObject private var model: AppModel

    var body: some View {
        NavigationStack(path: $model.listsNavigation) {
            List {
                NavigationLink(value: ListsNavigation.favourites) {
                    Text("Favourites")
                }
                
                NavigationLink(value: ListsNavigation.notes) {
                    Text("Notes")
                }
            }
            .navigationDestination(for: ListsNavigation.self) { value in
                switch value {
                case .favourites: Text("Favourites View")
                case .notes: Text("Notes View")
                }
            }
        }
    }
}

SettingsView

import SwiftUI

struct SettingsView: View {
    @EnvironmentObject private var model: AppModel

    var body: some View {
        NavigationStack(path: $model.settingsNavigation) {
            List {
                NavigationLink(value: SettingsNavigation.settings1) {
                    Text("Settings 1")
                }
                
                NavigationLink(value: SettingsNavigation.settings2) {
                    Text("Settings 2")
                }
            }
            .navigationDestination(for: SettingsNavigation.self) { value in
                switch value {
                case .settings1: Text("Settings 1")
                case .settings2: Text("Setings 2")
                }
            }
        }
    }
}

Example Project: https://www.dropbox.com/s/jlxct4qeac8kt75/splitty.zip?dl=0

Steps to reproduce:

• Launch app on iPad
• Tap between main app navigation (lists/settings)

The error occurs because you use two different navigation enum types in the detail view NavigationStack.

Even though you define two NavigationStacks, one in each detail subview, SwiftUI creates only one. So these two codes act identical:

NavigationSplitView {
    ...
} detail: {
    View1()
    View2()
}


View1() ... {
    NavigationStack(path: $pathA) { ... }
}

View2() ... {
    NavigationStack(path: $pathA) { ... }
}

is identical to:

NavigationSplitView {
    ...
} detail: {
    NavigationStack(path: $pathA ? $pathB ?) { // which type?
        View1()
        View2()
    }
}

View1() ... {
}

View2() ... {
}

The second version makes it apparent, why SwiftUI struggles. It finds values of two different types in the path.

The documentation says it, but in a quite cryptical way:

> You can also embed a NavigationStack in a column. ... Activating a
> link in the same column adds a view to the stack. Either way, the
> link must present a data type for which the stack has a corresponding
> navigationDestination(for:destination:) modifier.

Solution:

The solution for the problem is to use the special type erased NavigationPath for both path vars. It has been introduced exactly for this purpose:

final class AppModel: ObservableObject {
    @Published var appNavigation: AppNavigation? = .lists
    @Published var listsNavigation = NavigationPath()
    @Published var settingsNavigation = NavigationPath()
}