# Comparison operators in Elixir

28 Dec 2014

When I began learning Elixir and worked my way through the getting started guide, I found two things which felt a bit out of place. One of them was the comparison operators which got me thinking more around this topic.

In Elixir, there are two equals operators: `==` and `===`. The difference between them are similar to other languages whereas the latter is more strict than the former.

``````iex(1)> 1 == 1.0
true
iex(2)> 1 === 1.0
false
``````

It can also be used in the same regard in nested structures:

``````iex(1)> [1, 2, 3] == [1, 2, 3.0]
true
iex(2)> [1, 2, 3] === [1, 2, 3.0]
false
iex(3)> %{a: 2} == %{a: 2.0}
true
iex(4)> %{a: 2} === %{a: 2.0}
false
``````

To accompany the stricter `===` operator, Elixir also has the negated version, `!==`, but as in most other languages, there is no strict version of the other comparison operators: `<`, `>`, `<=`, `<=`. While one could imagine that `<==` and `>==` easily could be created, there isn’t really one as intuitive syntactic version for `>` and `<`.

As a comparison, in Scala and Java to name two languages, there is no strict comparison operators. In these languages, if we compare integers and floating point numbers, the integer is converted to a floating point number since this conversion does not lead to any data loss (which would happen if `1.1` would be converted to an integer).

The interesting thing to think about how is more how the less strict `==` operator works in those languages that does have the strict version. In languages like PHP and JavaScript, the `==` operator is much more relaxed than in Elixir and so numeric values can, to take one example, be compared with strings in this same regard as well:

``````"1.0" == 1
true
``````

In JavaScript, the implementation of the less strict `==` operator doesn’t only apply to comparing numeric types and strings but can also cause much wonder. These sometimes unexpected behaviours are however not possible in Elixir:

``````iex(1)> "1" == 1
false
``````

So in Elixir, the `===` operator only has one use which is to avoid comparing integers and floating point numbers which leads me to wonder if the `===` operator really is necessary in Elixir? My guess is that it is an inherited behaviour from Erlang which has the `=:=` operator (exactly equal to) and the corresponding `=/=` operator “exactly not equal to”.

For me, the `===` operator seems to be unnecessary in Elixir - I’ve never missed the `===` operator in Scala and if it was removed from Elixir, the same behaviour could be recreated by combining the `is_integer/1` or `is_float/1` function with the `==` operator.