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.
Some languages do offer this -- to an extent. 

Maybe not as your *specific* example, but take for example a Python line:

```
def minmax(min, max):
    def answer(value):
        return max > value > min
    return answer

inbounds = minmax(5, 15)
inbounds(7) ##returns True
inbounds(3) ##returns False
inbounds(18) ##returns False

```

So, some languages are fine with multiple comparisons, as long as you're expressing it correctly.

Unfortunately, it doesn't work quite like you'd expect it to for comparisons.

```
>>> def foo(a, b):
...     def answer(value):
...         return value == a or b
...     return answer
... 
>>> tester = foo(2, 4)
>>> tester(3)
4
>>> tester(2)
True
>>> tester(4)
4
>>> 

```

*"What do you **mean** it returns either True or 4?" -- the hire after you*

One solution in this case, at least with Python, is to use it slightly differently:

```
>>> def bar(a, b):
...     def ans(val):
...             return val == a or val == b
...     return ans
... 
>>> this = bar(4, 10)
>>> this(5)
False
>>> this(4)
True
>>> this(10)
True
>>> this(9)
False
>>> 

```

EDIT: The following would also do something similar, again in Python...

```
>>> def bar(a, b):
...     def answer(val):
...             return val in (a, b)
...     return answer
... 
>>> this = bar(3, 5)
>>> this(3)
True
>>> this(4)
False
>>> this(5)
True
>>> 

```

So, whichever language you're using, it may not be that you *cannot* do it, just that you must first take a closer look at how the logic actually works. Typically it's just a matter of knowing what you're 'actually asking' the language to tell you.