{=>
(Some(x_), Some(y_)) => Some(x_+y_),
(Some(x_), None) => Some(x_),
_ => None
}
```
But that’s another magic sigil.
Is there something specific about the doubled brackets you don’t like? Is it just the lack of explicitly saying ‘match’?
---
### Author:  [@glaebhoerl](https://internals.rust-lang.org/u/glaebhoerl)
#### Post date: [October 18, 2014, 11:27pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/14 "2014-10-18T23:27:16Z")
> [@jfager](#):
>
> I believe this is unambiguous b/c '=\>' isn't used for anything else
Hilarious brain fart aside: this is similar to how many years ago I consistently read (Brent) 'Scowcroft' as 'Snowcroft', to the point where I was tremendously confused and rather agitated by the fact that if I wrote the name into Google myself, it only returned a single result, while if I copy pasted the name from a web page, it returned lots of results. It took me a while to realize what was going on and that the world hadn't stopped making sense, only my brain.
Similarly, in this case for _years_ now I had been under the impression that the `=>` operator used by Rust for `match` and by Haskell for type class contexts is the greater-than-or-equals operator, and specifically thinking that this would likely end up causing some problems for Haskell when the type system advanced to the point that they got to writing inequality comparisons at the type level.
...but it turns out that `>=` and `=>` are distinct entities.
> Is there something specific about the doubled brackets you don't like?
It seems awfully arbitrary and not very aesthetically appealing (line noise, etc.).
---
### Author:  [@nikomatsakis](https://internals.rust-lang.org/u/nikomatsakis)
#### Post date: [October 19, 2014, 1:53pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/15 "2014-10-19T13:53:00Z")
On Sat, Oct 18, 2014 at 12:44:50PM +0000, glaebhoerl wrote:
---
### Author:  [@glaebhoerl](https://internals.rust-lang.org/u/glaebhoerl)
#### Post date: [October 19, 2014, 2:03pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/16 "2014-10-19T14:03:10Z")
Discourse ate your reply :\
---
### Author:  [@jfager](https://internals.rust-lang.org/u/jfager)
#### Post date: [October 19, 2014, 3:38pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/17 "2014-10-19T15:38:38Z")
Working off @mdinger’s comment, more match sugar:
```
for v in foo.iter() {{
(Some(x), Some(y)) => println!("Total: {}", x+y),
(Some(x), None) => println!("x: {}", x),
_ => println!("no x")
}}
loop rx.recv() {{
(Some(x), Some(y)) => println!("Total: {}", x+y),
(Some(x), None) => println!("x: {}", x),
_ => println!("no x")
}}
```
Or more like @glaebhoerl’s alternative:
```
for match v in foo.iter() {
(Some(x), Some(y)) => println!("Total: {}", x+y),
(Some(x), None) => println!("x: {}", x),
_ => println!("no x")
}
loop match rx.recv() {
(Some(x), Some(y)) => println!("Total: {}", x+y),
(Some(x), None) => println!("x: {}", x),
_ => println!("no x")
}
```
I think ‘if let’ and ‘while let’ are already the analogous sugar for ‘if’ and ‘while’.
---
### Author:  [@bfops](https://internals.rust-lang.org/u/bfops)
#### Post date: [October 19, 2014, 7:24pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/18 "2014-10-19T19:24:53Z")
For language features like this, my request is that if they incur overhead in the compiler (I don’t know how much there actually would be), there should be a way to disable them. This and other features (like `if let`) might be things I just decide not to use, e.g. for simplicity and consistency reasons (one of the great things about C is how dead simple the language is, not just for computer to parse, but for humans, too!). If I can squeeze out any more compiler performance by not using more sugary language features, I’d absolutely like that option.
---
### Author:  [@Drup](https://internals.rust-lang.org/u/Drup)
#### Post date: [October 19, 2014, 7:28pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/19 "2014-10-19T19:28:02Z")
FWIW, In OCaml, the sugar is the following:
```rust
let f = function
| ....
```
is (exactly) the same as
```rust
let f x = match x with
| ...
```
---
### Author:  [@jfager](https://internals.rust-lang.org/u/jfager)
#### Post date: [October 19, 2014, 8:09pm UTC](https://internals.rust-lang.org/t/match-fn-sugar/431/20 "2014-10-19T20:09:12Z")
Simplicity is in the eyes of the beholder, I guess. C is simple but a lot of C programs end up being verbose and complex b/c the language isn’t expressive enough. Compact forms for common idioms lead to simpler programs (though admittedly it can be taken too far).
[Next page](https://internals.rust-lang.org/t/match-fn-sugar/431.md?page=2)