Loops Clojure嵌套doseq循环

我是Clojure的新手，我有一个关于嵌套doseq循环的问题

我想迭代一个序列，得到一个子序列，然后得到一些键，将函数应用于所有序列元素

给定序列的结构大致如下，但包含数百本书、书架和许多图书馆：

([:state/libraries {6 #:library {:name "MUNICIPAL LIBRARY OF X" :id 6 
:shelves {3 #:shelf {:name "GREEN SHELF" :id 3 :books  
{45 #:book {:id 45 :name "NECRONOMICON" :pages {...}, 
{89 #:book {:id 89 :name "HOLY BIBLE" :pages {...}}}}}}}}])

这是我的密码：

(defn my-function []   (let [conn  (d/connect (-> my-system :config :datomic-uri))]
(doseq [library-seq (read-string (slurp "given-sequence.edn"))]
  (doseq [shelves-seq (val library-seq)]
    (library/create-shelf conn {:id (:shelf/id (val shelves-seq)) 
                                :name (:shelf/name (val shelves-seq))})
    (doseq [books-seq (:shelf/books (val shelves-seq))]
      (library/create-book conn (:shelf/id (val shelves-seq)) {:id (:book/id (val books-seq))
                                                               :name (:book/name (val books-seq))})
                                                               )))))

---

问题是我想摆脱嵌套的doseq混乱，但我不知道什么是最好的方法，因为在每次迭代中键都会改变。使用重现？减少也许我的想法是完全错误的？

就像Carcigenicate在评论中说的那样，假设图书馆/。。。函数只是副作用，您只需将其写入一个

doseq

(defn my-function []
  (let [conn  (d/connect (-> my-system :config :datomic-uri))]
    (doseq [library-seq (read-string (slurp "given-sequence.edn"))
            shelves-seq (val library-seq)
            :let [_ (library/create-shelf conn
                                          {:id (:shelf/id (val shelves-seq))
                                           :name (:shelf/name (val shelves-seq))})]
            books-seq (:shelf/books (val shelves-seq))]
      (library/create-book conn
                           (:shelf/id (val shelves-seq))
                           {:id (:book/id (val books-seq))
                            :name (:book/name (val books-seq))}))))

不过，我会将“连接到数据库”与“读取文件”与“写入数据库”分开。再加上一些解构，我最终会得到一些类似于：

(defn write-to-the-db [conn given-sequence]
  (doseq [library-seq given-sequence
          shelves-seq (val library-seq)
          :let [{shelf-id   :shelf/id,
                 shelf-name :shelf/name
                 books      :shelf/books} (val shelves-seq)
                _ (library/create-shelf conn {:id shelf-id, :name shelf-name})]
          {book-id :book/id, book-name :book/name} books]
    (library/create-book conn shelf-id {:id book-id, :name book-name})))

---

正如Carcigenicate在评论中所说，假设图书馆/。。。函数只是副作用，您只需将其写入一个

doseq

(defn my-function []
  (let [conn  (d/connect (-> my-system :config :datomic-uri))]
    (doseq [library-seq (read-string (slurp "given-sequence.edn"))
            shelves-seq (val library-seq)
            :let [_ (library/create-shelf conn
                                          {:id (:shelf/id (val shelves-seq))
                                           :name (:shelf/name (val shelves-seq))})]
            books-seq (:shelf/books (val shelves-seq))]
      (library/create-book conn
                           (:shelf/id (val shelves-seq))
                           {:id (:book/id (val books-seq))
                            :name (:book/name (val books-seq))}))))

不过，我会将“连接到数据库”与“读取文件”与“写入数据库”分开。再加上一些解构，我最终会得到一些类似于：

(defn write-to-the-db [conn given-sequence]
  (doseq [library-seq given-sequence
          shelves-seq (val library-seq)
          :let [{shelf-id   :shelf/id,
                 shelf-name :shelf/name
                 books      :shelf/books} (val shelves-seq)
                _ (library/create-shelf conn {:id shelf-id, :name shelf-name})]
          {book-id :book/id, book-name :book/name} books]
    (library/create-book conn shelf-id {:id book-id, :name book-name})))

---

library/create-*

函数完全通过副作用发挥作用？他们没有返回任何东西？如果是这样的话，嵌套的剂量可能是这里最整洁的。请注意，至少对于前两个doseq，您可以将其压缩为

（doseq[库顺序…，架顺序…]）

。对于每个序列，您不需要新的

doseq

。它们可以像

for

s那样分组。

library/create-*

函数完全通过副作用发挥作用？他们没有返回任何东西？如果是这样的话，嵌套的剂量可能是这里最整洁的。请注意，至少对于前两个doseq，您可以将其压缩为

（doseq[库顺序…，架顺序…]）

。对于每个序列，您不需要新的

doseq

。它们可以像fors那样分组。基本上就是我在头脑中散列的东西。虽然

（library/create shelf

部分很不幸。我几乎会给第三个seq自己的

doseq

，这样

let

就不会被用来产生副作用了。是的，我同意这有点恶心。a

：do

如果它存在的话会更好。基本上就是我脑海中散列的内容（库/创建书架部分很不幸。我几乎会给第三个seq自己的

doseq

，这样

let

就不会被用来产生副作用。是的，我同意这有点恶心。如果它存在的话，

：do

会更好。