Question

如果我有一个向量(def v [1 2 3])，我可以用(assoc v 0 666)替换第一个元素，获取[666 2 3]

但如果我在映射矢量后尝试做同样的事情：

(def v (map inc [1 2 3]))
(assoc v 0 666)

抛出以下异常：

ClassCastException clojure.lang.LazySeq cannot be cast to clojure.lang.Associative

编辑或更新惰性序列的单个元素的最常用的方法是什么？

我应该使用map-indexed并仅更改索引0或将惰性序列实现为向量，然后通过assoc / update进行编辑吗？第一个是保持懒惰的优势，而第二个是效率较低但可能更明显。

我想第一个元素我也可以使用drop和cons。还有其他方法吗？我无法在任何地方找到任何例子。

Answer 1

编辑或更新懒惰序列的单个元素的最常用方法是什么？

没有用于修改序列/列表的单个元素的内置函数，但map-indexed可能是最接近的事物。它不是列表的有效操作。假设你不需要懒惰，我会将序列倒入一个向量中，这就是mapv所做的，即(into [] (map f coll))。根据您使用修改后序列的方式，对其进行矢量化和修改可能同样有效。

您可以使用map-indexed编写一个函数来执行类似和懒惰的操作：

(defn assoc-seq [s i v]
  (map-indexed (fn [j x] (if (= i j) v x)) s))

或者，如果你想在没有矢量化的情况下懒散地完成这项工作，你也可以使用传感器：

(sequence
  (comp
    (map inc)
    (map-indexed (fn [j x] (if (= 0 j) 666 x))))
  [1 2 3])

实现你的用例只是修改懒惰序列中的第一项，然后你可以做一些更简单的事情，同时保留懒惰：

(concat [666] (rest s))

更新re：评论优化：leetwinski＆＃39; assoc-at函数在更新1,000,000元素懒惰序列中的第500,000个元素时快〜8ms，所以你应该使用他的答案希望从本质上效率低下的操作中挤出一切性能：

(def big-lazy (range 1e6))

(crit/bench
  (last (assoc-at big-lazy 500000 666)))
Evaluation count : 1080 in 60 samples of 18 calls.
            Execution time mean : 51.567317 ms
    Execution time std-deviation : 4.947684 ms
  Execution time lower quantile : 47.038877 ms ( 2.5%)
  Execution time upper quantile : 65.604790 ms (97.5%)
                  Overhead used : 1.662189 ns

Found 6 outliers in 60 samples (10.0000 %)
  low-severe     4 (6.6667 %)
  low-mild   2 (3.3333 %)
Variance from outliers : 68.6139 % Variance is severely inflated by outliers
=> nil

(crit/bench
  (last (assoc-seq big-lazy 500000 666)))
Evaluation count : 1140 in 60 samples of 19 calls.
            Execution time mean : 59.553335 ms
    Execution time std-deviation : 4.507430 ms
  Execution time lower quantile : 54.450115 ms ( 2.5%)
  Execution time upper quantile : 69.288104 ms (97.5%)
                  Overhead used : 1.662189 ns

Found 4 outliers in 60 samples (6.6667 %)
  low-severe     4 (6.6667 %)
Variance from outliers : 56.7865 % Variance is severely inflated by outliers
=> nil

在大型延迟序列中更新第一个项时，assoc-at版本的速度提高了2-3倍，但速度并不比(last (concat [666] (rest big-lazy)))快。

Answer 2

如果真的需要这个功能（我强烈怀疑），我可能会选择像这样的通用东西：

(defn assoc-at [data i item]
  (if (associative? data)
    (assoc data i item)
    (if-not (neg? i)
      (letfn [(assoc-lazy [i data]
                (cond (zero? i) (cons item (rest data))
                      (empty? data) data
                      :else (lazy-seq (cons (first data)
                                            (assoc-lazy (dec i) (rest data))))))]
        (assoc-lazy i data))
      data)))

user> (assoc-at {:a 10} :b 20)
;; {:a 10, :b 20}

user> (assoc-at [1 2 3 4] 3 101)
;; [1 2 3 101]

user> (assoc-at (map inc [1 2 3 4]) 2 123)
;; (2 3 123 5)

另一种方法是使用split-at：

(defn assoc-at [data i item]
  (if (neg? i)
    data
    (let [[l r] (split-at i data)]
      (if (seq r)
        (concat l [item] (rest r))
        data))))

注意这两个函数都会使coll遍历短路，哪种映射方法不会。这里有一些快速而肮脏的基准：

(defn massoc-at [data i item]
  (if (neg? i)
    data
    (map-indexed (fn [j x] (if (== i j) item x)) data)))

(time (last (assoc-at (range 10000000) 0 1000)))
;;=> "Elapsed time: 747.921032 msecs"
9999999

(time (last (massoc-at (range 10000000) 0 1000)))
;;=> "Elapsed time: 1525.446511 msecs"
9999999

关联或更新Clojure列表和延迟序列

2 个答案: