Is an initial `|` on match arms a formatting issue?

[nrc]

It is now possible in Rust to start a match arm with a |, e.g.,

match foo {
    | whatever => {}
}

Currently Rustfmt treats a leading | or not as significant code, i.e., preserves what the user chose to do. However, it is not semantically significant, so one might consider it a style issue, in which case Rustfmt should change it one way or the other (since we believe in consistent formatting, not preserving user input). As a counter-point, we do not strip unnecessary () although these also are not semantically significant.

So, there are three options:

• never use an initial |
• always use an intial |
• preserve the user choice.

[strega-nil]

I personally want something like this: rust-lang/rustfmt#2234 . I think it would help a lot with the issue of indenting way too much in Rust.

[chriskrycho]

👍 to @ubsan's suggestion. This is where Reason landed, for example. Also, I've gotten quite used to the visual nicety of having every pattern in a union type prefaced by a | when declaring them in e.g. TypeScript, F♯, etc. It makes for a really pleasantly self-consistent style.

It's worth noting that there's a subtle difference: | in Reason is actually equivalent to , in Rust. That's why in Reason we only have | at the beginning of line, while in @ubsan's suggestion we have both leading | and trailing ,.

While I can appreciate the reduction of rightward drift, my main worry is that having leading |s would further the perception of Rust as a sigil-heavy language. To be fair, leading | does look nice when matching on a large set of cases where some of them are indeed unified using |, but if there is no legitimate use of |, then perhaps writing it redundantly before each case is more harm than good? After all, legitimate uses of | are not very common.

And the problem with the second style (the one without indentation and without leading |) is that two adjacent closing braces can line up at the same indentation level:

match self.front() {
None => return None,
Some(e) => {
    if e.remove() {
        return Some(e);
    }
}
}

[steveklabnik]

I really don't want leading |, so my preference is 1, then 3.

[jplatte]

As a counter-point, we do not strip unnecessary () although these also are not semantically significant.

Unnecessary () are something you use in very few situations, if ever, though. Initial | on match arms seem to me like something you would either add everywhere, or nowhere. So I would consider it a style choice.

[nrc]

OK, it sounds like there is consensus that this is a formatting issue, but not on exactly what we should do.

IMO, using | instead of an indent is too radical a change at this stage, and is also inconsistent with the rest of our formatting choices because we heavily rely on indentation rather than punctuation to identify 'sub-items'.

Therefore I propose we accept option 1, that tools should remove leading |s. However, tools could support an option like rust-lang/rustfmt#2234 (i.e., leading | without indentation).

Rustfmt currently uses this formatting:

match foo {
    Foo::Bar(value)
    | Foo::Baz(_ignore_this, value)
    | Foo::Quux(_ignore_this, _and_this, value) => {
        println!("value = {}", value);
        Whatever::One
    }
    Foo::Spam(value) | Foo::Eggs(_, value) => Whatever::Two(value),
}

But the style with leading vert @withoutboats suggested here is starting to grow on me, and looks really neat in this case:

match foo {
    | Foo::Bar(value)
    | Foo::Baz(_ignore_this, value)
    | Foo::Quux(_ignore_this, _and_this, value)
    => {
        println!("value = {}", value);
        Whatever::One
    }
    | Foo::Spam(value)
    | Foo::Eggs(_, value)
    => Whatever::Two(value),
}

[nrc]

Closed by #127