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: 
In most languages, this should be trivially achievable by writing an `In` function, so why make it a part of the actual language?

Linq, for example, has `Contains()`.

Alright, for all you pedants, here's my implementation in C#:

```
public static bool In<T>(this T obj, params T[] values)
{
    for(int i=0; i < values.Length; i++)
    {
        if (object.Equals(obj, values[i]))
            return true;
    }
    return false;
}

```
Usually, you want to keep your syntax at a minimum and instead allow such constructs to be defined in the language itself.

For example, in Haskell you can convert any function with two or more arguments into an infix operator using backticks. This allows you to write:

```
if a `elem` [b, c] then ... else ...

```

where `elem` is just a normal function taking two arguments - a value and a list of values - and checks whether the first is an element of the second.

What if you want to use `and` instead of `or`? In Haskell, you can just use the following instead of waiting for the compiler vendor to implement a new feature:

```
 if all (== a) [b, c] then ... else ...

```