What should be allowed in the pattern grammar?

Consider the following code:

let a = 0b11;
let b = match a {
  0b01 | 0b10 => true,
  _ => false
};
io::println(b.to_str());

The output is false, but let b = (a == 0b01 | 0b10); yields true.

I don't know how common patterns containing bitwise ors would be, but it seems inconsistent for this operator to be unavailable when the other arithmetic and bitwise ops function as expected here:

let a = 0b11;
let b = match a {
  0b01 + 0b10 => true,
  _ => false
};
io::println(b.to_str());

The output is true.

[brson]

I am somewhat surprised that binary + is allowed in patterns. I don't recall seeing binops in patterns before. Can they be forbidden?

[nikomatsakis]

I am also surprised. This seems like a parser bug, if it is indeed true.

[graydon]

Yeah, I don't think any binops like this belong in the pattern grammar. It's already very full and they won't compose: consider matching an integer against a+b. It's not going to work.

[sanxiyn]

Haskell has n+k pattern which I like, but I agree that arbitrary expressions should not be parsed as patterns.

[graydon]

nominating for backwards-compatible milestone

[pcwalton]

I believe this is now fixed; reopen if not.