Array-like immutable (persistent) data structure implementation with fast indexing, append, prepend, iteration
The obvious candidate is a persistent balanced binary tree.  All the operations you listed can be performed in $O(1)$ or $O(\lg n)$ time, using path copying.  For more details on how to achieve this runtime, see Chris Okasaki's book referenced below or my answer here.

Of course, as an variant, each leaf of such a tree could itself contain an immutable array (a sequence of consecutive values).  This makes updating a value less efficient, but it might work well for your situation, if you never intend to modify an existing value, just append and prepend.  In this way, your vector is represented as a sequence of immutable sequences, represented as a balanced binary tree with immutable arrays in the leaves.  This allows for fast indexing (logarithmic in the number of leaves), fast append and prepend, and fast iteration.  The worst-case asymptotic complexity is no better, but the performance in practice might be significantly better.

The standard reference is Chris Okasaki's 1998 book "Purely functional data structures".
See also


What classes of data structures can be made persistent?
What's new in purely functional data structures since Okasaki?
What are the outstanding questions in purely functional data structures?
Ten Years of Purely Functional Data Structures