Elixir array-like data structure?

There are 3 approaches you can take:

• write your own module that will use tuples to store data
• write functions you need for the :array
• use NIF or port

It depends on your use case which one of these will be most efficient. In general there is no simple and efficient way to shuffle any structure in Elixir.

I’m reluctant to use Tuples because of this from the official documentation:

updating or adding elements to tuples is expensive because it requires creating a new tuple in memory:

:array module is built upon tuples. And the same shortcomings are when you want to use maps. So if you are doing many updates to the array then you need to use:

• Process dictionary, but this will limit you to single process
• ETS, but that requires careful editing and managing of the state, also you need to have “parent” process for the table
• NIF

There is also :atomics.

If 64 bit integers are suitable for you. You can also use them as a bit array. (I have a lib to help with that: Abit)

I almost forgot:
When I was playing with genetic algorithms, I successfully sped up things with the Matrex library.

This has been my biggest gripe with elixir for quite awhile.

I think adding built in support for a first class array type or (a well integrated NIF at least) would go a long way.

Keep in mind that the data structure you are proposing is ill suited for distributed systems, which is why it’s not a first class citizen of the BEAM. I’m a math major working at a deep learning company, and maybe it’s Stockholm syndrome but I’m ok with this separation of concerns and having arrays be second class citizens of the ecosystem. Distribution is hard, and the trade-off of making arrays second class is, in my mind “totally worth it” to make distribution easy.

Minor nitpick - Javascript implements “normal” arrays (like you’d get from parsing the JSON string [1,2,3]) as maps under the hood. For instance, you can call [1,2,3].keys()…

IMO this sounds like you need a more-specialized data structure than arrays - even Ruby arrays are going to have poor performance characteristics with things like inserting in the middle that can’t share structure.

For instance, a common solution you’ll find in a lot of text editors is the rope. It costs more complexity up-front, but it comes in very handy when (for instance) a user types one character at the start of a 10MB text file.

In general, immutability seems to require a little more thought when picking structures - for instance, a performant double-ended queue is more complicated without mutation so there’s the :queue module in stdlib. The comments in that module recommend reading “Purely Functional Data Structures” by C. Okasaki and I’ll +1 that recommendation.

wow, that paper is great and I really wish I had the time to implement them all in elixir.

I think that a build-in (to Erlang) version of a persistent data structure with properties similar Clojure’s vector (access to items by index in log32N hops, optimized for append rather than list’s prepend) would be very beneficial while not being any less suited to Erlang than a map.