style-guide: Format single associated type where clauses on the same line

[joshtriplett]

In particular, lifetime-generic associated types often have a
where Self: 'a bound, which we can format on the same line.

[rustbot]

r? @yaahc

(rustbot has picked a reviewer for you, use r? to override)

[rustbot]

Some changes occurred in src/doc/style-guide

cc @rust-lang/style

[bors]

☔ The latest upstream changes (presumably #119837) made this pull request unmergeable. Please resolve the merge conflicts.

[joshtriplett]

@rfcbot merge

[rfcbot]

Team member @joshtriplett has proposed to merge this. The next step is review by the rest of the tagged team members:

• @calebcartwright
• @compiler-errors
• @joshtriplett
• @yaahc

No concerns currently listed.

Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!

See this document for info about what commands tagged team members can give me.

[rfcbot]

🔔 This is now entering its final comment period, as per the review above. 🔔

[pitaj]

Just curious about the reasoning here

    fn count(self) -> usize
    where
        Self: Sized,
    {
        todo!()
    }

Why exclude functions with bodies, and why not allow Self: Sized to be on the same line as the where?

[rfcbot]

The final comment period, with a disposition to merge, as per the review above, is now complete.

As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed.

This will be merged soon.

[compiler-errors]

Please rebase, then r=me.

@rustbot author

[Dylan-DPC]

@joshtriplett any updates on this? this is ready for a merge and has been approved but requires a rebase before that

[joshtriplett]

Rebased.

[joshtriplett]

@bors merge r=compiler-errors

[compiler-errors]

@bors r+

[bors]

📌 Commit 163b1a6 has been approved by compiler-errors

It is now in the queue for this repository.

[joshtriplett]

@pitaj This was intended as a narrow fix for making GATs simpler to write and read. The rationale for excluding functions with bodies is the same as the rationale for excluding types that have an =, namely trying to space things out for readability.

Separate from that: Putting a function's where Single: Bound on a single line was a request made of the original Rust style as well. Part of the rationale against was that when you have a long and complex fn function(...) -> Type line, having a single-line where next to that can blend together and prove hard to read, whereas a blank line seems to help with that. (Your count example is a simple function with a simple where clause; consider a more complex function than count.) We could reconsider that, but I feel like that rationale still applies.

[pitaj]

A more complex function signature would also be more likely to spill into the next line.

The argument seems to apply equally regardless of whether the function has a body or not.

[joshtriplett]

The argument seems to apply equally regardless of whether the function has a body or not.

The argument I wrote above was in response to the idea of writing

    fn count(self) -> usize
    where Self: Sized
    {
        todo!()
    }

I'd make a different argument about why not to write:

    fn count(self) -> usize where Self: Sized
    {
        todo!()
    }

That argument would mostly be "that function already has a body, so it's already spread over several lines and has a blank line separating it from other functions, so the incremental value of putting where Self: Sized on the same line is low compared to the readability cost of doing so".

By contrast, if you have:

    fn count(self) -> usize where Self: Sized;
    fn recount(self) -> usize where Self: Sized;
    fn turn_purple(&mut self);

I think that's more readable than breaking each of the where clauses onto subsequent lines.