问表达式的类型是不明确的，在自定义类的“`ForEach`‘over数组中没有更多的上下文

EN

protocol ExpensePeriod: AnyObject, Identifiable, Hashable {
    associatedtype Period: ExpensePeriod
    
    var type: Calendar.Component { get set }
    var interval: DateInterval { get set }
    var start: Date { get }
    var end: Date { get }
    var expenses: FetchRequest<Expense> { get }
    
    static func array(from startDate: Date, to endDate: Date) -> [Period]
    
    init(from date: Date)
}

extension ExpensePeriod {
    
    var start: Date { interval.start }
    var end: Date { interval.end }
    var expenses: FetchRequest<Expense> {
        FetchRequest<Expense>(
            entity: Expense.entity(),
            sortDescriptors: [NSSortDescriptor(key: "datetime", ascending: false)],
            predicate: NSPredicate(
                format: "datetime > %@ AND datetime < %@",
                argumentArray: [start, end]
            )
        )
    }
    
    static func array(of timeComponent: Calendar.Component, from startDate: Date, to endDate: Date) -> [Self] {
        var currentDate = startDate
        var array = [Self(from: currentDate)]
        while !Calendar.current.dateInterval(of: timeComponent, for: currentDate)!.contains(endDate) {
            currentDate = Calendar.current.date(byAdding: timeComponent, value: 1, to: currentDate)!
            array.append(Self(from: currentDate))
        }
        return array
    }
    
    static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.interval == rhs.interval
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(interval)
    }
}

final class ExpenseYear: ExpensePeriod {
    
    typealias Period = ExpenseYear
    
    var type: Calendar.Component
    var interval: DateInterval
    
    var year: Int { Calendar.current.component(.year, from: interval.start) }
    var expenseMonths: [ExpenseMonth] {
        return ExpenseMonth.array(from: start, to: end)
    }
    
    static func array(from startDate: Date, to endDate: Date) -> [ExpenseYear] {
        array(of: .year, from: startDate, to: endDate)
    }
    
    init(from date: Date) {
        self.type = .year
        self.interval = Calendar.current.dateInterval(of: type, for: date)!
    }
}

struct ListView: View {
    
    @Environment(\.managedObjectContext) private var managedObjectContext
    @FetchRequest(
        entity: Expense.entity(),
        sortDescriptors: [NSSortDescriptor(key: "datetime", ascending: false)]
    ) var expenses: FetchedResults<Expense>
    
    @State private var showingNewExpenseSheet = false
    @State private var showingPreferencesSheet = false
    
    private var dateFormatter: DateFormatter {
        let formatter = DateFormatter()
        formatter.dateFormat = "YYYY MMM"
        return formatter
    }
    
    var body: some View {
        NavigationView {
            List {
                ForEach(ExpenseYear.array(from: expenses.last!, to: expenses.first!)) { expenseYear in
                    ForEach(expenseYear.expenseMonths) { expenseMonth in
                        MonthlyListView(expenseMonth)
                    }
                    Text("\(0)")
                }.onDelete(perform: deleteExpenseItem)
            }
            .navigationBarTitle("Expenses")
            .navigationBarHidden(true)
        }
    }
    
    func deleteExpenseItem(at offsets: IndexSet) {
        for index in offsets {
            let expense = expenses[index]
            managedObjectContext.delete(expense)
        }
        do {
            try managedObjectContext.save()
        } catch {
            print("Wasn't able to save after delete due to \(error)")
        }
    }
}

struct MonthlyListView: View {
    @Environment(\.managedObjectContext) private var managedObjectContext
    var expenseFetchRequest: FetchRequest<Expense>
    var expenses: FetchedResults<Expense> {
        expenseFetchRequest.wrappedValue
    }
    let expenseMonth: ExpenseMonth
    
    init(_ month: ExpenseMonth) {
        self.expenseMonth = month
        self.expenseFetchRequest = month.expenses
    }
    
    var body: some View {
        Section(header: Text("\(expenseMonth.month)")) {
            ForEach(expenses) { expense in
                ExpenseRowItemView(expense)
            }
        }
    }
}