I need a collection of process (I’m thinking of PIDs). Once I have spawned processes and added them to the collection, I won’t add any new process. But I may have to remove some process to simulate node failure, this operation would be rare and mostly the collection would be unchanged.
Also, I need to have cheap random access to elements.
Ah yeah this changes things. You almost certainly want to use Registry, which will ensure that individual values are tied to the life cycle of the process.
Registry is backed by :ets, which is a very high performance key value store that also enables concurrent reads / writes.
As a direct answer to your question: there is the :array module from erlang.
That module uses a set of nested tuples and reading is O(1). I’m not sure about its writing runtime though, and you’d have to implement filling logic on delete by yourself (either take the last in the hole, or let every following item go one step forward, thats up to you, depending on if original order matters).
There is also the array package which is a wrapper around the erlang module, providing some protocols as well to make it easier to handle them from elixir site. But it hasn’t been updated in the last 3 years, therefore it might spit some warnings in a current elixir or not work at all.
To try to find another solution to your problem. It sounds a bit as if you want to create some kind of load balancer which is giving away its work randomly on the workers.
By picking randomly from a fixed set, you might get non-uniform distribution due to how PRNGs work.
Therefore I’d suggest one of these solutions:
:queue module for a datastructure which can pull from the head and push to the tail in amortized o(1).
For what you describe a tuple actually seems like a good choice. Some questions though:
Having very large tuples is inefficient when you update them. You basically make a copy of the whole tuple every time, but not the elements themselves of course. If it is relatively static then a tuple will work fine, doing your occasional deletes would probably work fine. Otherwise the :array module mentioned by @NobbZ is a good alternative. Maybe just using a map would work as well.
Tuples :array’s and maps are local to one process so if multiple processes need to access it then perhaps using an ETS table would be better. These can be globally accessed however they have no built in transaction mechanism so you might need a process to manage them.
I have two fine packages for you:
:arrays-based implementation.)This is probably perfect for your needs, although the last time I had time to work on it I was unable to write proper documentation and tests, so these are still lacking.
If you need to do more mathematical stuff with them:
Tensor is very stable and greatly documented and tested.