Question: Consider the following:

```
if(a == b or c)

```

In most languages, this would need to be written as:

```
if(a == b or a == c)

```

which is slightly cumbersome and repeats information. 

I know my above sample syntax is slightly clunky, but I am sure there are better ways to convey the idea.

Why don't more languages offer it? Is there performance or syntax issues?

Answer: 
The syntax issue is – that it requires syntax. 

Whatever syntax your language has, people using the language have to learn it. Otherwise they run the risk of seeing code and not knowing what it does. Thus it's generally considered a good thing if a language has a simple syntax that cleanly handles a lot of cases. 

In your specific example, you are trying to take an infix operator (a function that takes two arguments but is written `Argument1 Operator Argument2`) and trying to extend it to multiple arguments. That doesn't work very cleanly because the whole point of infix operators, to the extent that there is one, is to put the operator right in between the 2 arguments. Extending to `(Argument1 Operator Argument2 MagicallyClearSymbol Argument3...)` doesn't seem to add a lot of clarity over `Equals(Arg1,Arg2,...)`. Infix is also typically used to emulate mathematical conventions that people are familiar with, which wouldn't be true of an alternate syntax.

There would not be any particular performance issues associated with your idea, other than that the parser would have to deal with a grammar with another production rule or two, which might have a slight effect on the speed of parsing. This might make some difference for an interpreted or JIT compiled language, but probably not a big difference.

The bigger problem with the idea is just that making **lots of special cases** in a language tends to be a **bad idea**.
Because it's a non-problem, and solving it brings basically zero benefit, but implementing it brings non-zero cost. 

Existing range-based functions and such that practically every language does offer can work perfectly well in this situation if it scales to a size where `a == b || a == c` won't cut it.