En Clojure, ¿cuándo debo usar un vector sobre una lista y viceversa?

Leí que los vectores no son seqs, pero las listas sí. No estoy seguro de cuál es la razón para usar uno sobre el otro. Parece que los vectores son los más utilizados, pero ¿hay alguna razón para eso?

Una vez más, parece que he respondido mi propia pregunta poniéndome impaciente y preguntándola en #clojure en Freenode. Se recomienda responder a sus propias preguntas en Stackoverflow.com: D

Tuve una discusión rápida con Rich Hickey, y aquí está lo esencial.

[12:21] <Raynes>    Vectors aren't seqs, right?
[12:21] <rhickey>   Raynes: no, but they are sequential
[12:21] <rhickey>   ,(sequential? [1 2 3])
[12:21] <clojurebot>    true
[12:22] <Raynes>    When would you want to use a list over a vector?
[12:22] <rhickey>   when generating code, when generating back-to-front
[12:23] <rhickey>   not too often in Clojure

Si ha hecho mucha programación en Java y está familiarizado con el marco de recopilación de Java, piense en listas como LinkedListy vectores similares ArrayList. Así que puedes elegir contenedores de la misma manera.

Para una mayor aclaración: si tiene la intención de agregar elementos individualmente al principio o al final de la secuencia, una lista vinculada es mucho mejor que un vector, ya que los elementos no necesitan ser barajados cada vez. Sin embargo, si desea llegar a elementos específicos (no cerca del frente o al final de la lista) con frecuencia (es decir, acceso aleatorio), querrá usar el vector.

Por cierto, los vectores se pueden convertir fácilmente en seqs.

user=> (def v (vector 1 2 3))
#'user/v
user=> v
[1 2 3]
user=> (seq v)
(1 2 3)
user=> (rseq v)
(3 2 1)

Los vectores tienen O (1) tiempos de acceso aleatorio, pero deben ser preasignados. Las listas se pueden extender dinámicamente, pero acceder a un elemento aleatorio es O (n).

Cuando usar un vector:

• Rendimiento de acceso indexado: obtiene ~ O (1) costo por acceso indexado frente a O (n) para listas
• Anexar - con conj es ~ O (1)
• Notación conveniente: me resulta más fácil escribir y leer [1 2 3] que '(1 2 3) para obtener una lista literal en circunstancias en las que cualquiera de los dos funcionaría.

Cuándo usar una lista:

• Cuando desee acceder a él como una secuencia (ya que las listas admiten directamente seq sin tener que asignar nuevos objetos)
• Previo - agregando al inicio de una lista con contras o preferiblemente conj es O (1)

solo una nota al margen rápida:

"Leí que los vectores no son seqs, pero las listas sí". 

Las secuencias son más genéricas que las listas o los vectores (o los mapas o conjuntos).
Es desafortunado que REPL imprima listas y secuencias de la misma manera porque realmente hace que parezca que las listas son secuencias a pesar de que son diferentes. la función (seq) creará una secuencia de muchas cosas diferentes, incluidas listas, y luego puede alimentar esa seq a cualquiera de la gran cantidad de funciones que hacen cosas ingeniosas con seqs.

user> (class (list 1 2 3))
clojure.lang.PersistentList

user> (class (seq (list 1 2 3)))
clojure.lang.PersistentList

user> (class (seq [1 2 3]))
clojure.lang.PersistentVector$ChunkedSeq

Sec tiene un acceso directo que devuelve su argumento si ya es un seq:

user> (let [alist (list 1 2 3)] (identical? alist (seq alist)))
true
user> (identical? (list 1 2 3) (seq (list 1 2 3)))
false

static public ISeq seq(Object coll){
        if(coll instanceof ASeq)
                return (ASeq) coll;
        else if(coll instanceof LazySeq)
                return ((LazySeq) coll).seq();
        else
                return seqFrom(coll);
}

las listas son secuencias, aunque otras cosas también lo son, y no todas las secuencias son listas.