Why aren't binaries enumerable?

Why don’t Binary types implement the Enumerable protocol so that they can be used with the Enum library? It seems like it would be useful and easy enough to write the reduce, slice, count, and member? functions for binaries.

I tried doing so, but it only seems to work if I define the implementation for BitString and use guards or pattern matching to make sure that binaries are being passed.

defmodule BinaryEnumerable do
  defimpl Enumerable, for: BitString do
    def slice(_string), do: {:error, __MODULE__}

    def slice(string, range) when is_binary(string),
      do: String.slice(string, range)

    def slice("", _start, _count), do: ""
    def slice(_string, _start, 0), do: ""

    def slice(string, start, len) when is_binary(string),
      do: String.slice(string, start, len)

    def count(string) when is_binary(string),
      do: {:ok, String.length(string)}

    def member?(string, <<char::binary-1>>) when is_binary(string),
      do: {:ok, String.contains?(string, char)}

    def member?(_string, _char), do: {:error, __MODULE__}

    def reduce(_string, {:halt, acc}, _fun), do: {:halted, acc}
    def reduce(string, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(string, &1, fun)}
    def reduce(<<>>, {:cont, acc}, _fun), do: {:done, acc}

    def reduce(<<head::binary-1, tail::binary>>, {:cont, acc}, fun),
      do: reduce(tail, fun.(head, acc), fun)
1 Like

First of all Enum is module in Elixir core code - not library, so topic should be closed. :077:

ok, but seriously now …

seems is good word here. It would be definitely useful, but also definitely not easy.

Let’s take a look at simplest example Enum.count/1. Do you want to count graphemes, bytes or maybe bites? Enum does not support options in its functions, so it would be hard to write an Enumerable implementation which satisfies everyone. <<…>> syntax have lots of useful types like bits, bytes, utf8 and many more. Such protocol implementation can’t guess based on which type you want to enumerate.

There are probably also some internal reasons for doing that, but I can’t give example here as I’m not a member of lots core discussions. I think that people from Elixir Core Team could say more about it.