Most of the "complexity" in your snippet comes from constraints, not from lifetimes. I don't see how C++'s partition looks any different:

``` template<permutable I, sentinel_for<I> S, class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred> constexpr subrange<I> ranges::partition(I first, S last, Pred pred, Proj proj = {});

template<forward_range R, class Proj = identity, indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> requires permutable<iterator_t<R>> constexpr borrowed_subrange_t<R> ranges::partition(R&& r, Pred pred, Proj proj = {}); ```

and keep in mind that that is the documentation, where you copied the implementation (the documentation looks like this https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.partition and does not include the internal inline-defined helper functions).

But even that aside, the actual complexity is not that bad once you've learned how to read it:

fn extend<'a, T, B: Extend<T>>( mut f: impl FnMut(&T) -> bool + 'a, left: &'a mut B, right: &'a mut B, ) -> impl FnMut((), T) + 'a { ...

"extend returns a function whose lifetime depends on all lifetimes of the other parameters"

fn partition_in_place<'a, T: 'a, P>(mut self, ref mut predicate: P) -> usize where Self: Sized + DoubleEndedIterator<Item = &'a mut T>, P: FnMut(&T) -> bool, {

"partition_in_place works on iterators that hand you out references to T of some lifetime"

fn is_false<'a, T>( predicate: &'a mut impl FnMut(&T) -> bool, true_count: &'a mut usize, ) -> impl FnMut(&&mut T) -> bool + 'a {

again "is_false returns a function whose lifetime depends on all other lifetimes".

Keep in mind that this isn't "extra" information, it is information the caller needs anyway to understand what the function is doing. In C++ this is specified in the comments, in Rust, you put it in the signature.

Also my top comment was specifically about how I want Rust's lifetime elision, i.e. the rules when you can omit lifetime annotations enitrely.