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: 
Some languages do have such features. E.g. in Perl6 we can use [Junctions](http://perlcabal.org/syn/S03.html#Junctive_operators), which are “superpositions” of two values:

```perl
if $a == any($b, $c) {
    say "yes";
}

# syntactic sugar for the above
if $a == $b | $c {
    say "yes";
}

```

Junctions allow us to express operations on a set of data quite succinctly, similar to the way scalar operations distribute over collections in some languages. E.g. using Python with numpy, the comparison can be distribute over all values:

```py
import numpy as np
2 == np.array([1, 2, 3])
#=> np.array([False, True, False], dtype=np.bool)
(2 == np.array([1, 2, 3])).any()
#=> True

```

However, this only works for selected primitive types.

Why are junctions problematic? Because operations on a junction distribute over the contained values, the junction object itself behaves like a proxy for method calls – something few type systems aside from duck typing can handle.

Type system problems can be avoided if such junctions are only allowed as special *syntax* around comparison operators. But in this case, they are limited so much that they don't add sufficient value to be added to any sane language. The same behavior could be expressed using set operations or spelling out all comparisons manually, and most languages do not believe in adding redundant syntax if there is already a perfectly fine solution.
"if(a == b or c)" works in most languages: if a == b or if c is not negative, null, or zero.

Complaining that it's verbose misses the point: you shouldn't be piling a dozen things into a conditional. If you need to compare one value to an arbitrary number of other values, then build a subroutine.