Returning an iterator from a method fights me over lifetimes every single time Idiomatic?

fn matching(&self, kind: Kind) -> impl Iterator<Item = &Record> + '_ is what you want. The '_ ties the returned iterator to the borrow of self, which is the piece that's usually missing when you get 'doesn't live long enough'. Inside, self.records.iter().filter(move |r| r.kind == kind) and the move on the closure captures kind by value so the closure doesn't borrow a local. Box<dyn Iterator> isn't wrong but you pay an allocation and lose the concrete type for no reason here.

One thing that trips people: if the predicate itself borrows something with a shorter life than self, no signature will save you and you genuinely do need to restructure. Passing the filter criteria in by value, as above, is what makes the simple signature possible.

Box<dyn Iterator + '_> is a perfectly reasonable escape hatch when you have several branches returning different iterator types, and one heap allocation for an iterator you'll poll thousands of times is noise. I wouldn't feel like you gave up, I'd feel like you shipped.

Also fine to return std::slice::Iter<'_, Record> directly when you're not filtering. Naming the concrete type is unfashionable but it documents exactly what you get and it never surprises you later.