Каков идиоматический способ присоединиться к вектору в Clojure?

Question

Добавить в список легко:

user=> (conj '(:bar :baz) :foo)
(:foo :bar :baz)

Присоединиться к вектору легко:

user=> (conj [:bar :baz] :foo) 
[:bar :baz :foo]

Как я (идиоматически) присоединяюсь к вектору, возвращая вектор? Это не работает, так как возвращает seq, а не вектор:

user=> (cons :foo [:bar :baz])     
(:foo :bar :baz)

Это некрасиво (ИМВХО)

user=> (apply vector (cons :foo [:bar :baz])) 
[:foo :bar :baz]

Примечание. Мне просто нужна структура данных, к которой я могу добавить и подготовить. Добавление к большим спискам должно иметь большое снижение производительности, поэтому я подумал о векторах..

Answer 1

Векторы не предназначены для добавления. У вас есть только O(n) prepend:

user=> (into [:foo] [:bar :baz])
[:foo :bar :baz]

То, что вы хотите, это, скорее всего, пальчиковое дерево.

Answer 2

Я знаю, что этот вопрос старый, но никто ничего не сказал о списках различий, и, поскольку вы говорите, что на самом деле просто хотите что-то, к чему можно добавить и добавить, кажется, что списки различий могут вам помочь. Они не кажутся популярными в Clojure, но они ОЧЕНЬ просты в реализации и намного менее сложны, чем "пальчиковые деревья", поэтому я только что создал небольшую библиотеку списков различий (и даже протестировал ее). Они объединяются в O(1) времени (prepend или append). Преобразование списка различий обратно в список должно стоить вам O(n), что является хорошим компромиссом, если вы делаете много конкатенации. Если вы не делаете много конкатенации, просто придерживайтесь списков, верно?:)

Вот функции в этой крошечной библиотеке:

dl: список различий на самом деле является функцией, которая объединяет свое собственное содержимое с аргументом и возвращает результирующий список. Каждый раз, когда вы создаете список различий, вы создаете небольшую функцию, которая действует как структура данных.

dlempty: поскольку список различий просто объединяет свое содержимое с аргументом, пустой список различий - это то же самое, что и функция тождества.

undl: Из-за того, что делают списки различий, вы можете преобразовать список различий в обычный список, просто вызвав его с помощью nil, так что эта функция на самом деле не нужна; это просто для удобства.

dlcons: помещает элемент в начало списка - не совсем необходимо, но согласование является достаточно распространенной операцией, и это всего лишь одна строка (как и все функции здесь).

dlappend: объединяет два списка различий. Я думаю, что его определение является самым забавным - проверьте это!:)

А теперь вот эта крошечная библиотека - 5 однострочных функций, которые дают O(1) структуру данных добавления / добавления. Неплохо, а? Ах, красота лямбда-исчисления...

(defn dl
  "Return a difference list for a list"
  [l]
  (fn [x] (concat l x)))

; Return an empty difference list
(def dlempty identity)

(defn undl
  "Return a list for a difference list (just call the difference list with nil)"
  [aDl]
  (aDl nil))

(defn dlcons
  "Cons an item onto a difference list"
  [item aDl]
  (fn [x] (cons item (aDl x))))

(defn dlappend
  "Append two difference lists"
  [dl1 dl2]
  (fn [x] (dl1 (dl2 x))))

Вы можете увидеть это в действии с этим:

(undl (dlappend (dl '(1 2 3)) (dl '(4 5 6))))

который возвращает:

(1 2 3 4 5 6)

Это также возвращает то же самое:

((dl '(1 2 3)) '(4 5 6))

Веселитесь со списками различий!

Обновить

Вот некоторые определения, которые могут быть более сложными для понимания, но я думаю, что они лучше:

(defn dl [& elements] (fn [x] (concat elements x)))
(defn dl-un [l] (l nil))
(defn dl-concat [& lists] (fn [x] ((apply comp lists) x)))

Это позволяет вам сказать что-то вроде этого:

(dl-un (dl-concat (dl 1) (dl 2 3) (dl) (dl 4)))

Который вернется

(1 2 3 4)

Answer 3

Если вы не боитесь квазицитирования, это решение на самом деле довольно элегантное (для некоторых определений "элегантный"):

> `[~:foo ~@[:bar :baz]]

[:foo :bar :baz]

Я действительно использую это иногда в реальном коде, так как декларативный синтаксис делает его довольно читабельным, IMHO.

Answer 4

Как сказал пользователь optevo в комментариях под ответом "деревья пальца", вы можете использовать https://github.com/clojure/core.rrb-vector, которая реализует RRB-деревья:

RRB-деревья основаны на PersistentVectors Clojure, добавляя логарифмическую конкатенацию времени и срезы. ClojureScript поддерживается с тем же API, за исключением отсутствия vector-of функция.

Я решил опубликовать это как отдельный ответ, потому что я думаю, что эта библиотека заслуживает этого. Он поддерживает ClojureScript и поддерживается Michał Marczyk, который известен в сообществе Clojure своей работой по реализации различных структур данных.

Answer 5

Я бы предложил использовать удобные функции, встроенные в библиотеку Тупело. Например:

(append [1 2] 3  )   ;=> [1 2 3  ]
(append [1 2] 3 4)   ;=> [1 2 3 4]

(prepend   3 [2 1])  ;=> [  3 2 1]
(prepend 4 3 [2 1])  ;=> [4 3 2 1]

по сравнению с необработанным Clojure легко ошибиться:

; Add to the end
(concat [1 2] 3)    ;=> IllegalArgumentException
(cons   [1 2] 3)    ;=> IllegalArgumentException
(conj   [1 2] 3)    ;=> [1 2 3]
(conj   [1 2] 3 4)  ;=> [1 2 3 4]

; Add to the beginning
(conj     1 [2 3] ) ;=> ClassCastException
(concat   1 [2 3] ) ;=> IllegalArgumentException
(cons     1 [2 3] ) ;=> (1 2 3)
(cons   1 2 [3 4] ) ;=> ArityException