а так, есть же survey, там статистика

кстати, самый быстрый вариант у меня получился с трасдьюсерным dedupe

(let [x 4 path [1 2 3]]
    (into [] (dedupe) (conj path x)))

заодно убирает другие дубликаты из path, если они там почему-то были

(let [x 4 path [1 2 3]]
    (into [] (dedupe) (conj path x)))

сорри, не самый быстрый, а в сравнении с вариантом 2
который я тестировал как

  (let [x 4 path [1 2 3]]
    (cond-> path (nil? (some (partial = x) path)) (conj x)))

ибо #{x} не самый шустрый вариант

(let [x 4 path [1 2 3]]
    (into [] (dedupe) (conj path x)))

👍

точнее

  (let [x 4 path [1 2 3]]
    (cond-> path (nil? (some #(== x %) path)) (conj x)))

  (let [x 4 path [1 2 3]]
    (cond-> path (nil? (some (partial = x) path)) (conj x)))

на бо́льших случайных (rand-int) списках этот вариант не меняется почти по времени, dedupe адово тормозит

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

про сомнительность согласен

А кто-то видел, кстати какую-то таблицу с бенчем разных функ?

(let [path (take 1000000 (repeatedly #(rand-int 100)))
      x (rand-int 100)
      a (time (cond-> path
                (nil? (some (partial = x) path)) (conj x)))      
      
      b (time (into [] (dedupe) (conj path x)))])

я наколенно так проверял (меняя аргумент в take)

(let [path (take 1000000 (repeatedly #(rand-int 100)))
      x (rand-int 100)
      a (time (cond-> path
                (nil? (some (partial = x) path)) (conj x)))      
      
      b (time (into [] (dedupe) (conj path x)))])

у тебя a ленивое и не реализуется, как я понимаю

(let [path (take 1000000 (repeatedly #(rand-int 100)))
      x (rand-int 100)
      a (time (cond-> path
                (nil? (some (partial = x) path)) (conj x)))      
      
      b (time (into [] (dedupe) (conj path x)))])

ты же в а не вектор получаешь

а ты прав, да

Пытался сделать dfs

тогда dedupe в два-три раза примерно быстрее

тут уже зависеть будет от набора данных
ибо если в данных первым элементом стоит искомый, то тут уже никакой вариант с обходом по всей коллекции не сравнится

ну я про рандом, в среднем 2-3 раза выходит в большинстве случаев

а вот если взять заведомо отсутствующий элемент в качестве x... 😊

мы так и не узнали кейс, да

то дедупе будет быстрее 😊

(let [path (into [] (take 1000000 (repeatedly #(rand-int 100))))
        x 101
        a (time (cond-> path
                  (nil? (some #(== x %) path)) (conj x)))

        b (time (into [] (dedupe) (conj path x)))])
"Elapsed time: 62.1621 msecs"
"Elapsed time: 43.835101 msecs"