@NobbZ already told you that equality != equivalence, but let see why you cannot compare iolists and why your comparator is terribly wrong.

See what Typespecs say about iolist type:

iolist() maybe_improper_list(byte() | binary() | iolist(), binary() | [])

But what is improper list?

So all of us get used to it that list in Erlang is head and tail or an empty list (yes empty list is special case of list). So when we do [a | b] = list then is_list(b) == true. Simple. But what when it isn’t? Nothing in Erlang prevents you from doing [1 | 2]. Yes this is proper syntax, yes it will compile, yes it is used. This is called improper list and your Comparer will fail on that.

Second thing is that iolist can be:

• infinitely nested, so [[[[[["a"]]]]]] is also proper iolist that is equivalent to ["a"]
• can contain raw bytes, so ["a", 97] is equivalent to ["aa"]
• can contain Erlang strings, which are lists ['a'] == [[97]] == [[?a]] which is equivalent to ["a"]

So some hard examples for you to compare:

• ["foo", 'bar' | ?z] vs [["foo" | "bar"], "z"]
• ['a' | "ą"] vs ["aą"]
• ["aa", ?a, 'aa'] vs ["a", ?a, 'aa' | "a"]

None that I know of. The thing to be aware of is that there is no real iolist data type, it is just a nested recursive structure which happens to be interpreted in a special way in some cases. The main one being that on output the BEAM will automagically flatten it and output the bytes. This means that in many case you don’t have to pay the price of flattening it.

That should be all now.

The reason converting the iolists to binaries and then doing and equals test is that these are both implemented in the VM in C while your code is in Elixir. No, will not go faster if you were to write it in Erlang. [*]

You can probably make your code more efficient when comparing binaries by directly comparing the longest leading chunk in one go instead of doing it byte by byte. And it is fun code to write as well. Another fun function is one that takes an iolist and returns the Nth byte.

[*] Of course the Erlang would be more beautiful.

Just benchmarked my incomplete implementation from above against IO.iodata_to_binary followed by ==, and my implementation was 40 times slower.

iolist1 = ["SELECT ", "a,", "b,", "c", " FROM somewhere", " WHERE a = 5"]
iolist2 = ["SELECT ", "a,", "b,", "c", " FROM somewhere WHERE a = 5"]

Benchee.run(%{
  "Comparer.equal?/2" => fn -> Comparer.equal?(iolist1, iolist2) end,
  "to binary and then compare" => fn ->
    IO.iodata_to_binary(iolist1) == IO.iodata_to_binary(iolist2)
  end
})

Benchmarking Comparer.equal?/2...
Benchmarking to binary and then compare...

Name                                 ips        average  deviation         median         99th %
to binary and then compare        1.40 M        0.71 μs ±10280.07%           1 μs           1 μs
Comparer.equal?/2               0.0342 M       29.28 μs   ±107.85%          23 μs         112 μs

Comparison:
to binary and then compare        1.40 M
Comparer.equal?/2               0.0342 M - 40.97x slower