Wouldn't it be great if pattern variables could be used more than once in a pattern? Like so: foo [x,x,_,x] = "The values are the same!" foo _ = "They're not the same!" where this could be rewritten to: foo [x,y,_,z] | x == y && x == z = "The values are the same!" foo _ = "They're not the same!" It seems like a straight-forward translation and there wouldn't be a speed hit for normal patterns because it would only be triggered in compilation where the same free variable appears twice. Implications are: 1. in ``foo [x,y] = ...'', x has type a 1. in ``foo [x,x] = ...'', x has type Eq a => a Was this ever considered? Is it a bad idea for some reason I'm not aware of? On a mildly irrelevant note, I have observed newbies to the language wonder why on earth it's not already like this. Cheers