After benchmarking queues they seem much faster than Lists on
appending.

• [1,...1000] ++ [1001] O(n)
• :queue.in(1,q) should be O(1) right?

last element

• List.last([1,..,1000]) again O(n)
• :queue.get_r(q) again O(1)

and they should be similar on prepending

• List [0 | [1,..,1000]]
• :queue.in_r(0,q)

Now, seeing queues implementation it seems reasonable. A queue generated from a list of numbers from 1 to 1000 is implemented as a tuple of two lists.

{ [1000, 999, 998,.., 501], [1, 2, 3, 4, .., 500] }

So the list is split in two and the last half part of the list is reversed. Since prepending an item in a list is fast O(1) then appending 1001 is fast because 1001 is prepended to the first list in the tuple. Same thing for getting the last element, with lists is O(n) and while with :queue is O(1).

My question is, what are the downsides of using queues over lists? Maybe enumerating the numbers from 500 to 1000 since that list is reversed?
Some rebalancing when enqueueing new elements?