No Clojure, quando devo usar um vetor sobre uma lista e o contrário?

Eu li que vetores não são seqs, mas listas são. Não sei ao certo qual é a razão para usar um sobre o outro. Parece que os vetores são mais utilizados, mas existe uma razão para isso?

Mais uma vez, parece que respondi à minha própria pergunta, ficando impaciente e fazendo-a no #clojure no Freenode. É bom responder a suas próprias perguntas no Stackoverflow.com: D

Tive uma rápida discussão com Rich Hickey, e aqui está a essência disso.

[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

Se você já fez muita programação em Java e está familiarizado com a estrutura de coleta Java, pense em listas como LinkedListe vetores como ArrayList. Assim, você pode escolher contêineres da mesma maneira.

Para esclarecimentos adicionais: se você deseja adicionar itens individualmente à frente ou atrás da sequência, uma lista vinculada é muito melhor que um vetor, porque os itens não precisam ser embaralhados a cada vez. No entanto, se você deseja obter elementos específicos (não próximos à frente ou atrás da lista) com frequência (ou seja, acesso aleatório), convém usar o vetor.

A propósito, os vetores podem ser facilmente transformados em 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)

Os vetores têm tempos de acesso aleatório O (1), mas precisam ser pré-alocados. As listas podem ser estendidas dinamicamente, mas o acesso a um elemento aleatório é O (n).

Quando usar um vetor:

• Desempenho de acesso indexado - você obtém um custo ~ O (1) para acesso indexado vs. O (n) para listas
• Anexando - com conj é ~ O (1)
• Notação conveniente - acho mais fácil digitar e ler [1 2 3] do que '(1 2 3) para obter uma lista literal nas circunstâncias em que qualquer uma delas funcionaria.

Quando usar uma lista:

• Quando você deseja acessá-lo como uma sequência (uma vez que as listas suportam diretamente a seq sem precisar alocar novos objetos)
• Anexar - adicionar ao início de uma lista com contras ou, de preferência, conj é O (1)

apenas uma observação rápida:

"Eu li que Vetores não são seqs, mas Listas são." 

seqüências são mais genéricas do que listas ou vetores (ou mapas ou conjuntos).
É lamentável que o REPL imprima listas e sequências da mesma forma, porque realmente faz parecer que as listas são sequências, embora sejam diferentes. a função (seq) fará uma sequência de várias coisas diferentes, incluindo listas, e você pode alimentar essa seq com qualquer uma das inúmeras funções que fazem coisas bacanas com as 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 possui um atalho que retorna seu argumento se já é um 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);
}

listas são sequências, embora outras coisas também sejam, e nem todas as sequências são listas.